mcs/class/corlib/Test/System/VersionTest.cs

   1 //
   2 // VersionTest.cs - NUnit Test Cases for the System.Version class
   3 //
   4 // Authors:
   5 //      Duco Fijma (duco@lorentz.xs4all.nl)
   6 //      Sebastien Pouliot  <sebastien@ximian.com>
   7 //
   8 //   (C) 2002 Duco Fijma
   9 // Copyright (C) 2006 Novell, Inc (http://www.novell.com)
  10 //
  11
  12 using System;
  13
  14 using NUnit.Framework;
  15
  16 namespace MonoTests.System
  17 {
  18         [TestFixture]
  19         public class VersionTest
  20         {
  21                 [Test]
  22                 public void TestCtors ()
  23                 {
  24                         Version v1 = new Version ();
  25                         Assert.AreEqual (0, v1.Major, "#A1");
  26                         Assert.AreEqual (0, v1.Minor, "#A2");
  27                         Assert.AreEqual (-1, v1.Build, "#A3");
  28                         Assert.AreEqual (-1, v1.Revision, "#A4");
  29
  30                         v1 = new Version (23, 7);
  31                         Assert.AreEqual (23, v1.Major, "#B1");
  32                         Assert.AreEqual (7, v1.Minor, "#B2");
  33                         Assert.AreEqual (-1, v1.Build, "#B3");
  34                         Assert.AreEqual (-1, v1.Revision, "#B4");
  35
  36                         v1 = new Version (23, 7, 99);
  37                         Assert.AreEqual (23, v1.Major, "#C1");
  38                         Assert.AreEqual (7, v1.Minor, "#C2");
  39                         Assert.AreEqual (99, v1.Build, "#C3");
  40                         Assert.AreEqual (-1, v1.Revision, "#C4");
  41
  42                         v1 = new Version (23, 7, 99, 42);
  43                         Assert.AreEqual (23, v1.Major, "#D1");
  44                         Assert.AreEqual (7, v1.Minor, "#D2");
  45                         Assert.AreEqual (99, v1.Build, "#D3");
  46                         Assert.AreEqual (42, v1.Revision, "#D4");
  47
  48                         try {
  49                                 v1 = new Version (23, -1);
  50                                 Assert.Fail ("#E");
  51                         } catch (ArgumentOutOfRangeException) {
  52                         }
  53
  54                         try {
  55                                 v1 = new Version (23, 7, -1);
  56                                 Assert.Fail ("#F");
  57                         } catch (ArgumentOutOfRangeException) {
  58                         }
  59
  60                         try {
  61                                 v1 = new Version (23, 7, 99, -1);
  62                                 Assert.Fail ("#G");
  63                         } catch (ArgumentOutOfRangeException) {
  64                         }
  65                 }
  66
  67                 [Test]
  68                 public void TestStringCtor ()
  69                 {
  70                         Version v1 = new Version ("1.42");
  71                         Assert.AreEqual (1, v1.Major, "#A1");
  72                         Assert.AreEqual (42, v1.Minor, "#A2");
  73                         Assert.AreEqual (-1, v1.Build, "#A3");
  74                         Assert.AreEqual (-1, v1.Revision, "#A4");
  75
  76                         v1 = new Version ("1.42.79");
  77                         Assert.AreEqual (1, v1.Major, "#B1");
  78                         Assert.AreEqual (42, v1.Minor, "#B2");
  79                         Assert.AreEqual (79, v1.Build, "#B3");
  80                         Assert.AreEqual (-1, v1.Revision, "#B4");
  81
  82                         v1 = new Version ("1.42.79.66");
  83                         Assert.AreEqual (1, v1.Major, "#C1");
  84                         Assert.AreEqual (42, v1.Minor, "#C2");
  85                         Assert.AreEqual (79, v1.Build, "#C3");
  86                         Assert.AreEqual (66, v1.Revision, "#C4");
  87
  88                         try {
  89                                 v1 = new Version ("1.42.-79");
  90                                 Assert.Fail ("#D");
  91                         } catch (ArgumentOutOfRangeException) {
  92                         }
  93
  94                         try {
  95                                 v1 = new Version ("1");
  96                                 Assert.Fail ("#E");
  97                         } catch (ArgumentException) {
  98                         }
  99
 100                         try {
 101                                 v1 = new Version ("1.2.3.4.5");
 102                                 Assert.Fail ("#F");
 103                         } catch (ArgumentException) {
 104                         }
 105
 106                         try {
 107                                 v1 = new Version ((string) null);
 108                                 Assert.Fail ("#G");
 109                         } catch (ArgumentNullException) {
 110                         }
 111                 }
 112
 113                 [Test]
 114                 public void TestClone ()
 115                 {
 116                         Version v1 = new Version (1, 2, 3, 4);
 117                         Version v2 = (Version) v1.Clone ();
 118
 119                         Assert.IsTrue (v1.Equals (v2), "#A1");
 120                         Assert.IsFalse (object.ReferenceEquals (v1, v2), "#A2");
 121
 122                         Version v3 = new Version (); // 0.0
 123                         v2 = (Version) v3.Clone ();
 124
 125                         Assert.IsTrue (v3.Equals (v2), "#B1");
 126                         Assert.IsFalse (object.ReferenceEquals (v3, v2), "#B2");
 127                 }
 128
 129                 [Test]
 130                 public void TestCompareTo ()
 131                 {
 132                         Assert.AreEqual (1, new Version (1, 2).CompareTo (new Version (1, 1)), "#A1");
 133                         Assert.AreEqual (-1, new Version (1, 2, 3).CompareTo (new Version (2, 2, 3)), "#A2");
 134                         Assert.AreEqual (1, new Version (1, 2, 3, 4).CompareTo (new Version (1, 2, 2, 1)), "#A3");
 135                         Assert.AreEqual (1, new Version (1, 3).CompareTo (new Version (1, 2, 2, 1)), "#A4");
 136                         Assert.AreEqual (-1, new Version (1, 2, 2).CompareTo (new Version (1, 2, 2, 1)), "#A5");
 137                         Assert.AreEqual (0, new Version (1, 2).CompareTo (new Version (1, 2)), "#A6");
 138                         Assert.AreEqual (0, new Version (1, 2, 3).CompareTo (new Version (1, 2, 3)), "#A7");
 139                         Assert.IsTrue (new Version (1, 1) < new Version (1, 2), "#A8");
 140                         Assert.IsTrue (new Version (1, 2) <= new Version (1, 2), "#A9");
 141                         Assert.IsTrue (new Version (1, 2) <= new Version (1, 3), "#A10");
 142                         Assert.IsTrue (new Version (1, 2) >= new Version (1, 2), "#A11");
 143                         Assert.IsTrue (new Version (1, 3) >= new Version (1, 2), "#A12");
 144                         Assert.IsTrue (new Version (1, 3) > new Version (1, 2), "#A13");
 145
 146                         Version v1 = new Version(1, 2);
 147                         bool exception;
 148
 149                         Assert.AreEqual (1, v1.CompareTo (null), "#B");
 150
 151                         try {
 152                                 v1.CompareTo ("A string is not a version");
 153                                 Assert.Fail ("#C");
 154                         } catch (ArgumentException) {
 155                         }
 156                 }
 157
 158                 [Test]
 159                 public void TestEquals ()
 160                 {
 161                         Version v1 = new Version (1, 2);
 162                         Version v2 = new Version (1, 2, 3, 4);
 163                         Version v3 = new Version (1, 2, 3, 4);
 164
 165                         Assert.IsTrue (v2.Equals (v3), "#A1");
 166                         Assert.IsTrue (v2.Equals (v2), "#A2");
 167                         Assert.IsFalse (v1.Equals (v3), "#A3");
 168
 169                         Assert.IsTrue (v2 == v3, "#B1");
 170 #pragma warning disable 1718
 171                         Assert.IsTrue (v2 == v2, "#B2");
 172 #pragma warning restore 1718
 173                         Assert.IsFalse (v1 == v3, "#B3");
 174
 175                         Assert.IsFalse (v2.Equals ((Version) null), "#C1");
 176                         Assert.IsFalse (v2.Equals ("A string"), "#C2");
 177                 }
 178
 179                 [Test]
 180                 public void TestToString ()
 181                 {
 182                         Version v1 = new Version (1,2);
 183                         Version v2 = new Version (1,2,3);
 184                         Version v3 = new Version (1,2,3,4);
 185
 186                         Assert.AreEqual ("1.2", v1.ToString (), "#A1");
 187                         Assert.AreEqual ("1.2.3", v2.ToString (), "#A2");
 188                         Assert.AreEqual ("1.2.3.4", v3.ToString (), "#A3");
 189                         Assert.AreEqual (string.Empty, v3.ToString (0), "#A4");
 190                         Assert.AreEqual ("1", v3.ToString (1), "#A5");
 191                         Assert.AreEqual ("1.2", v3.ToString (2), "#A6");
 192                         Assert.AreEqual ("1.2.3", v3.ToString (3), "#A7");
 193                         Assert.AreEqual ("1.2.3.4", v3.ToString (4), "#A8");
 194
 195                         try {
 196                                 v2.ToString (4);
 197                                 Assert.Fail ("#B");
 198                         } catch (ArgumentException) {
 199                         }
 200
 201                         try {
 202                                 v3.ToString (42);
 203                                 Assert.Fail ("#C");
 204                         } catch (ArgumentException) {
 205                         }
 206                 }
 207
 208                 [Test]
 209                 public void HashCode ()
 210                 {
 211                         Version v1 = new Version ("1.2.3.4");
 212                         Version v2 = new Version (1, 2, 3, 4);
 213                         Assert.AreEqual (v1.GetHashCode (), v2.GetHashCode (), "HashCode");
 214                 }
 215                 [Test]
 216                 public void MajorMinorRevisions ()
 217                 {
 218                         Version v = new Version ();
 219                         Assert.AreEqual (-1, v.MajorRevision, "MajorRevision/Empty");
 220                         Assert.AreEqual (-1, v.MinorRevision, "MinorRevision/Empty");
 221                         v = new Version ("1.2.3.4");
 222                         Assert.AreEqual (0, v.MajorRevision, "MajorRevision/string");
 223                         Assert.AreEqual (4, v.MinorRevision, "MinorRevision/string");
 224                         v = new Version (1, 2);
 225                         Assert.AreEqual (-1, v.MajorRevision, "MajorRevision/int,int");
 226                         Assert.AreEqual (-1, v.MinorRevision, "MinorRevision/int,int");
 227                         v = new Version (10, 20, 30);
 228                         Assert.AreEqual (-1, v.MajorRevision, "MajorRevision/int,int,int");
 229                         Assert.AreEqual (-1, v.MinorRevision, "MinorRevision/int,int,int");
 230                         v = new Version (100, 200, 300, 400);
 231                         Assert.AreEqual (0, v.MajorRevision, "MajorRevision/int,int,int,int");
 232                         Assert.AreEqual (400, v.MinorRevision, "MinorRevision/int,int,int,int");
 233                         v = new Version (100, 200, 300, (256 << 16) | 384);
 234                         Assert.AreEqual (256, v.MajorRevision, "MajorRevision/int,int,int,bint");
 235                         Assert.AreEqual (384, v.MinorRevision, "MinorRevision/int,int,int,bint");
 236                 }
 237
 238                 [Test]
 239                 public void CompareTo ()
 240                 {
 241                         Version v1234 = new Version (1, 2, 3, 4);
 242                         Version vnull = null;
 243                         Assert.AreEqual (1, v1234.CompareTo (vnull), "1234-null");
 244                         Version v2234 = new Version (2, 2, 3, 4);
 245                         Assert.AreEqual (1, v2234.CompareTo (v1234), "2234-1234");
 246                         Version v1224 = new Version (1, 2, 2, 4);
 247                         Assert.AreEqual (-1, v1224.CompareTo (v1234), "1224-1234");
 248                         Version v1235 = new Version (1, 2, 3, 5);
 249                         Assert.AreEqual (1, v1235.CompareTo (v1234), "1235-1234");
 250                 }
 251
 252                 [Test]
 253                 public void Parse ()
 254                 {
 255                         Assert.AreEqual (new Version (1, 7), Version.Parse ("1.7"), "#A1");
 256                         Assert.AreEqual (new Version (1, 7, 3), Version.Parse ("1.7.3"), "#A2");
 257                         Assert.AreEqual (new Version (1, 7, 3, 4001), Version.Parse ("1.7.3.4001"), "#A3");
 258                         Assert.AreEqual (new Version (2, 9), Version.Parse ("  2.9  "), "#A4");
 259                         Assert.AreEqual (new Version (2, 9, 3), Version.Parse ("2. 9. 3"), "#A5");
 260
 261                         try {
 262                                 Version.Parse (null);
 263                                 Assert.Fail ("#EXC1");
 264                         } catch (ArgumentNullException) {
 265                         }
 266
 267                         try {
 268                                 Version.Parse ("1");
 269                                 Assert.Fail ("#EXC2");
 270                         } catch (ArgumentException) {
 271                         }
 272
 273                         try {
 274                                 Version.Parse ("1.4.7.8.9");
 275                                 Assert.Fail ("#EXC3");
 276                         } catch (ArgumentException) {
 277                         }
 278
 279                         try {
 280                                 Version.Parse ("1.2.a.7");
 281                                 Assert.Fail ("#EXC4");
 282                         } catch (FormatException) {
 283                         }
 284
 285                         try {
 286                                 Version.Parse ("1.2.");
 287                                 Assert.Fail ("#EXC5");
 288                         } catch (FormatException) {
 289                         }
 290
 291                         try {
 292                                 Version.Parse ("1.2.0." + ((long)Int32.MaxValue + 1).ToString ());
 293                                 Assert.Fail ("#EXC6");
 294                         } catch (OverflowException) {
 295                         }
 296
 297                         try {
 298                                 Version.Parse ("1.3.-6.0");
 299                                 Assert.Fail ("#EXC7");
 300                         } catch (ArgumentOutOfRangeException) {
 301                         }
 302                 }
 303
 304                 [Test]
 305                 public void TryParse ()
 306                 {
 307                         Version result;
 308                         bool success;
 309
 310                         success = Version.TryParse ("1.7", out result);
 311                         Assert.AreEqual (new Version (1, 7), result, "#A1");
 312                         Assert.AreEqual (true, success, "#A2");
 313
 314                         success = Version.TryParse ("1.7.3", out result);
 315                         Assert.AreEqual (new Version (1, 7, 3), result, "#B1");
 316                         Assert.AreEqual (true, success, "#B2");
 317
 318                         success = Version.TryParse ("1.7.0.4001", out result);
 319                         Assert.AreEqual (new Version (1, 7, 0, 4001), result, "#C1");
 320                         Assert.AreEqual (true, success, "#C2");
 321
 322                         success = Version.TryParse ("  2.9  ", out result);
 323                         Assert.AreEqual (new Version (2, 9), result, "#D1");
 324                         Assert.AreEqual (true, success, "#D2");
 325
 326                         success = Version.TryParse ("2. 9. 3", out result);
 327                         Assert.AreEqual (new Version (2, 9, 3), result, "#E1");
 328                         Assert.AreEqual (true, success, "#E2");
 329
 330                         //
 331                         // Errors
 332                         //
 333                         success = Version.TryParse (null, out result);
 334                         Assert.AreEqual (null, result, "#F1");
 335                         Assert.AreEqual (false, success, "#F2");
 336
 337                         success = Version.TryParse ("1", out result);
 338                         Assert.AreEqual (null, result, "#G1");
 339                         Assert.AreEqual (false, success, "#G2");
 340
 341                         success = Version.TryParse ("1.4.7.8.9", out result);
 342                         Assert.AreEqual (null, result, "#H1");
 343                         Assert.AreEqual (false, success, "#H2");
 344
 345                         success = Version.TryParse ("1.2.a.7", out result);
 346                         Assert.AreEqual (null, result, "#I1");
 347                         Assert.AreEqual (false, success, "#I2");
 348
 349                         success = Version.TryParse ("1.2.", out result);
 350                         Assert.AreEqual (null, result, "#J1");
 351                         Assert.AreEqual (false, success, "#J2");
 352
 353                         success = Version.TryParse ("1.2.0." + ((long)Int32.MaxValue + 1).ToString (), out result);
 354                         Assert.AreEqual (null, result, "#K1");
 355                         Assert.AreEqual (false, success, "#K2");
 356
 357                         success = Version.TryParse ("1.-6", out result);
 358                         Assert.AreEqual (null, result, "#L1");
 359                         Assert.AreEqual (false, success, "#L2");
 360                 }
 361         }
 362 }