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