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

   1 //
   2 // TimeSpanTest.cs - NUnit Test Cases for the System.TimeSpan struct
   3 //
   4 // Authors:
   5 //      Duco Fijma (duco@lorentz.xs4all.nl)
   6 //      Sebastien Pouliot  <sebastien@ximian.com>
   7 //
   8 // (C) 2001 Duco Fijma
   9 // Copyright (C) 2004 Novell (http://www.novell.com)
  10 //
  11
  12 using NUnit.Framework;
  13 using System;
  14
  15 namespace MonoTests.System
  16 {
  17
  18 [TestFixture]
  19 public class TimeSpanTest : Assertion {
  20
  21         private void Debug (TimeSpan ts)
  22         {
  23                 Console.Out.WriteLine ("Days {0}", ts.Days);
  24                 Console.Out.WriteLine ("Hours {0}", ts.Hours);
  25                 Console.Out.WriteLine ("Minutes {0}", ts.Minutes);
  26                 Console.Out.WriteLine ("Seconds {0}", ts.Seconds);
  27                 Console.Out.WriteLine ("Milliseconds {0}", ts.Milliseconds);
  28                 Console.Out.WriteLine ("Ticks {0}", ts.Ticks);
  29         }
  30
  31         public void TestCtors ()
  32         {
  33                 TimeSpan t1 = new TimeSpan (1234567890);
  34
  35                 AssertEquals ("A1", "00:02:03.4567890", t1.ToString ());
  36                 t1 = new TimeSpan (1,2,3);
  37                 AssertEquals ("A2", "01:02:03", t1.ToString ());
  38                 t1 = new TimeSpan (1,2,3,4);
  39                 AssertEquals ("A3", "1.02:03:04", t1.ToString ());
  40                 t1 = new TimeSpan (1,2,3,4,5);
  41                 AssertEquals ("A4", "1.02:03:04.0050000", t1.ToString ());
  42                 t1 = new TimeSpan (-1,2,-3,4,-5);
  43                 AssertEquals ("A5", "-22:02:56.0050000", t1.ToString ());
  44                 t1 = new TimeSpan (0,25,0,0,0);
  45                 AssertEquals ("A6", "1.01:00:00", t1.ToString ());
  46         }
  47
  48         [Test]
  49         [ExpectedException (typeof (ArgumentOutOfRangeException))]
  50         public void DaysOverflow ()
  51         {
  52                 int days = (int) (Int64.MaxValue / TimeSpan.TicksPerDay) + 1;
  53                 TimeSpan ts = new TimeSpan (days, 0, 0, 0, 0);
  54         }
  55
  56         [Test]
  57 #if NET_2_0
  58         [ExpectedException (typeof (ArgumentOutOfRangeException))]
  59         [Category ("NotWorking")]
  60 #endif
  61         public void TemporaryOverflow ()
  62         {
  63                 // calculating part of this results in overflow (days)
  64                 // but the negative hours, minutes, seconds & ms correct this
  65                 int days = (int) (Int64.MaxValue / TimeSpan.TicksPerDay) + 1;
  66                 TimeSpan ts = new TimeSpan (days, Int32.MinValue, Int32.MinValue, Int32.MinValue, Int32.MinValue);
  67                 AssertEquals ("Days", 10650320, ts.Days);
  68                 AssertEquals ("Hours", 0, ts.Hours);
  69                 AssertEquals ("Minutes", 14, ts.Minutes);
  70                 AssertEquals ("Seconds", 28, ts.Seconds);
  71                 AssertEquals ("Milliseconds", 352, ts.Milliseconds);
  72                 AssertEquals ("Ticks", 9201876488683520000, ts.Ticks);
  73         }
  74
  75         [Test]
  76 #if NET_2_0
  77         [ExpectedException (typeof (ArgumentOutOfRangeException))]
  78         [Category ("NotWorking")]
  79 #endif
  80         public void NoOverflowInHoursMinsSecondsMS ()
  81         {
  82                 TimeSpan ts = new TimeSpan (0, Int32.MaxValue, Int32.MaxValue, Int32.MaxValue, Int32.MaxValue);
  83                 AssertEquals ("Days", 24879, ts.Days);
  84                 AssertEquals ("Hours", 22, ts.Hours);
  85                 AssertEquals ("Minutes", 44, ts.Minutes);
  86                 AssertEquals ("Seconds", 30, ts.Seconds);
  87                 AssertEquals ("Milliseconds", 647, ts.Milliseconds);
  88                 AssertEquals ("Ticks", 21496274706470000, ts.Ticks);
  89         }
  90
  91         [Test]
  92         [ExpectedException (typeof (ArgumentOutOfRangeException))]
  93         public void MaxDays ()
  94         {
  95                 new TimeSpan (Int32.MaxValue, 0, 0, 0, 0);
  96         }
  97
  98         [Test]
  99         [ExpectedException (typeof (ArgumentOutOfRangeException))]
 100         public void MinDays ()
 101         {
 102                 new TimeSpan (Int32.MinValue, 0, 0, 0, 0);
 103         }
 104
 105         [Test]
 106         [Ignore ("too long")]
 107         public void MaxHours_TooLong ()
 108         {
 109                 // LAMESPEC: the highest hours are "special"
 110                 for (int i=0; i < 596523; i++) {
 111                         TimeSpan ts = new TimeSpan (0, Int32.MaxValue - i, 0, 0, 0);
 112                         int h = i + 1;
 113                         string prefix = i.ToString () + '-';
 114                         AssertEquals (prefix + "Days", -(h / 24), ts.Days);
 115                         AssertEquals (prefix + "Hours", -(h % 24), ts.Hours);
 116                         AssertEquals (prefix + "Minutes", 0, ts.Minutes);
 117                         AssertEquals (prefix + "Seconds", 0, ts.Seconds);
 118                         AssertEquals (prefix + "Milliseconds", 0, ts.Milliseconds);
 119                         AssertEquals (prefix + "Ticks", -36000000000 * h, ts.Ticks);
 120                 }
 121         }
 122
 123         [Test]
 124 #if NET_2_0
 125         [ExpectedException (typeof (ArgumentOutOfRangeException))]
 126         [Category ("NotWorking")]
 127 #endif
 128         public void MaxHours ()
 129         {
 130                 // LAMESPEC: the highest hours are "special"
 131                 TimeSpan ts = new TimeSpan (0, Int32.MaxValue, 0, 0, 0);
 132                 AssertEquals ("Max-Days", 0, ts.Days);
 133                 AssertEquals ("Max-Hours", -1, ts.Hours);
 134                 AssertEquals ("Max-Minutes", 0, ts.Minutes);
 135                 AssertEquals ("Max-Seconds", 0, ts.Seconds);
 136                 AssertEquals ("Max-Milliseconds", 0, ts.Milliseconds);
 137                 AssertEquals ("Max-Ticks", -36000000000, ts.Ticks);
 138
 139                 ts = new TimeSpan (0, Int32.MaxValue - 596522, 0, 0, 0);
 140                 AssertEquals ("Days", -24855, ts.Days);
 141                 AssertEquals ("Hours", -3, ts.Hours);
 142                 AssertEquals ("Minutes", 0, ts.Minutes);
 143                 AssertEquals ("Seconds", 0, ts.Seconds);
 144                 AssertEquals ("Milliseconds", 0, ts.Milliseconds);
 145                 AssertEquals ("Ticks", -21474828000000000, ts.Ticks);
 146         }
 147
 148         [Test]
 149 #if NET_2_0
 150         [ExpectedException (typeof (ArgumentOutOfRangeException))]
 151         [Category ("NotWorking")]
 152 #endif
 153         public void MaxHours_BreakPoint ()
 154         {
 155                 TimeSpan ts = new TimeSpan (0, Int32.MaxValue - 596523, 0, 0, 0);
 156                 AssertEquals ("Days", 24855, ts.Days);
 157                 AssertEquals ("Hours", 2, ts.Hours);
 158                 AssertEquals ("Minutes", 28, ts.Minutes);
 159                 AssertEquals ("Seconds", 16, ts.Seconds);
 160                 AssertEquals ("Milliseconds", 0, ts.Milliseconds);
 161                 AssertEquals ("Ticks", 21474808960000000, ts.Ticks);
 162         }
 163
 164         [Test]
 165         [Ignore ("too long")]
 166         public void MinHours_TooLong ()
 167         {
 168                 // LAMESPEC: the lowest hours are "special"
 169                 for (int i=Int32.MinValue; i < -2146887124; i++) {
 170                         TimeSpan ts = new TimeSpan (0, i, 0, 0, 0);
 171                         int h = i + Int32.MaxValue + 1;
 172                         string prefix = i.ToString () + '-';
 173                         AssertEquals (prefix + "Days", (h / 24), ts.Days);
 174                         AssertEquals (prefix + "Hours", (h % 24), ts.Hours);
 175                         AssertEquals (prefix + "Minutes", 0, ts.Minutes);
 176                         AssertEquals (prefix + "Seconds", 0, ts.Seconds);
 177                         AssertEquals (prefix + "Milliseconds", 0, ts.Milliseconds);
 178                         AssertEquals (prefix + "Ticks", 36000000000 * h, ts.Ticks);
 179                 }
 180         }
 181
 182         [Test]
 183 #if NET_2_0
 184         [Category ("NotWorking")]
 185 #endif
 186         public void MinHours ()
 187         {
 188 #if NET_2_0
 189                 TimeSpan ts = new TimeSpan (0, -256204778, 0, 0, 0);
 190                 AssertEquals ("Days", -10675199, ts.Days);
 191                 AssertEquals ("Hours", -2, ts.Hours);
 192                 AssertEquals ("Minutes", 0, ts.Minutes);
 193                 AssertEquals ("Seconds", 0, ts.Seconds);
 194                 AssertEquals ("Milliseconds", 0, ts.Milliseconds);
 195                 AssertEquals ("Ticks", -9223372008000000000, ts.Ticks);
 196 #else
 197                 // LAMESPEC: the lowest hours are "special"
 198                 TimeSpan ts = new TimeSpan (0, Int32.MinValue, 0, 0, 0);
 199                 AssertEquals ("Min-Days", 0, ts.Days);
 200                 AssertEquals ("Min-Hours", 0, ts.Hours);
 201                 AssertEquals ("Min-Minutes", 0, ts.Minutes);
 202                 AssertEquals ("Min-Seconds", 0, ts.Seconds);
 203                 AssertEquals ("Min-Milliseconds", 0, ts.Milliseconds);
 204                 AssertEquals ("Min-Ticks", 0, ts.Ticks);
 205
 206                 ts = new TimeSpan (0, -2146887125, 0, 0, 0);
 207                 AssertEquals ("Days", 24855, ts.Days);
 208                 AssertEquals ("Hours", 3, ts.Hours);
 209                 AssertEquals ("Minutes", 0, ts.Minutes);
 210                 AssertEquals ("Seconds", 0, ts.Seconds);
 211                 AssertEquals ("Milliseconds", 0, ts.Milliseconds);
 212                 AssertEquals ("Ticks", 21474828000000000, ts.Ticks);
 213 #endif
 214         }
 215
 216         [Test]
 217 #if NET_2_0
 218         [ExpectedException (typeof (ArgumentOutOfRangeException))]
 219         [Category ("NotWorking")]
 220 #endif
 221         public void MinHours_BreakPoint ()
 222         {
 223                 TimeSpan ts = new TimeSpan (0, -2146887124, 0, 0, 0);
 224                 AssertEquals ("Days", -24855, ts.Days);
 225                 AssertEquals ("Hours", -2, ts.Hours);
 226                 AssertEquals ("Minutes", -28, ts.Minutes);
 227                 AssertEquals ("Seconds", -16, ts.Seconds);
 228                 AssertEquals ("Milliseconds", 0, ts.Milliseconds);
 229                 AssertEquals ("Ticks", -21474808960000000, ts.Ticks);
 230         }
 231
 232         [Test]
 233         [Ignore ("too long")]
 234         public void MaxMinutes_TooLong ()
 235         {
 236                 // LAMESPEC: the highest minutes are "special"
 237                 for (int i=0; i < 35791394; i++) {
 238                         TimeSpan ts = new TimeSpan (0, 0, Int32.MaxValue - i, 0, 0);
 239                         long h = -(i + 1);
 240                         string prefix = i.ToString () + '-';
 241                         AssertEquals (prefix + "Days", (h / 1440), ts.Days);
 242                         AssertEquals (prefix + "Hours", ((h / 60) % 24), ts.Hours);
 243                         AssertEquals (prefix + "Minutes", (h % 60), ts.Minutes);
 244                         AssertEquals (prefix + "Seconds", 0, ts.Seconds);
 245                         AssertEquals (prefix + "Milliseconds", 0, ts.Milliseconds);
 246                         AssertEquals (prefix + "Ticks", (600000000L * h), ts.Ticks);
 247                 }
 248         }
 249
 250         [Test]
 251 #if NET_2_0
 252         [Category ("NotWorking")]
 253 #endif
 254         public void MaxMinutes ()
 255         {
 256                 TimeSpan ts;
 257 #if NET_2_0
 258                 ts = new TimeSpan (0, 0, 256204778, 0, 0);
 259                 AssertEquals ("Max-Days", 177919, ts.Days);
 260                 AssertEquals ("Max-Hours", 23, ts.Hours);
 261                 AssertEquals ("Max-Minutes", 38, ts.Minutes);
 262                 AssertEquals ("Max-Seconds", 0, ts.Seconds);
 263                 AssertEquals ("Max-Milliseconds", 0, ts.Milliseconds);
 264                 AssertEquals ("Max-Ticks", 153722866800000000, ts.Ticks);
 265 #else
 266                 // LAMESPEC: the highest minutes are "special"
 267                 ts = new TimeSpan (0, 0, Int32.MaxValue, 0, 0);
 268                 AssertEquals ("Max-Days", 0, ts.Days);
 269                 AssertEquals ("Max-Hours", 0, ts.Hours);
 270                 AssertEquals ("Max-Minutes", -1, ts.Minutes);
 271                 AssertEquals ("Max-Seconds", 0, ts.Seconds);
 272                 AssertEquals ("Max-Milliseconds", 0, ts.Milliseconds);
 273                 AssertEquals ("Max-Ticks", -600000000, ts.Ticks);
 274
 275                 ts = new TimeSpan (0, 0, Int32.MaxValue - 35791393, 0, 0);
 276                 AssertEquals ("Days", -24855, ts.Days);
 277                 AssertEquals ("Hours", -3, ts.Hours);
 278                 AssertEquals ("Minutes", -14, ts.Minutes);
 279                 AssertEquals ("Seconds", 0, ts.Seconds);
 280                 AssertEquals ("Milliseconds", 0, ts.Milliseconds);
 281                 AssertEquals ("Ticks", -21474836400000000, ts.Ticks);
 282 #endif
 283         }
 284
 285         [Test]
 286 #if NET_2_0
 287         [ExpectedException (typeof (ArgumentOutOfRangeException))]
 288         [Category ("NotWorking")]
 289 #endif
 290         public void MaxMinutes_BreakPoint ()
 291         {
 292                 TimeSpan ts = new TimeSpan (0, Int32.MaxValue - 35791394, 0, 0, 0);
 293                 AssertEquals ("Days", 0, ts.Days);
 294                 AssertEquals ("Hours", 0, ts.Hours);
 295                 AssertEquals ("Minutes", -52, ts.Minutes);
 296                 AssertEquals ("Seconds", 0, ts.Seconds);
 297                 AssertEquals ("Milliseconds", 0, ts.Milliseconds);
 298                 AssertEquals ("Ticks", -31200000000, ts.Ticks);
 299         }
 300
 301         [Test]
 302         [Ignore ("too long")]
 303         public void MinMinutes_TooLong ()
 304         {
 305                 // LAMESPEC: the highest minutes are "special"
 306                 for (int i=Int32.MinValue; i < -2111692253; i++) {
 307                         TimeSpan ts = new TimeSpan (0, 0, i, 0, 0);
 308                         long h = i + Int32.MaxValue + 1;
 309                         string prefix = i.ToString () + '-';
 310                         AssertEquals (prefix + "Days", (h / 1440), ts.Days);
 311                         AssertEquals (prefix + "Hours", ((h / 60) % 24), ts.Hours);
 312                         AssertEquals (prefix + "Minutes", (h % 60), ts.Minutes);
 313                         AssertEquals (prefix + "Seconds", 0, ts.Seconds);
 314                         AssertEquals (prefix + "Milliseconds", 0, ts.Milliseconds);
 315                         AssertEquals (prefix + "Ticks", (600000000L * h), ts.Ticks);
 316                 }
 317         }
 318
 319         [Test]
 320 #if NET_2_0
 321         [Category ("NotWorking")]
 322 #endif
 323         public void MinMinutes ()
 324         {
 325                 TimeSpan ts;
 326 #if NET_2_0
 327                 ts = new TimeSpan (0, 0, Int32.MinValue, 0, 0);
 328                 AssertEquals ("Days", -1491308, ts.Days);
 329                 AssertEquals ("Hours", -2, ts.Hours);
 330                 AssertEquals ("Minutes", -8, ts.Minutes);
 331                 AssertEquals ("Seconds", 0, ts.Seconds);
 332                 AssertEquals ("Milliseconds", 0, ts.Milliseconds);
 333                 AssertEquals ("Ticks", -1288490188800000000, ts.Ticks);
 334 #else
 335                 // LAMESPEC: the highest minutes are "special"
 336                 ts = new TimeSpan (0, 0, Int32.MinValue, 0, 0);
 337                 AssertEquals ("Min-Days", 0, ts.Days);
 338                 AssertEquals ("Min-Hours", 0, ts.Hours);
 339                 AssertEquals ("Min-Minutes", 0, ts.Minutes);
 340                 AssertEquals ("Min-Seconds", 0, ts.Seconds);
 341                 AssertEquals ("Min-Milliseconds", 0, ts.Milliseconds);
 342                 AssertEquals ("Min-Ticks", 0, ts.Ticks);
 343
 344                 ts = new TimeSpan (0, 0, -2111692254, 0, 0);
 345                 AssertEquals ("Days", 24855, ts.Days);
 346                 AssertEquals ("Hours", 3, ts.Hours);
 347                 AssertEquals ("Minutes", 14, ts.Minutes);
 348                 AssertEquals ("Seconds", 0, ts.Seconds);
 349                 AssertEquals ("Milliseconds", 0, ts.Milliseconds);
 350                 AssertEquals ("Ticks", 21474836400000000, ts.Ticks);
 351 #endif
 352         }
 353
 354         [Test]
 355 #if NET_2_0
 356         [Category ("NotWorking")]
 357 #endif
 358         public void MinMinutes_BreakPoint ()
 359         {
 360 #if NET_2_0
 361                 TimeSpan ts = new TimeSpan (0, 0, -2111692253, 0, 0);
 362                 AssertEquals ("Days", -1466452, ts.Days);
 363                 AssertEquals ("Hours", -22, ts.Hours);
 364                 AssertEquals ("Minutes", -53, ts.Minutes);
 365                 AssertEquals ("Seconds", -0, ts.Seconds);
 366                 AssertEquals ("Milliseconds", 0, ts.Milliseconds);
 367                 AssertEquals ("Ticks", -1267015351800000000, ts.Ticks);
 368 #else
 369                 TimeSpan ts = new TimeSpan (0, 0, -2111692253, 0, 0);
 370                 AssertEquals ("Days", -24855, ts.Days);
 371                 AssertEquals ("Hours", -3, ts.Hours);
 372                 AssertEquals ("Minutes", -13, ts.Minutes);
 373                 AssertEquals ("Seconds", -16, ts.Seconds);
 374                 AssertEquals ("Milliseconds", 0, ts.Milliseconds);
 375                 AssertEquals ("Ticks", -21474835960000000, ts.Ticks);
 376 #endif
 377         }
 378
 379         [Test]
 380         public void MaxSeconds ()
 381         {
 382                 TimeSpan ts = new TimeSpan (0, 0, 0, Int32.MaxValue, 0);
 383                 AssertEquals ("Days", 24855, ts.Days);
 384                 AssertEquals ("Hours", 3, ts.Hours);
 385                 AssertEquals ("Minutes", 14, ts.Minutes);
 386                 AssertEquals ("Seconds", 7, ts.Seconds);
 387                 AssertEquals ("Milliseconds", 0, ts.Milliseconds);
 388                 AssertEquals ("Ticks", 21474836470000000, ts.Ticks);
 389         }
 390
 391         [Test]
 392         public void MinSeconds ()
 393         {
 394                 TimeSpan ts = new TimeSpan (0, 0, 0, Int32.MinValue, 0);
 395                 AssertEquals ("Days", -24855, ts.Days);
 396                 AssertEquals ("Hours", -3, ts.Hours);
 397                 AssertEquals ("Minutes", -14, ts.Minutes);
 398                 AssertEquals ("Seconds", -8, ts.Seconds);
 399                 AssertEquals ("Milliseconds", 0, ts.Milliseconds);
 400                 AssertEquals ("Ticks", -21474836480000000, ts.Ticks);
 401         }
 402
 403         [Test]
 404         public void MaxMilliseconds ()
 405         {
 406                 TimeSpan ts = new TimeSpan (0, 0, 0, 0, Int32.MaxValue);
 407                 AssertEquals ("Days", 24, ts.Days);
 408                 AssertEquals ("Hours", 20, ts.Hours);
 409                 AssertEquals ("Minutes", 31, ts.Minutes);
 410                 AssertEquals ("Seconds", 23, ts.Seconds);
 411                 AssertEquals ("Milliseconds", 647, ts.Milliseconds);
 412                 AssertEquals ("Ticks", 21474836470000, ts.Ticks);
 413         }
 414
 415         [Test]
 416         public void MinMilliseconds ()
 417         {
 418                 TimeSpan ts = new TimeSpan (0, 0, 0, 0, Int32.MinValue);
 419                 AssertEquals ("Days", -24, ts.Days);
 420                 AssertEquals ("Hours", -20, ts.Hours);
 421                 AssertEquals ("Minutes", -31, ts.Minutes);
 422                 AssertEquals ("Seconds", -23, ts.Seconds);
 423                 AssertEquals ("Milliseconds", -648, ts.Milliseconds);
 424                 AssertEquals ("Ticks", -21474836480000, ts.Ticks);
 425         }
 426
 427         [Test]
 428         public void NegativeTimeSpan ()
 429         {
 430                 TimeSpan ts = new TimeSpan (-23, -59, -59);
 431                 AssertEquals ("Days", 0, ts.Days);
 432                 AssertEquals ("Hours", -23, ts.Hours);
 433                 AssertEquals ("Minutes", -59, ts.Minutes);
 434                 AssertEquals ("Seconds", -59, ts.Seconds);
 435                 AssertEquals ("Milliseconds", 0, ts.Milliseconds);
 436                 AssertEquals ("Ticks", -863990000000, ts.Ticks);
 437         }
 438
 439         public void TestProperties ()
 440         {
 441                 TimeSpan t1 = new TimeSpan (1,2,3,4,5);
 442                 TimeSpan t2 = -t1;
 443
 444                 AssertEquals ("A1", 1, t1.Days);
 445                 AssertEquals ("A2", 2, t1.Hours);
 446                 AssertEquals ("A3", 3, t1.Minutes);
 447                 AssertEquals ("A4", 4, t1.Seconds);
 448                 AssertEquals ("A5", 5, t1.Milliseconds);
 449                 AssertEquals ("A6", -1, t2.Days);
 450                 AssertEquals ("A7", -2, t2.Hours);
 451                 AssertEquals ("A8", -3, t2.Minutes);
 452                 AssertEquals ("A9", -4, t2.Seconds);
 453                 AssertEquals ("A10", -5, t2.Milliseconds);
 454         }
 455
 456         public void TestAdd ()
 457         {
 458                 TimeSpan t1 = new TimeSpan (2,3,4,5,6);
 459                 TimeSpan t2 = new TimeSpan (1,2,3,4,5);
 460                 TimeSpan t3 = t1 + t2;
 461                 TimeSpan t4 = t1.Add (t2);
 462                 TimeSpan t5;
 463                 bool exception;
 464
 465                 AssertEquals ("A1", 3, t3.Days);
 466                 AssertEquals ("A2", 5, t3.Hours);
 467                 AssertEquals ("A3", 7, t3.Minutes);
 468                 AssertEquals ("A4", 9, t3.Seconds);
 469                 AssertEquals ("A5", 11, t3.Milliseconds);
 470                 AssertEquals ("A6", "3.05:07:09.0110000", t4.ToString ());
 471                 try
 472                 {
 473                         t5 = TimeSpan.MaxValue + new TimeSpan (1);
 474                         exception = false;
 475                 }
 476                 catch (OverflowException)
 477                 {
 478                         exception = true;
 479                 }
 480                 Assert ("A7", exception);
 481         }
 482
 483         public void TestCompare ()
 484         {
 485                 TimeSpan t1 = new TimeSpan (-1);
 486                 TimeSpan t2 = new TimeSpan (1);
 487                 int res;
 488                 bool exception;
 489
 490                 AssertEquals ("A1", -1, TimeSpan.Compare (t1, t2));
 491                 AssertEquals ("A2", 1, TimeSpan.Compare (t2, t1));
 492                 AssertEquals ("A3", 0, TimeSpan.Compare (t2, t2));
 493                 AssertEquals ("A4", -1, TimeSpan.Compare (TimeSpan.MinValue, TimeSpan.MaxValue));
 494                 AssertEquals ("A5", -1, t1.CompareTo (t2));
 495                 AssertEquals ("A6", 1, t2.CompareTo (t1));
 496                 AssertEquals ("A7", 0, t2.CompareTo (t2));
 497                 AssertEquals ("A8", -1, TimeSpan.Compare (TimeSpan.MinValue, TimeSpan.MaxValue));
 498
 499                 AssertEquals ("A9", 1, TimeSpan.Zero.CompareTo (null));
 500
 501                 try
 502                 {
 503                         res = TimeSpan.Zero.CompareTo("");
 504                         exception = false;
 505                 }
 506                 catch (ArgumentException)
 507                 {
 508                         exception = true;
 509                 }
 510                 Assert ("A10", exception);
 511
 512                 AssertEquals ("A11", false, t1 == t2);
 513                 AssertEquals ("A12", false, t1 > t2);
 514                 AssertEquals ("A13", false, t1 >= t2);
 515                 AssertEquals ("A14", true, t1 != t2);
 516                 AssertEquals ("A15", true, t1 < t2);
 517                 AssertEquals ("A16", true, t1 <= t2);
 518         }
 519
 520         [Test]
 521         [ExpectedException (typeof (OverflowException))]
 522         public void NoNegateMinValue() {
 523                 TimeSpan t1 = TimeSpan.MinValue.Negate ();
 524         }
 525
 526         public void TestNegateAndDuration ()
 527         {
 528                 TimeSpan t1;
 529                 bool exception;
 530
 531                 AssertEquals ("A1", "-00:00:00.0012345", new TimeSpan (12345).Negate ().ToString ());
 532                 AssertEquals ("A2", "00:00:00.0012345", new TimeSpan (-12345).Duration ().ToString ());
 533
 534                 try
 535                 {
 536                         t1 = TimeSpan.MinValue.Duration ();
 537                         exception = false;
 538                 }
 539                 catch (OverflowException) {
 540                         exception = true;
 541                 }
 542                 Assert ("A4", exception);
 543
 544                 AssertEquals ("A5", "-00:00:00.0000077", (-(new TimeSpan (77))).ToString ());
 545                 AssertEquals("A6", "00:00:00.0000077", (+(new TimeSpan(77))).ToString());
 546         }
 547
 548         public void TestEquals ()
 549         {
 550                 TimeSpan t1 = new TimeSpan (1);
 551                 TimeSpan t2 = new TimeSpan (2);
 552                 string s = "justastring";
 553
 554                 AssertEquals ("A1", true, t1.Equals (t1));
 555                 AssertEquals ("A2", false, t1.Equals (t2));
 556                 AssertEquals ("A3", false, t1.Equals (s));
 557                 AssertEquals ("A4", false, t1.Equals (null));
 558                 AssertEquals ("A5", true, TimeSpan.Equals (t1, t1));
 559                 AssertEquals ("A6", false, TimeSpan.Equals (t1, t2));
 560                 AssertEquals ("A7", false, TimeSpan.Equals (t1, null));
 561                 AssertEquals ("A8", false, TimeSpan.Equals (t1, s));
 562                 AssertEquals ("A9", false, TimeSpan.Equals (s, t2));
 563                 AssertEquals ("A10", true, TimeSpan.Equals (null,null));
 564         }
 565
 566         public void TestFromXXXX ()
 567         {
 568                 AssertEquals ("A1", "12.08:16:48", TimeSpan.FromDays (12.345).ToString ());
 569                 AssertEquals ("A2", "12:20:42", TimeSpan.FromHours (12.345).ToString ());
 570                 AssertEquals ("A3", "00:12:20.7000000", TimeSpan.FromMinutes (12.345).ToString ());
 571                 AssertEquals ("A4", "00:00:12.3450000", TimeSpan.FromSeconds (12.345).ToString ());
 572                 AssertEquals ("A5", "00:00:00.0120000", TimeSpan.FromMilliseconds (12.345).ToString ());
 573                 AssertEquals ("A6", "00:00:00.0012345", TimeSpan.FromTicks (12345).ToString ());
 574         }
 575
 576         [Test]
 577         [ExpectedException (typeof (OverflowException))]
 578         public void FromDays_MinValue ()
 579         {
 580                 TimeSpan.FromDays (Double.MinValue);
 581         }
 582
 583         [Test]
 584         [ExpectedException (typeof (OverflowException))]
 585         public void FromDays_MaxValue ()
 586         {
 587                 TimeSpan.FromDays (Double.MaxValue);
 588         }
 589
 590         [Test]
 591         [ExpectedException (typeof (ArgumentException))]
 592         public void FromDays_NaN ()
 593         {
 594                 TimeSpan.FromDays (Double.NaN);
 595         }
 596
 597         [Test]
 598         [ExpectedException (typeof (OverflowException))]
 599         public void FromDays_PositiveInfinity ()
 600         {
 601                 // LAMESPEC: Document to return TimeSpan.MaxValue
 602                 AssertEquals (TimeSpan.MaxValue, TimeSpan.FromDays (Double.PositiveInfinity));
 603         }
 604
 605         [Test]
 606         [ExpectedException (typeof (OverflowException))]
 607         public void FromDays_NegativeInfinity ()
 608         {
 609                 // LAMESPEC: Document to return TimeSpan.MinValue
 610                 AssertEquals (TimeSpan.MinValue, TimeSpan.FromDays (Double.NegativeInfinity));
 611         }
 612
 613         [Test]
 614         [ExpectedException (typeof (OverflowException))]
 615         public void FromHours_MinValue ()
 616         {
 617                 TimeSpan.FromHours (Double.MinValue);
 618         }
 619
 620         [Test]
 621         [ExpectedException (typeof (OverflowException))]
 622         public void FromHours_MaxValue ()
 623         {
 624                 TimeSpan.FromHours (Double.MaxValue);
 625         }
 626
 627         [Test]
 628         [ExpectedException (typeof (ArgumentException))]
 629         public void FromHours_NaN ()
 630         {
 631                 TimeSpan.FromHours (Double.NaN);
 632         }
 633
 634         [Test]
 635         [ExpectedException (typeof (OverflowException))]
 636         public void FromHours_PositiveInfinity ()
 637         {
 638                 // LAMESPEC: Document to return TimeSpan.MaxValue
 639                 AssertEquals (TimeSpan.MaxValue, TimeSpan.FromHours (Double.PositiveInfinity));
 640         }
 641
 642         [Test]
 643         [ExpectedException (typeof (OverflowException))]
 644         public void FromHours_NegativeInfinity ()
 645         {
 646                 // LAMESPEC: Document to return TimeSpan.MinValue
 647                 AssertEquals (TimeSpan.MinValue, TimeSpan.FromHours (Double.NegativeInfinity));
 648         }
 649
 650         [Test]
 651         [ExpectedException (typeof (OverflowException))]
 652         public void FromMilliseconds_MinValue ()
 653         {
 654                 TimeSpan.FromMilliseconds (Double.MinValue);
 655         }
 656
 657         [Test]
 658         [ExpectedException (typeof (OverflowException))]
 659         public void FromMilliseconds_MaxValue ()
 660         {
 661                 TimeSpan.FromMilliseconds (Double.MaxValue);
 662         }
 663
 664         [Test]
 665         [ExpectedException (typeof (ArgumentException))]
 666         public void FromMilliseconds_NaN ()
 667         {
 668                 TimeSpan.FromMilliseconds (Double.NaN);
 669         }
 670
 671         [Test]
 672         [ExpectedException (typeof (OverflowException))]
 673         public void FromMilliseconds_PositiveInfinity ()
 674         {
 675                 // LAMESPEC: Document to return TimeSpan.MaxValue
 676                 AssertEquals (TimeSpan.MaxValue, TimeSpan.FromMilliseconds (Double.PositiveInfinity));
 677         }
 678
 679         [Test]
 680         [ExpectedException (typeof (OverflowException))]
 681         public void FromMilliseconds_NegativeInfinity ()
 682         {
 683                 // LAMESPEC: Document to return TimeSpan.MinValue
 684                 AssertEquals (TimeSpan.MinValue, TimeSpan.FromMilliseconds (Double.NegativeInfinity));
 685         }
 686
 687         [Test]
 688         [ExpectedException (typeof (OverflowException))]
 689         public void FromMinutes_MinValue ()
 690         {
 691                 TimeSpan.FromMinutes (Double.MinValue);
 692         }
 693
 694         [Test]
 695         [ExpectedException (typeof (OverflowException))]
 696         public void FromMinutes_MaxValue ()
 697         {
 698                 TimeSpan.FromMinutes (Double.MaxValue);
 699         }
 700
 701         [Test]
 702         [ExpectedException (typeof (ArgumentException))]
 703         public void FromMinutes_NaN ()
 704         {
 705                 TimeSpan.FromMinutes (Double.NaN);
 706         }
 707
 708         [Test]
 709         [ExpectedException (typeof (OverflowException))]
 710         public void FromMinutes_PositiveInfinity ()
 711         {
 712                 // LAMESPEC: Document to return TimeSpan.MaxValue
 713                 AssertEquals (TimeSpan.MaxValue, TimeSpan.FromMinutes (Double.PositiveInfinity));
 714         }
 715
 716         [Test]
 717         [ExpectedException (typeof (OverflowException))]
 718         public void FromMinutes_NegativeInfinity ()
 719         {
 720                 // LAMESPEC: Document to return TimeSpan.MinValue
 721                 AssertEquals (TimeSpan.MinValue, TimeSpan.FromMinutes (Double.NegativeInfinity));
 722         }
 723
 724         [Test]
 725         [ExpectedException (typeof (OverflowException))]
 726         public void FromSeconds_MinValue ()
 727         {
 728                 TimeSpan.FromSeconds (Double.MinValue);
 729         }
 730
 731         [Test]
 732         [ExpectedException (typeof (OverflowException))]
 733         public void FromSeconds_MaxValue ()
 734         {
 735                 TimeSpan.FromSeconds (Double.MaxValue);
 736         }
 737
 738         [Test]
 739         [ExpectedException (typeof (ArgumentException))]
 740         public void FromSeconds_NaN ()
 741         {
 742                 TimeSpan.FromSeconds (Double.NaN);
 743         }
 744
 745         [Test]
 746         [ExpectedException (typeof (OverflowException))]
 747         public void FromSeconds_PositiveInfinity ()
 748         {
 749                 // LAMESPEC: Document to return TimeSpan.MaxValue
 750                 AssertEquals (TimeSpan.MaxValue, TimeSpan.FromSeconds (Double.PositiveInfinity));
 751         }
 752
 753         [Test]
 754         [ExpectedException (typeof (OverflowException))]
 755         public void FromSeconds_NegativeInfinity ()
 756         {
 757                 // LAMESPEC: Document to return TimeSpan.MinValue
 758                 AssertEquals (TimeSpan.MinValue, TimeSpan.FromSeconds (Double.NegativeInfinity));
 759         }
 760
 761         public void TestGetHashCode ()
 762         {
 763                 AssertEquals ("A1", 77, new TimeSpan (77).GetHashCode ());
 764         }
 765
 766         private void ParseHelper (string s, bool expectFormat, bool expectOverflow, string expect)
 767         {
 768                 bool formatException = false;
 769                 bool overflowException = false;
 770                 string result = "junk ";
 771
 772                 try {
 773                         result =  TimeSpan.Parse (s).ToString ();
 774                 }
 775                 catch (OverflowException) {
 776                         overflowException = true;
 777                 }
 778                 catch (FormatException) {
 779                         formatException = true;
 780                 }
 781                 AssertEquals ("A1", expectFormat, formatException);
 782                 AssertEquals ("A2", expectOverflow, overflowException);
 783
 784                 if (!expectOverflow && !expectFormat) {
 785                         AssertEquals ("A3", expect, result);
 786                 }
 787         }
 788
 789         public void TestParse ()
 790         {
 791                 ParseHelper (" 13:45:15 ",false, false, "13:45:15");
 792                 ParseHelper (" -1:2:3 ", false, false, "-01:02:03");
 793
 794                 ParseHelper (" 25:0:0 ",false, true, "dontcare");
 795                 ParseHelper ("aaa", true, false, "dontcare");
 796
 797                 ParseHelper ("-21.23:59:59.9999999", false, false, "-21.23:59:59.9999999");
 798
 799                 ParseHelper ("100000000000000.1:1:1", false, true, "dontcare");
 800                 ParseHelper ("24:60:60", false, true, "dontcare");
 801                 ParseHelper ("0001:0002:0003.12     ", false, false, "01:02:03.1200000");
 802
 803                 ParseHelper (" 1:2:3:12345678 ", true, false, "dontcare");
 804         }
 805
 806         // LAMESPEC: timespan in documentation is wrong - hh:mm:ss isn't mandatory
 807         [Test]
 808         public void Parse_Days_WithoutColon ()
 809         {
 810                 TimeSpan ts = TimeSpan.Parse ("1");
 811                 AssertEquals ("Days", 1, ts.Days);
 812         }
 813
 814         public void TestSubstract ()
 815         {
 816                 TimeSpan t1 = new TimeSpan (2,3,4,5,6);
 817                 TimeSpan t2 = new TimeSpan (1,2,3,4,5);
 818                 TimeSpan t3 = t1 - t2;
 819                 TimeSpan t4 = t1.Subtract (t2);
 820                 TimeSpan t5;
 821                 bool exception;
 822
 823                 AssertEquals ("A1", "1.01:01:01.0010000", t3.ToString ());
 824                 AssertEquals ("A2", "1.01:01:01.0010000", t4.ToString ());
 825                 try {
 826                         t5 = TimeSpan.MinValue - new TimeSpan (1);
 827                         exception = false;
 828                 }
 829                 catch (OverflowException) {
 830                         exception = true;
 831                 }
 832                 Assert ("A3", exception);
 833         }
 834
 835         public void TestToString ()
 836         {
 837                 TimeSpan t1 = new TimeSpan (1,2,3,4,5);
 838                 TimeSpan t2 = -t1;
 839
 840                 AssertEquals ("A1", "1.02:03:04.0050000", t1.ToString ());
 841                 AssertEquals ("A2", "-1.02:03:04.0050000", t2.ToString ());
 842                 AssertEquals ("A3", "10675199.02:48:05.4775807", TimeSpan.MaxValue.ToString ());
 843                 AssertEquals ("A4", "-10675199.02:48:05.4775808", TimeSpan.MinValue.ToString ());
 844         }
 845
 846         [Test]
 847         public void ToString_Constants ()
 848         {
 849                 AssertEquals ("Zero", "00:00:00", TimeSpan.Zero.ToString ());
 850                 AssertEquals ("MaxValue", "10675199.02:48:05.4775807", TimeSpan.MaxValue.ToString ());
 851                 AssertEquals ("MinValue", "-10675199.02:48:05.4775808", TimeSpan.MinValue.ToString ());
 852         }
 853
 854         [Test]
 855         [ExpectedException (typeof (OverflowException))]
 856         public void Parse_InvalidValuesAndFormat_ExceptionOrder ()
 857         {
 858                 // hours should be between 0 and 23 but format is also invalid (too many dots)
 859                 TimeSpan.Parse ("0.99.99.0");
 860         }
 861
 862         [Test]
 863         public void Parse_MinMaxValues ()
 864         {
 865                 AssertEquals ("MaxValue", TimeSpan.MaxValue, TimeSpan.Parse ("10675199.02:48:05.4775807"));
 866                 AssertEquals ("MinValue", TimeSpan.MinValue, TimeSpan.Parse ("-10675199.02:48:05.4775808"));
 867         }
 868
 869         [Test]
 870         [ExpectedException (typeof (OverflowException))]
 871         public void Parse_OverMaxValue()
 872         {
 873                 TimeSpan.Parse ("10675199.02:48:05.4775808");
 874         }
 875
 876         [Test]
 877         [ExpectedException (typeof (OverflowException))]
 878         public void Parse_UnderMinValue()
 879         {
 880                 TimeSpan.Parse ("-10675199.02:48:05.4775809");
 881         }
 882 }
 883
 884 }