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

   1 //
   2 // DateTimeTest.cs - NUnit Test Cases for the System.DateTime struct
   3 //
   4 // author:
   5 //   Martin Baulig (martin@gnome.org)
   6 //
   7 //   (C) 2002 Free Software Foundation
   8 // Copyright (C) 2004 Novell (http://www.novell.com)
   9 //
  10
  11 using NUnit.Framework;
  12 using System;
  13 using System.IO;
  14 using System.Threading;
  15 using System.Globalization;
  16
  17 namespace MonoTests.System
  18 {
  19
  20 [TestFixture]
  21 public class DateTimeTest : Assertion
  22 {
  23         [Flags]
  24         internal enum Resolution : ushort {
  25                 Year = 64,
  26                 Month = 96,
  27                 Day = 112,
  28                 Hour = 120,
  29                 Minute = 124,
  30                 Second = 126,
  31                 Millisecond = 127,
  32                 _Month = 32,
  33                 _Day = 16,
  34                 _Hour = 8,
  35                 _Minute = 4,
  36                 _Second = 2,
  37                 _Millisecond = 1
  38         }
  39
  40         internal void DTAssertEquals (DateTime actual, DateTime expected, Resolution resolution) {
  41                 DTAssertEquals ("", actual, expected, resolution);
  42         }
  43
  44         internal void DTAssertEquals (string message, DateTime expected, DateTime actual, Resolution resolution) {
  45                 if ((resolution & Resolution.Year) != 0)
  46                         AssertEquals (message, expected.Year, actual.Year);
  47                 if ((resolution & Resolution._Month) != 0)
  48                         AssertEquals (message, expected.Month, actual.Month);
  49                 if ((resolution & Resolution._Day) != 0)
  50                         AssertEquals (message, expected.Day, actual.Day);
  51                 if ((resolution & Resolution._Hour) != 0)
  52                         AssertEquals (message, expected.Hour, actual.Hour);
  53                 if ((resolution & Resolution._Minute) != 0)
  54                         AssertEquals (message, expected.Minute, actual.Minute);
  55                 if ((resolution & Resolution._Second) != 0)
  56                         AssertEquals (message, expected.Second, actual.Second);
  57                 if ((resolution & Resolution._Millisecond) != 0)
  58                         AssertEquals (message, expected.Millisecond, actual.Millisecond);
  59         }
  60
  61         private CultureInfo oldcult;
  62
  63         long[] myTicks = {
  64                 631501920000000000L,    // 25 Feb 2002 - 00:00:00
  65                 631502475130080000L,    // 25 Feb 2002 - 15:25:13,8
  66                 631502115130080000L,    // 25 Feb 2002 - 05:25:13,8
  67                 631502115000000000L,    // 25 Feb 2002 - 05:25:00
  68                 631502115130000000L,    // 25 Feb 2002 - 05:25:13
  69                 631502079130000000L,    // 25 Feb 2002 - 04:25:13
  70                 629197085770000000L     // 06 Nov 1994 - 08:49:37
  71         };
  72
  73         public DateTimeTest() {}
  74
  75         [SetUp]
  76         public void SetUp()
  77         {
  78                 // the current culture determines the result of formatting
  79                 oldcult = Thread.CurrentThread.CurrentCulture;
  80                 Thread.CurrentThread.CurrentCulture = new CultureInfo ("");
  81         }
  82
  83         [TearDown]
  84         public void TearDown ()
  85         {
  86                 Thread.CurrentThread.CurrentCulture = oldcult;
  87         }
  88
  89         [Test]
  90         public void TestCtors ()
  91         {
  92                 DateTime t1 = new DateTime (2002,2,25);
  93                 AssertEquals("A01", myTicks[0], t1.Ticks);
  94                 DateTime t2 = new DateTime (2002,2,25,15,25,13,8);
  95                 AssertEquals("A02", myTicks[1], t2.Ticks);
  96                 AssertEquals("A03", myTicks[0], t2.Date.Ticks);
  97                 AssertEquals("A04", 2002, t2.Year);
  98                 AssertEquals("A05", 2, t2.Month);
  99                 AssertEquals("A06", 25, t2.Day);
 100                 AssertEquals("A07", 15, t2.Hour);
 101                 AssertEquals("A08", 25, t2.Minute);
 102                 AssertEquals("A09", 13, t2.Second);
 103                 AssertEquals("A10", 8, t2.Millisecond);
 104                 DateTime t3 = new DateTime (2002,2,25,5,25,13,8);
 105                 AssertEquals("A11", myTicks[2], t3.Ticks);
 106         }
 107
 108         [Test]
 109         public void Constructor_Max ()
 110         {
 111                 AssertEquals ("Max", 3155378975999990000, new DateTime (9999, 12, 31, 23, 59, 59, 999).Ticks);
 112         }
 113
 114         [Test]
 115         [ExpectedException (typeof (ArgumentOutOfRangeException))]
 116         public void Constructor_Milliseconds_Negative ()
 117         {
 118                 new DateTime (9999, 12, 31, 23, 59, 59, -1);
 119         }
 120
 121         [Test]
 122         [ExpectedException (typeof (ArgumentOutOfRangeException))]
 123         public void Constructor_Milliseconds_1000 ()
 124         {
 125                 new DateTime (9999, 12, 31, 23, 59, 59, 1000);
 126         }
 127
 128         [Test]
 129         public void Fields ()
 130         {
 131                 AssertEquals ("J01", 3155378975999999999L, DateTime.MaxValue.Ticks);
 132                 AssertEquals ("J02", 0, DateTime.MinValue.Ticks);
 133         }
 134
 135         [Test]
 136         public void Add ()
 137         {
 138                 DateTime t1 = new DateTime (myTicks [1]);
 139                 TimeSpan span = new TimeSpan (3, 54, 1);
 140                 DateTime t2 = t1.Add (span);
 141
 142                 AssertEquals ("K01", 25, t2.Day);
 143                 AssertEquals ("K02", 19, t2.Hour);
 144                 AssertEquals ("K03", 19, t2.Minute);
 145                 AssertEquals ("K04", 14, t2.Second);
 146
 147                 AssertEquals ("K05", 25, t1.Day);
 148                 AssertEquals ("K06", 15, t1.Hour);
 149                 AssertEquals ("K07", 25, t1.Minute);
 150                 AssertEquals ("K08", 13, t1.Second);
 151         }
 152
 153         [Test]
 154         [ExpectedException(typeof (ArgumentOutOfRangeException))]
 155         public void AddOutOfRangeException1 ()
 156         {
 157                 DateTime t1 = new DateTime (myTicks [1]);
 158                 t1.Add (TimeSpan.MaxValue);
 159         }
 160
 161         [Test]
 162         [ExpectedException(typeof (ArgumentOutOfRangeException))]
 163         public void AddOutOfRangeException2 ()
 164         {
 165                 DateTime t1 = new DateTime (myTicks [1]);
 166                 t1.Add (TimeSpan.MinValue);
 167         }
 168
 169         [Test]
 170         public void AddDays ()
 171         {
 172                 DateTime t1 = new DateTime (myTicks [1]);
 173                 t1 = t1.AddDays (3);
 174                 AssertEquals ("L01", 28, t1.Day);
 175                 AssertEquals ("L02", 15, t1.Hour);
 176                 AssertEquals ("L03", 25, t1.Minute);
 177                 AssertEquals ("L04", 13, t1.Second);
 178
 179                 t1 = t1.AddDays (1.9);
 180                 AssertEquals ("L05", 2, t1.Day);
 181                 AssertEquals ("L06", 13, t1.Hour);
 182                 AssertEquals ("L07", 1, t1.Minute);
 183                 AssertEquals ("L08", 13, t1.Second);
 184
 185                 t1 = t1.AddDays (0.2);
 186                 AssertEquals ("L09", 2, t1.Day);
 187                 AssertEquals ("L10", 17, t1.Hour);
 188                 AssertEquals ("L11", 49, t1.Minute);
 189                 AssertEquals ("L12", 13, t1.Second);
 190         }
 191
 192         [Test]
 193         [ExpectedException(typeof (ArgumentOutOfRangeException))]
 194         public void AddDaysOutOfRangeException1 ()
 195         {
 196                 DateTime t1 = new DateTime (myTicks [1]);
 197                 t1.AddDays (10000000);
 198         }
 199
 200         [Test]
 201         [ExpectedException(typeof (ArgumentOutOfRangeException))]
 202         public void AddDaysOutOfRangeException2 ()
 203         {
 204                 DateTime t1 = new DateTime (myTicks [1]);
 205                 t1.AddDays (-10000000);
 206         }
 207
 208         [Test]
 209         public void AddHours ()
 210         {
 211                 DateTime t1 = new DateTime (myTicks [1]);
 212                 t1 = t1.AddHours (10);
 213                 AssertEquals ("N01", 26, t1.Day);
 214                 AssertEquals ("N02", 1, t1.Hour);
 215                 AssertEquals ("N03", 25, t1.Minute);
 216                 AssertEquals ("N04", 13, t1.Second);
 217
 218                 t1 = t1.AddHours (-3.7);
 219                 AssertEquals ("N05", 25, t1.Day);
 220                 AssertEquals ("N06", 21, t1.Hour);
 221                 AssertEquals ("N07", 43, t1.Minute);
 222                 AssertEquals ("N08", 13, t1.Second);
 223
 224                 t1 = t1.AddHours (3.732);
 225                 AssertEquals ("N09", 26, t1.Day);
 226                 AssertEquals ("N10", 1, t1.Hour);
 227                 AssertEquals ("N11", 27, t1.Minute);
 228                 AssertEquals ("N12", 8, t1.Second);
 229         }
 230
 231         [Test]
 232         [ExpectedException (typeof (ArgumentOutOfRangeException))]
 233         public void AddHoursOutOfRangeException1 ()
 234         {
 235                 DateTime t1 = new DateTime (myTicks [1]);
 236                 t1.AddHours (9E100);
 237         }
 238
 239         [Test]
 240         [ExpectedException (typeof (ArgumentOutOfRangeException))]
 241         public void AddHoursOutOfRangeException2 ()
 242         {
 243                 DateTime t1 = new DateTime (myTicks [1]);
 244                 t1.AddHours (-9E100);
 245         }
 246
 247         [Test]
 248         public void AddMilliseconds ()
 249         {
 250                 DateTime t1 = new DateTime (myTicks [1]);
 251                 t1 = t1.AddMilliseconds (1E10);
 252                 AssertEquals ("O01", 21, t1.Day);
 253                 AssertEquals ("O02", 9, t1.Hour);
 254                 AssertEquals ("O03", 11, t1.Minute);
 255                 AssertEquals ("O04", 53, t1.Second);
 256
 257                 t1 = t1.AddMilliseconds (-19E10);
 258                 AssertEquals ("O05", 13, t1.Day);
 259                 AssertEquals ("O06", 7, t1.Hour);
 260                 AssertEquals ("O07", 25, t1.Minute);
 261                 AssertEquals ("O08", 13, t1.Second);
 262
 263                 t1 = t1.AddMilliseconds (15.623);
 264                 AssertEquals ("O09", 13, t1.Day);
 265                 AssertEquals ("O10", 7, t1.Hour);
 266                 AssertEquals ("O11", 25, t1.Minute);
 267                 AssertEquals ("O12", 13, t1.Second);
 268         }
 269
 270         [Test]
 271         [ExpectedException (typeof (ArgumentOutOfRangeException))]
 272         public void AddMillisecondsOutOfRangeException1 ()
 273         {
 274                 DateTime t1 = new DateTime (myTicks [1]);
 275                 t1.AddMilliseconds (9E100);
 276         }
 277
 278         [Test]
 279         [ExpectedException (typeof (ArgumentOutOfRangeException))]
 280         public void AddMillisecondsOutOfRangeException2 ()
 281         {
 282                 DateTime t1 = new DateTime (myTicks [1]);
 283                 t1.AddMilliseconds (-9E100);
 284         }
 285
 286         [Test]
 287         public void TestToString ()
 288         {
 289                 DateTime t1 = new DateTime (myTicks[2]);
 290                 DateTime t2 = new DateTime (myTicks[1]);
 291                 // Standard patterns
 292                 AssertEquals("B01", "02/25/2002", t1.ToString ("d"));
 293                 AssertEquals("B02", "Monday, 25 February 2002", t1.ToString ("D"));
 294                 AssertEquals("B03", "Monday, 25 February 2002 05:25", t1.ToString ("f"));
 295                 AssertEquals("B04", "Monday, 25 February 2002 05:25:13", t1.ToString ("F"));
 296                 AssertEquals("B05", "02/25/2002 05:25", t1.ToString ("g"));
 297                 AssertEquals("B06", "02/25/2002 05:25:13", t1.ToString ("G"));
 298                 AssertEquals("B07", "February 25", t1.ToString ("m"));
 299                 AssertEquals("B08", "February 25", t1.ToString ("M"));
 300                 AssertEquals("B09", "Mon, 25 Feb 2002 05:25:13 GMT", t1.ToString ("r"));
 301                 AssertEquals("B10", "Mon, 25 Feb 2002 05:25:13 GMT", t1.ToString ("R"));
 302                 AssertEquals("B11", "2002-02-25T05:25:13", t1.ToString ("s"));
 303                 AssertEquals("B12", "05:25", t1.ToString ("t"));
 304                 AssertEquals("B13", "05:25:13", t1.ToString ("T"));
 305                 AssertEquals("B14", "2002-02-25 05:25:13Z", t1.ToString ("u"));
 306                 // FIXME: this test is timezone dependent
 307                 // AssertEquals("B15", "Sunday, 24 February 2002 11:25:13", t1.ToString ("U"));
 308                 AssertEquals("B16", "2002 February", t1.ToString ("y"));
 309                 AssertEquals("B17", "2002 February", t1.ToString ("Y"));
 310
 311                 // Custom patterns
 312                 AssertEquals("C01", "25", t1.ToString ("%d"));
 313                 AssertEquals("C02", "25", t1.ToString ("dd"));
 314                 AssertEquals("C03", "Mon", t1.ToString ("ddd"));
 315                 AssertEquals("C04", "Monday", t1.ToString ("dddd"));
 316                 AssertEquals("C05", "2", t1.ToString ("%M"));
 317                 AssertEquals("C06", "02", t1.ToString ("MM"));
 318                 AssertEquals("C07", "Feb", t1.ToString ("MMM"));
 319                 AssertEquals("C08", "February", t1.ToString ("MMMM"));
 320                 AssertEquals("C09", "2", t1.ToString ("%y"));
 321                 AssertEquals("C10", "02", t1.ToString ("yy"));
 322                 AssertEquals("C11", "2002", t1.ToString ("yyyy"));
 323                 AssertEquals("C12", "5", t1.ToString ("%h"));
 324                 AssertEquals("C13", "05", t1.ToString ("hh"));
 325                 AssertEquals("C14", "3", t2.ToString ("%h"));
 326                 AssertEquals("C15", "03", t2.ToString ("hh"));
 327                 AssertEquals("C16", "15", t2.ToString ("%H"));
 328                 AssertEquals("C17", "15", t2.ToString ("HH"));
 329                 AssertEquals("C18", "25", t2.ToString ("%m"));
 330                 AssertEquals("C19", "25", t2.ToString ("mm"));
 331                 AssertEquals("C20", "13", t2.ToString ("%s"));
 332                 AssertEquals("C21", "13", t2.ToString ("ss"));
 333                 AssertEquals("C22", "A", t1.ToString ("%t"));
 334                 AssertEquals("C23", "P", t2.ToString ("%t"));
 335                 AssertEquals("C24", "AM", t1.ToString ("tt"));
 336                 AssertEquals("C25", "PM", t2.ToString ("tt"));
 337                 long offset = TimeZone.CurrentTimeZone.GetUtcOffset(t1).Ticks / 36000000000;
 338                 // Must specify '+0' for GMT
 339                 AssertEquals("C26", offset.ToString("+#;-#;+0"), t1.ToString ("%z"));
 340                 AssertEquals("C27", offset.ToString("+00;-00;+00"), t1.ToString ("zz"));
 341                 // This does not work in, eg banglore, because their timezone has an offset of
 342                 // +05:30
 343                 //AssertEquals("C28", offset.ToString("+00;-00;00") + ":00", t1.ToString ("zzz"));
 344                 AssertEquals("C29", " : ", t1.ToString (" : "));
 345                 AssertEquals("C30", " / ", t1.ToString (" / "));
 346                 AssertEquals("C31", " yyy ", t1.ToString (" 'yyy' "));
 347                 AssertEquals("C32", " d", t1.ToString (" \\d"));
 348         }
 349
 350         [Test]
 351         public void TestParseExact3 ()
 352         {
 353                 DateTime t1 = DateTime.ParseExact ("2002-02-25 04:25:13Z", "u", null);
 354                 t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1);
 355                 AssertEquals ("D07a", 2002, t1.Year);
 356                 AssertEquals ("D07b", 02, t1.Month);
 357                 // FIXME: This test is timezone dependent.
 358 //              AssertEquals ("D07c", 25, t1.Day);
 359 //              AssertEquals ("D07d", 04, t1.Hour);
 360                 AssertEquals ("D07e", 25, t1.Minute);
 361                 AssertEquals ("D07f", 13, t1.Second);
 362         }
 363
 364         [Test]
 365         public void TestParseExact4 ()
 366         {
 367                 // bug #60912, modified hour as 13:00
 368                 string s = "6/28/2004 13:00:00 AM";
 369                 string f = "M/d/yyyy HH':'mm':'ss tt";
 370                 DateTime.ParseExact (s, f, CultureInfo.InvariantCulture);
 371
 372                 // bug #63137
 373                 DateTime.ParseExact ("Wed, 12 May 2004 20:51:09 +0200",
 374                         @"ddd, d MMM yyyy H:m:s zzz",
 375                         CultureInfo.CreateSpecificCulture("en-us"),
 376                         DateTimeStyles.AllowInnerWhite);
 377         }
 378
 379         [Test]
 380         public void TestParseExact ()
 381         {
 382                 // Standard patterns
 383                 DateTime t1 = DateTime.ParseExact ("02/25/2002", "d", null);
 384                 AssertEquals ("D01", myTicks[0], t1.Ticks);
 385                 t1 = DateTime.ParseExact ("Monday, 25 February 2002", "D", null);
 386                 AssertEquals ("D02", myTicks[0], t1.Ticks);
 387                 t1 = DateTime.ParseExact ("Monday, 25 February 2002 05:25", "f", null);
 388                 AssertEquals ("D03", myTicks[3], t1.Ticks);
 389                 t1 = DateTime.ParseExact ("Monday, 25 February 2002 05:25:13", "F", null);
 390                 AssertEquals ("D04", myTicks[4], t1.Ticks);
 391                 t1 = DateTime.ParseExact ("02/25/2002 05:25", "g", null);
 392                 AssertEquals ("D05", myTicks[3], t1.Ticks);
 393                 t1 = DateTime.ParseExact ("02/25/2002 05:25:13", "G", null);
 394                 AssertEquals ("D06", myTicks[4], t1.Ticks);
 395                 t1 = DateTime.ParseExact ("Monday, 25 February 2002 04:25:13", "U", null);
 396                 t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1);
 397                 AssertEquals ("D08a", 2002, t1.Year);
 398                 AssertEquals ("D08b", 02, t1.Month);
 399                 AssertEquals ("D08c", 25, t1.Day);
 400                 AssertEquals ("D08d", 04, t1.Hour);
 401                 AssertEquals ("D08e", 25, t1.Minute);
 402                 AssertEquals ("D08f", 13, t1.Second);
 403
 404                 DateTime t2 = new DateTime (DateTime.Today.Year, 2, 25);
 405                 t1 = DateTime.ParseExact ("February 25", "m", null);
 406                 AssertEquals ("D09", t2.Ticks, t1.Ticks);
 407
 408                 t2 = new DateTime (DateTime.Today.Year, 2, 25);
 409                 t1 = DateTime.ParseExact ("February 25", "M", null);
 410                 AssertEquals ("D10", t2.Ticks, t1.Ticks);
 411
 412                 t1 = DateTime.ParseExact ("Mon, 25 Feb 2002 04:25:13 GMT", "r", null);
 413                 AssertEquals ("D11a", 2002, t1.Year);
 414                 AssertEquals ("D11b", 02, t1.Month);
 415                 AssertEquals ("D11c", 25, t1.Day);
 416                 AssertEquals ("D11d", 04, t1.Hour);
 417                 AssertEquals ("D11e", 25, t1.Minute);
 418                 AssertEquals ("D11f", 13, t1.Second);
 419
 420                 t1 = DateTime.ParseExact ("Mon, 25 Feb 2002 04:25:13 GMT", "R", null);
 421                 AssertEquals ("D12a", 2002, t1.Year);
 422                 AssertEquals ("D12b", 02, t1.Month);
 423                 AssertEquals ("D12c", 25, t1.Day);
 424                 AssertEquals ("D12d", 04, t1.Hour);
 425                 AssertEquals ("D12e", 25, t1.Minute);
 426                 AssertEquals ("D12f", 13, t1.Second);
 427
 428                 t1 = DateTime.ParseExact ("2002-02-25T05:25:13", "s", null);
 429                 AssertEquals ("D13", myTicks[4], t1.Ticks);
 430
 431                 t2 = DateTime.Today + new TimeSpan (5,25,0);
 432                 t1 = DateTime.ParseExact ("05:25", "t", null);
 433                 AssertEquals("D14", t2.Ticks, t1.Ticks);
 434
 435                 t2 = DateTime.Today + new TimeSpan (5,25,13);
 436                 t1 = DateTime.ParseExact ("05:25:13", "T", null);
 437                 AssertEquals("D15", t2.Ticks, t1.Ticks);
 438
 439                 t2 = new DateTime (2002, 2, 1);
 440                 t1 = DateTime.ParseExact ("2002 February", "y", null);
 441                 AssertEquals ("D16", t2.Ticks, t1.Ticks);
 442
 443                 t2 = new DateTime (2002, 2, 1);
 444                 t1 = DateTime.ParseExact ("2002 February", "Y", null);
 445                 AssertEquals ("D16", t2.Ticks, t1.Ticks);
 446
 447                 // Custom patterns
 448                 t2 = new DateTime (DateTime.Now.Year, 1, 25);
 449                 t1 = DateTime.ParseExact ("25", "%d", null);
 450                 AssertEquals ("E01: " + t2 + " -- " + t1, t2.Ticks, t1.Ticks);
 451                 t1 = DateTime.ParseExact ("25", "dd", null);
 452                 AssertEquals ("E02", t2.Ticks, t1.Ticks);
 453
 454                 t2 = new DateTime (DateTime.Today.Year, 2, 1);
 455                 t1 = DateTime.ParseExact ("2", "%M", null);
 456                 AssertEquals ("E03", t2.Ticks, t1.Ticks);
 457                 t1 = DateTime.ParseExact ("02", "MM", null);
 458                 AssertEquals ("E04", t2.Ticks, t1.Ticks);
 459                 t1 = DateTime.ParseExact ("Feb", "MMM", null);
 460                 AssertEquals ("E05", t2.Ticks, t1.Ticks);
 461                 t1 = DateTime.ParseExact ("February", "MMMM", null);
 462                 AssertEquals ("E06", t2.Ticks, t1.Ticks);
 463
 464                 t2 = new DateTime (2005, 1, 1);
 465                 t1 = DateTime.ParseExact ("5", "%y", null);
 466                 AssertEquals ("E07", t2.Ticks, t1.Ticks);
 467                 t1 = DateTime.ParseExact ("05", "yy", null);
 468                 AssertEquals ("E08", t2.Ticks, t1.Ticks);
 469                 t1 = DateTime.ParseExact ("2005", "yyyy", null);
 470                 AssertEquals ("E09", t2.Ticks, t1.Ticks);
 471
 472                 t2 = DateTime.Today + new TimeSpan (5, 0, 0);
 473                 t1 = DateTime.ParseExact ("5A", "ht", null);
 474                 AssertEquals ("E10", t2.Ticks, t1.Ticks);
 475                 t1 = DateTime.ParseExact ("05A", "hht", null);
 476                 AssertEquals ("E11", t2.Ticks, t1.Ticks);
 477
 478                 t2 = DateTime.Today + new TimeSpan (15, 0, 0);
 479                 t1 = DateTime.ParseExact ("3P", "ht", null);
 480                 AssertEquals ("E12", t2.Ticks, t1.Ticks);
 481                 t1 = DateTime.ParseExact ("03P", "hht", null);
 482                 AssertEquals ("E13", t2.Ticks, t1.Ticks);
 483
 484                 t2 = DateTime.Today + new TimeSpan (5, 0, 0);
 485                 t1 = DateTime.ParseExact ("5", "%H", null);
 486                 AssertEquals ("E14", t2.Ticks, t1.Ticks);
 487
 488                 t2 = DateTime.Today + new TimeSpan (15, 0, 0);
 489                 t1 = DateTime.ParseExact ("15", "%H", null);
 490                 AssertEquals ("E15", t2.Ticks, t1.Ticks);
 491                 t1 = DateTime.ParseExact ("15", "HH", null);
 492                 AssertEquals ("E16", t2.Ticks, t1.Ticks);
 493
 494                 // Time zones
 495 #if false
 496                 // Fails durring DST for msft and mono
 497                 t2 = DateTime.Today + new TimeSpan (17, 18, 0);
 498                 t1 = DateTime.ParseExact ("11:18AM -5", "h:mmtt z", null);
 499                 t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1);
 500                 if (!TimeZone.CurrentTimeZone.IsDaylightSavingTime(t1))
 501                         t1 += new TimeSpan(1, 0, 0);
 502                 AssertEquals ("F01", t2.Ticks, t1.Ticks);
 503
 504                 t1 = DateTime.ParseExact ("11:18AM -05:00", "h:mmtt zzz", null);
 505                 t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1);
 506                 if (!TimeZone.CurrentTimeZone.IsDaylightSavingTime(t1))
 507                         t1 += new TimeSpan(1, 0, 0);
 508                 AssertEquals ("F02", t2.Ticks, t1.Ticks);
 509
 510                 t1 = DateTime.ParseExact ("7:18PM +03", "h:mmtt zz", null);
 511                 t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1);
 512                 if (!TimeZone.CurrentTimeZone.IsDaylightSavingTime(t1))
 513                         t1 += new TimeSpan(1, 0, 0);
 514                 AssertEquals ("F03", t2.Ticks, t1.Ticks);
 515
 516                 t1 = DateTime.ParseExact ("7:48PM +03:30", "h:mmtt zzz", null);
 517                 t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1);
 518                 if (!TimeZone.CurrentTimeZone.IsDaylightSavingTime(t1))
 519                         t1 += new TimeSpan(1, 0, 0);
 520                 AssertEquals ("F04", t2.Ticks, t1.Ticks);
 521 #endif
 522
 523                 // Options
 524                 t2 = DateTime.Today + new TimeSpan (16, 18, 0);
 525                 t1 = DateTime.ParseExact ("11:18AM -5", "h:mmtt z",
 526                                           null, DateTimeStyles.AdjustToUniversal);
 527                 AssertEquals ("G01", t2.Ticks, t1.Ticks);
 528
 529                 t1 = DateTime.ParseExact ("Monday, 25 February 2002 05:25:13", "F",
 530                                           null, DateTimeStyles.AdjustToUniversal);
 531                 AssertEquals ("G02", myTicks[4], t1.Ticks);
 532                 t1 = DateTime.ParseExact ("Monday, 25 February 2002 05:25:13",
 533                                           "dddd, dd MMMM yyyy HH:mm:ss",
 534                                           null, DateTimeStyles.AdjustToUniversal);
 535                 AssertEquals ("G03", myTicks[4], t1.Ticks);
 536
 537                 t1 = DateTime.ParseExact ("02/25/2002", "d", null,
 538                                           DateTimeStyles.AllowWhiteSpaces);
 539                 AssertEquals ("G04", myTicks[0], t1.Ticks);
 540
 541                 t1 = DateTime.ParseExact ("    02/25/2002", "d", null,
 542                                           DateTimeStyles.AllowLeadingWhite);
 543                 AssertEquals ("G05", myTicks[0], t1.Ticks);
 544
 545                 t1 = DateTime.ParseExact ("02/25/2002    ", "d", null,
 546                                           DateTimeStyles.AllowTrailingWhite);
 547                 AssertEquals ("G06", myTicks[0], t1.Ticks);
 548
 549                 t1 = DateTime.ParseExact ("  02 / 25 / 2002    ", "d", null,
 550                                           DateTimeStyles.AllowWhiteSpaces);
 551                 AssertEquals ("G07", myTicks[0], t1.Ticks);
 552
 553                 // Multi Custom Patterns
 554                 string rfc1123_date = "r";
 555                 string rfc850_date = "dddd, dd'-'MMM'-'yy HH':'mm':'ss 'GMT'";
 556                 string asctime_date = "ddd MMM d HH':'mm':'ss yyyy";
 557                 string [] formats = new string [] {rfc1123_date, rfc850_date, asctime_date};
 558                 CultureInfo enUS = new CultureInfo("en-US", false);
 559                 t1 = DateTime.ParseExact ("Sun, 06 Nov 1994 08:49:37 GMT", formats[0], enUS,
 560                                         DateTimeStyles.AllowWhiteSpaces);
 561                 AssertEquals ("M01", myTicks[6], t1.Ticks);
 562                 t1 = DateTime.ParseExact ("Sunday, 06-Nov-94 08:49:37 GMT", formats[1], enUS,
 563                                         DateTimeStyles.AllowWhiteSpaces);
 564                 AssertEquals ("M02", myTicks[6], t1.Ticks);
 565                 t1 = DateTime.ParseExact ("Sun Nov  6 08:49:37 1994", formats[2], enUS,
 566                                         DateTimeStyles.AllowWhiteSpaces);
 567                 AssertEquals ("M03", myTicks[6], t1.Ticks);
 568                 t1 = DateTime.ParseExact ("Sun, 06 Nov 1994 08:49:37 GMT", formats, enUS,
 569                                         DateTimeStyles.AllowWhiteSpaces);
 570                 AssertEquals ("M04", myTicks[6], t1.Ticks);
 571                 t1 = DateTime.ParseExact ("Sunday, 06-Nov-94 08:49:37 GMT", formats, enUS,
 572                                         DateTimeStyles.AllowWhiteSpaces);
 573                 AssertEquals ("M05", myTicks[6], t1.Ticks);
 574                 t1 = DateTime.ParseExact ("Sun Nov  6 08:49:37 1994", formats, enUS,
 575                                         DateTimeStyles.AllowWhiteSpaces);
 576                 AssertEquals ("M06", myTicks[6], t1.Ticks);
 577
 578                 // Bug 52274
 579                 t1 = DateTime.ParseExact ("--12--", "--MM--" , null);
 580                 AssertEquals("Dash01", 12, t1.Month);
 581                 t1=DateTime.ParseExact ("--12-24", "--MM-dd" , null);
 582                 AssertEquals("Dash02", 24, t1.Day);
 583                 AssertEquals("Dash03", 12, t1.Month);
 584                 t1=DateTime.ParseExact ("---24", "---dd" , null);
 585                 AssertEquals("Dash04", 24, t1.Day);
 586
 587                 // Bug 63376
 588                 t1 = DateTime.ParseExact ("18Aug2004 12:33:00", "ddMMMyyyy hh:mm:ss", new CultureInfo ("en-US"));
 589                 AssertEquals ("hh allows 12, though it's useless", 0, t1.Hour);
 590
 591                 // Bug 74775
 592                 DateTime.ParseExact ("Tue, 12 Apr 2005 10:10:04 +0100",
 593                         "Tue, 12 Apr 2005 10:10:04 +0100", enUS);
 594                 try {
 595                         DateTime.ParseExact ("Tue, 12 Apr 2005 10:10:04 +00000",
 596                                 "ddd, dd MMM yyyy HH':'mm':'ss zzz", enUS);
 597                         Fail ("z02");
 598                 } catch (FormatException) {
 599                 }
 600
 601                 // Bug #75213 : literal escaping.
 602                 t1 = DateTime.ParseExact ("20050707132527Z",
 603                         "yyyyMMddHHmmss\\Z", CultureInfo.InvariantCulture);
 604                 AssertEquals ("Literal1.Ticks", 632563395270000000, t1.Ticks);
 605         }
 606
 607         [Test]
 608         [Ignore ("need to fix tests that run on different timezones")]
 609         public void TestParse2 ()
 610         {
 611                 DateTime t1 = DateTime.Parse ("Mon, 25 Feb 2002 04:25:13 GMT");
 612                 t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1);
 613                 AssertEquals ("H10d", 04 - TimeZone.CurrentTimeZone.GetUtcOffset(t1).Hours, t1.Hour);
 614
 615         }
 616
 617         [Test]
 618         public void TestParse ()
 619         {
 620                 // Standard patterns
 621                 DateTime t1 = DateTime.Parse ("02/25/2002");
 622                 AssertEquals ("H00", myTicks[0], t1.Ticks);
 623                 try {
 624                         t1 = DateTime.Parse ("02-25-2002");
 625                 }
 626                 catch (Exception e) {
 627                         Fail ("Unexpected exception. e=" + e);
 628                 }
 629                 try {
 630                         t1 = DateTime.Parse ("2002-02-25");
 631                 }
 632                 catch (Exception e) {
 633                         Fail ("Unexpected exception. e=" + e);
 634                 }
 635                 AssertEquals ("H01", myTicks[0], t1.Ticks);
 636                 t1 = DateTime.Parse ("Monday, 25 February 2002");
 637                 AssertEquals ("H02", myTicks[0], t1.Ticks);
 638                 t1 = DateTime.Parse ("Monday, 25 February 2002 05:25");
 639                 AssertEquals ("H03", myTicks[3], t1.Ticks);
 640                 t1 = DateTime.Parse ("Monday, 25 February 2002 05:25:13");
 641                 AssertEquals ("H04", myTicks[4], t1.Ticks);
 642                 t1 = DateTime.Parse ("02/25/2002 05:25");
 643                 AssertEquals ("H05", myTicks[3], t1.Ticks);
 644                 t1 = DateTime.Parse ("02/25/2002 05:25:13");
 645                 AssertEquals ("H06", myTicks[4], t1.Ticks);
 646                 t1 = DateTime.Parse ("2002-02-25 04:25:13Z");
 647                 t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1);
 648                 AssertEquals ("H07a", 2002, t1.Year);
 649                 AssertEquals ("H07b", 02, t1.Month);
 650                 AssertEquals ("H07c", 25, t1.Day);
 651                 AssertEquals ("H07d", 04, t1.Hour);
 652                 AssertEquals ("H07e", 25, t1.Minute);
 653                 AssertEquals ("H07f", 13, t1.Second);
 654
 655                 DateTime t2 = new DateTime (DateTime.Today.Year, 2, 25);
 656                 t1 = DateTime.Parse ("February 25");
 657                 AssertEquals ("H08", t2.Ticks, t1.Ticks);
 658
 659                 t2 = new DateTime (DateTime.Today.Year, 2, 8);
 660                 t1 = DateTime.Parse ("February 08");
 661                 AssertEquals ("H09", t2.Ticks, t1.Ticks);
 662
 663                 // parsed as UTC string
 664                 t1 = DateTime.Parse ("Mon, 25 Feb 2002 04:25:13 GMT");
 665                 t1 = TimeZone.CurrentTimeZone.ToUniversalTime (t1);
 666                 AssertEquals ("H10a", 2002, t1.Year);
 667                 AssertEquals ("H10b", 02, t1.Month);
 668                 AssertEquals ("H10c", 25, t1.Day);
 669                 AssertEquals ("H10d", 4, t1.Hour);
 670                 AssertEquals ("H10e", 25, t1.Minute);
 671                 AssertEquals ("H10f", 13, t1.Second);
 672
 673                 t1 = DateTime.Parse ("2002-02-25T05:25:13");
 674                 AssertEquals ("H11", myTicks[4], t1.Ticks);
 675
 676                 t2 = DateTime.Today + new TimeSpan (5,25,0);
 677                 t1 = DateTime.Parse ("05:25");
 678                 AssertEquals("H12", t2.Ticks, t1.Ticks);
 679
 680                 t2 = DateTime.Today + new TimeSpan (5,25,13);
 681                 t1 = DateTime.Parse ("05:25:13");
 682                 AssertEquals("H13", t2.Ticks, t1.Ticks);
 683
 684                 t2 = new DateTime (2002, 2, 1);
 685                 t1 = DateTime.Parse ("2002 February");
 686                 AssertEquals ("H14", t2.Ticks, t1.Ticks);
 687
 688                 t2 = new DateTime (2002, 2, 1);
 689                 t1 = DateTime.Parse ("2002 February", new CultureInfo ("ja-JP"));
 690                 AssertEquals ("H15", t2.Ticks, t1.Ticks);
 691
 692                 t2 = new DateTime (DateTime.Today.Year, 2, 8);
 693                 t1 = DateTime.Parse ("February 8");
 694                 AssertEquals ("H16", t2.Ticks, t1.Ticks);
 695
 696                 // bug #72132
 697                 t2 = new DateTime (2002, 2, 25, 5, 25, 22);
 698                 t1 = DateTime.Parse ("Monday, 25 February 2002 05:25:22",
 699                         new CultureInfo ("hi-IN"));
 700                 AssertEquals ("H17", t2.Ticks, t1.Ticks);
 701                 t2 = new DateTime (2002, 2, 25, 5, 25, 0);
 702                 t1 = DateTime.Parse ("Monday, 25 February 2002 05:25",
 703                         new CultureInfo ("hi-IN"));
 704                 AssertEquals ("H18", t2.Ticks, t1.Ticks);
 705
 706                 // ASP.NET QuickStarts
 707                 t2 = new DateTime (2002, 10, 7, 15, 6, 0);
 708                 t1 = DateTime.Parse ("3:06 PM 10/7/2002");
 709                 AssertEquals ("H19a", t2.Ticks, t1.Ticks);
 710
 711                 t2 = new DateTime (2002, 10, 7, 15, 6, 0);
 712                 t1 = DateTime.Parse ("3:06 pm 10/7/2002");
 713                 AssertEquals ("H19b", t2.Ticks, t1.Ticks);
 714
 715                 t2 = new DateTime (2002, 10, 7, 3, 6, 0);
 716                 t1 = DateTime.Parse ("3:06 AM 10/7/2002");
 717                 AssertEquals ("H19c", t2.Ticks, t1.Ticks);
 718
 719                 t2 = new DateTime (2002, 10, 7, 3, 6, 0);
 720                 t1 = DateTime.Parse ("3:06 am 10/7/2002");
 721                 AssertEquals ("H19d", t2.Ticks, t1.Ticks);
 722         }
 723
 724         [Test]
 725         public void TestParse3 ()
 726         {
 727                 string s = "Wednesday, 09 June 2004";
 728                 DateTime.ParseExact (s, "dddd, dd MMMM yyyy", CultureInfo.InvariantCulture);
 729                 try {
 730                         DateTime.ParseExact (s, "dddd, dd MMMM yyyy", new CultureInfo ("ja-JP"));
 731                         Fail ("ja-JP culture does not support format \"dddd, dd MMMM yyyy\"");
 732                 } catch (FormatException) {
 733                 }
 734
 735                 // Ok, now we can assume ParseExact() works expectedly.
 736
 737                 DateTime.Parse (s, CultureInfo.InvariantCulture, DateTimeStyles.AllowWhiteSpaces);
 738                 DateTime.Parse (s, new CultureInfo ("ja-JP"), DateTimeStyles.AllowWhiteSpaces);
 739                 //DateTime.Parse (s, null); currently am not sure if it works for _every_ culture.
 740         }
 741
 742
 743         [Test]
 744         // bug #74936
 745         public void TestParse4 ()
 746         {
 747                 try {
 748                         DateTime.Parse("1");
 749                         Fail ("#1");
 750                 } catch (FormatException) {
 751                 }
 752
 753                 try {
 754                         DateTime.Parse("1000");
 755                         Fail ("#1");
 756                 } catch (FormatException) {
 757                 }
 758
 759                 try {
 760                         DateTime.Parse("8:");
 761                         Fail ("#1");
 762                 } catch (FormatException) {
 763                 }
 764         }
 765
 766         [Test]
 767         public void Parse_Bug71289a ()
 768         {
 769                 // bug #71289
 770                 DateTime.Parse ("Sat,,,,,, 01 Oct 1994 03:00:00", CultureInfo.InvariantCulture);
 771         }
 772
 773         [Test]
 774         public void Parse_Bug71289b ()
 775         {
 776                 // more example...
 777                 DateTime.Parse ("Sat,,, 01,,, Oct,,, ,,,1994 03:00:00", CultureInfo.InvariantCulture);
 778         }
 779
 780 #if NET_2_0
 781         [Test]
 782         [ExpectedException (typeof (FormatException))]
 783         public void Parse_CommaAfterHours ()
 784         {
 785                 // ',' after 03 is not allowed.
 786                 DateTime.Parse ("Sat,,, 01,,, Oct,,, ,,,1994 03,:00:00", CultureInfo.InvariantCulture);
 787         }
 788 #endif
 789
 790         [Test]
 791         public void Parse_Bug72788 ()
 792         {
 793                 // bug #72788
 794                 DateTime dt = DateTime.Parse ("21/02/05", new CultureInfo ("fr-FR"));
 795                 AssertEquals (2005, dt.Year);
 796                 AssertEquals (02, dt.Month);
 797                 AssertEquals (21, dt.Day);
 798         }
 799
 800         [Test]
 801         [Category ("NotWorking")] // Mono accept this format for ALL cultures
 802         public void Parse_Bug53023a ()
 803         {
 804                 foreach (CultureInfo ci in CultureInfo.GetCultures (CultureTypes.SpecificCultures)) {
 805                         FormatException e = null;
 806                         try {
 807                                 // this fails for MOST culture under MS 1.1 SP1
 808                                 DateTime.Parse ("8/16/2005", ci);
 809                         }
 810                         catch (FormatException fe) {
 811                                 e = fe;
 812                         }
 813                         string c = ci.ToString ();
 814                         switch (c) {
 815                         case "af-ZA":
 816                         case "en-CB":
 817                         case "en-PH":
 818                         case "en-US":
 819                         case "en-ZA":
 820                         case "en-ZW":
 821                         case "es-PA":
 822                         case "eu-ES":
 823                         case "fa-IR":
 824                         case "fr-CA":
 825                         case "hu-HU":
 826                         case "ja-JP":
 827                         case "ko-KR":
 828                         case "lv-LV":
 829                         case "lt-LT":
 830                         case "mn-MN":
 831                         case "pl-PL":
 832                         case "sq-AL":
 833                         case "sv-SE":
 834                         case "sw-KE":
 835                         case "zh-CN":
 836                         case "zh-TW":
 837 #if NET_2_0
 838                         case "ns-ZA":
 839                         case "se-SE":
 840                         case "sma-SE":
 841                         case "smj-SE":
 842                         case "tn-ZA":
 843                         case "xh-ZA":
 844                         case "zu-ZA":
 845 #endif
 846                                 Assert (c, (e == null));
 847                                 break;
 848                         default:
 849                                 Assert (c, (e != null));
 850                                 break;
 851                         }
 852                 }
 853         }
 854
 855         [Test]
 856         public void Parse_Bug53023b ()
 857         {
 858                 foreach (CultureInfo ci in CultureInfo.GetCultures (CultureTypes.SpecificCultures)) {
 859                         DateTime.Parse ("01-Sep-05", ci);
 860                         DateTime.Parse ("4:35:35 AM", ci);
 861                 }
 862         }
 863
 864         [Test]
 865         [ExpectedException (typeof (FormatException))]
 866         public void Parse_DontAccept2DigitsYears ()
 867         {
 868                 // don't allow 2 digit years where we require 4.
 869                 DateTime.ParseExact ("05", "yyyy", CultureInfo.InvariantCulture);
 870         }
 871
 872         [Test]
 873         public void ParseCOMDependentFormat ()
 874         {
 875                 // Japanese format.
 876                 DateTime.Parse (String.Format (
 877                         "{0}\u5E74{1}\u6708{2}\u65E5 {3}\u6642{4}\u5206{5}\u79D2",
 878                         2006, 3, 1, 15, 32, 42), new CultureInfo (""));
 879
 880                 try {
 881                         // incorrect year mark.
 882                         DateTime.Parse (String.Format (
 883                                 "{0}\u4E00{1}\u6708{2}\u65E5 {3}\u6642{4}\u5206{5}\u79D2",
 884                                 2006, 3, 1, 15, 32, 42), new CultureInfo (""));
 885                         Fail ();
 886                 } catch (FormatException) {
 887                 }
 888         }
 889
 890         [Test]
 891         [ExpectedException(typeof (FormatException))]
 892         public void ParseFormatException1 ()
 893         {
 894                 // Following string is not a correct French date i.e.
 895                 // MM/dd/yyyy HH:mm:ss since it expects d/M/yyyy HH:mm:ss
 896                 // instead (however fr-FR accepts both MM/dd/yyyy and
 897                 // dd/MM/yyyy, which means that we can't just throw exceptions
 898                 // on overflow).
 899                 String frDateTime = "11/13/2003 11:28:15";
 900                 IFormatProvider format = new CultureInfo("fr-FR", true);
 901                 DateTime t1 = DateTime.Parse(frDateTime, format);
 902         }
 903
 904         public void TestOA ()
 905         {
 906                 double number=5000.41443;
 907                 DateTime d = DateTime.FromOADate(number);
 908                 DTAssertEquals ("I01", d, new DateTime(1913, 9, 8, 9, 56, 46, 0), Resolution.Second);
 909                 AssertEquals ("I02", d.ToOADate(), number);
 910         }
 911
 912         [Test]
 913         public void ParseAllowsQueerString ()
 914         {
 915                 DateTime.Parse ("Sat,,,,,, 01 Oct 1994 03:00:00", CultureInfo.InvariantCulture);
 916         }
 917
 918         [Test]
 919         public void ParseUtcNonUtc ()
 920         {
 921                 Thread.CurrentThread.CurrentCulture = new CultureInfo ("es-ES");
 922
 923                 CultureInfo ci;
 924                 string s, s2, s3, d;
 925                 DateTime dt;
 926                 DateTimeFormatInfo dfi = DateTimeFormatInfo.InvariantInfo;
 927                 s = dfi.UniversalSortableDateTimePattern;
 928                 s2 = "r";
 929
 930                 s3 = "s";
 931
 932                 long tick1 = 631789220960000000; // 2003-01-23 12:34:56 as is
 933                 long tick2 = TimeZone.CurrentTimeZone.ToLocalTime (new DateTime (tick1)).Ticks; // adjusted to local time
 934
 935                 // invariant
 936                 ci = CultureInfo.InvariantCulture;
 937
 938                 d = "2003/01/23 12:34:56";
 939                 dt = DateTime.Parse (d, ci);
 940                 AssertEquals (d, tick1, dt.Ticks);
 941
 942                 d = "2003/01/23 12:34:56 GMT";
 943                 dt = DateTime.Parse (d, ci);
 944                 AssertEquals (d, tick2, dt.Ticks);
 945
 946                 d = "Thu, 23 Jan 2003 12:34:56 GMT";
 947                 dt = DateTime.ParseExact (d, s2, ci);
 948                 AssertEquals (d, tick1, dt.Ticks);
 949
 950                 d = "2003-01-23 12:34:56Z";
 951                 dt = DateTime.ParseExact (d, s, ci);
 952                 AssertEquals (d, tick1, dt.Ticks);
 953
 954                 d = "2003-01-23T12:34:56";
 955                 dt = DateTime.ParseExact (d, s3, ci);
 956                 AssertEquals (d, tick1, dt.Ticks);
 957
 958                 // ja-JP ... it should be culture independent
 959                 ci = new CultureInfo ("ja-JP");
 960
 961                 d = "2003/01/23 12:34:56";
 962                 dt = DateTime.Parse (d, ci);
 963                 AssertEquals (d, tick1, dt.Ticks);
 964
 965                 d = "2003/01/23 12:34:56 GMT";
 966                 dt = DateTime.Parse (d, ci);
 967                 AssertEquals (d, tick2, dt.Ticks);
 968
 969                 d = "Thu, 23 Jan 2003 12:34:56 GMT";
 970                 dt = DateTime.ParseExact (d, s2, ci);
 971                 AssertEquals (d, tick1, dt.Ticks);
 972
 973                 d = "2003-01-23 12:34:56Z";
 974                 dt = DateTime.ParseExact (d, s, ci);
 975                 AssertEquals (d, tick1, dt.Ticks);
 976
 977                 d = "2003-01-23T12:34:56";
 978                 dt = DateTime.ParseExact (d, s3, ci);
 979                 AssertEquals (d, tick1, dt.Ticks);
 980         }
 981
 982         [Test]
 983         public void TimeZoneAdjustment ()
 984         {
 985                 CultureInfo ci = Thread.CurrentThread.CurrentCulture;
 986                 try {
 987                         Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US");
 988                         DateTime d1 = DateTime.ParseExact ("2004/06/30", "yyyy/MM/dd", null);
 989                         DateTime d2 = DateTime.ParseExact ("2004/06/30Z", "yyyy/MM/dd'Z'", null);
 990                         DateTime d3 = DateTime.ParseExact ("Wed, 30 Jun 2004 00:00:00 GMT", "ddd, dd MMM yyyy HH':'mm':'ss 'GMT'", null);
 991                         DateTime d4 = DateTime.ParseExact ("2004-06-30 00:00:00Z", "yyyy'-'MM'-'dd HH':'mm':'ss'Z'", null);
 992                         StringWriter sw = new StringWriter ();
 993                         sw.Write ("{0} {1}", d1.Ticks, d1);
 994                         AssertEquals ("#1", "632241504000000000 6/30/2004 12:00:00 AM", sw.ToString ());
 995                         sw.GetStringBuilder ().Length = 0;
 996                         sw.Write ("{0} {1}", d2.Ticks, d2);
 997                         AssertEquals ("#2", "632241504000000000 6/30/2004 12:00:00 AM", sw.ToString ());
 998                         sw.GetStringBuilder ().Length = 0;
 999                         sw.Write ("{0} {1}", d3.Ticks, d3);
1000                         AssertEquals ("#3", "632241504000000000 6/30/2004 12:00:00 AM", sw.ToString ());
1001                         sw.GetStringBuilder ().Length = 0;
1002                         sw.Write ("{0} {1}", d4.Ticks, d4);
1003                         AssertEquals ("#4", "632241504000000000 6/30/2004 12:00:00 AM", sw.ToString ());
1004                 } finally {
1005                         Thread.CurrentThread.CurrentCulture = ci;
1006                 }
1007
1008                 // bug #76082
1009                 AssertEquals ("bug #76082", DateTime.MinValue,
1010                         DateTime.ParseExact ("00010101T00:00:00",
1011                                 "yyyyMMdd'T'HH':'mm':'ss",
1012                                 DateTimeFormatInfo.InvariantInfo));
1013         }
1014
1015         [Test]
1016         public void DateTimeStylesAdjustToUniversal ()
1017         {
1018                 // bug #75995 : AdjustToUniversal
1019                 DateTime t1 = DateTime.Parse ("2005-09-05T22:29:00Z",
1020                         CultureInfo.InvariantCulture,
1021                         DateTimeStyles.AdjustToUniversal);
1022                 AssertEquals ("2005-09-05 22:29:00Z", t1.ToString ("u"));
1023         }
1024
1025         [Test]
1026         [ExpectedException (typeof (ArgumentException))]
1027         public void FromOADate_Min ()
1028         {
1029                 // minimum documented value isn't inclusive
1030                 DateTime.FromOADate (-657435.0d);
1031         }
1032
1033         [Test]
1034         [ExpectedException (typeof (ArgumentException))]
1035         public void FromOADate_Max ()
1036         {
1037                 // maximum documented value isn't inclusive
1038                 DateTime.FromOADate (2958466.0d);
1039         }
1040
1041         [Test]
1042         public void FromOADate ()
1043         {
1044                 // Note: OA (OLE Automation) dates aren't timezone sensitive
1045                 AssertEquals ("Ticks-Zero", 599264352000000000, DateTime.FromOADate (0.0d).Ticks);
1046                 AssertEquals ("Ticks-Min", 31242239136000000, DateTime.FromOADate (-657434.999d).Ticks);
1047                 AssertEquals ("Ticks-Max", 3155378975136000000, DateTime.FromOADate (2958465.999d).Ticks);
1048         }
1049
1050         [Test]
1051         public void ToOADate ()
1052         {
1053                 // Note: OA (OLE Automation) dates aren't timezone sensitive
1054                 DateTime d = new DateTime (0);
1055                 AssertEquals ("Unititialized", 0.0d, d.ToOADate ());
1056                 d = new DateTime (599264352000000000);
1057                 AssertEquals ("Ticks-Zero", 0.0d, d.ToOADate ());
1058                 d = new DateTime (31242239136000000);
1059                 AssertEquals ("Ticks-Min", -657434.999d, d.ToOADate ());
1060                 d = new DateTime (3155378975136000000);
1061                 AssertEquals ("Ticks-Max", 2958465.999d, d.ToOADate ());
1062         }
1063
1064         [Test]
1065         public void ToOADate_OverMax ()
1066         {
1067                 DateTime d = new DateTime (3155378975136000001);
1068                 AssertEquals ("Over-Max", 2958465.999d, d.ToOADate ());
1069         }
1070
1071         [Test]
1072         public void ToOADate_MaxValue ()
1073         {
1074                 AssertEquals ("MaxValue", 2958465.99999999d, DateTime.MaxValue.ToOADate ());
1075         }
1076
1077         [Test]
1078         public void ToOADate_UnderMin ()
1079         {
1080                 DateTime d = new DateTime (31242239135999999);
1081                 AssertEquals ("Under-Min", -657434.999d, d.ToOADate ());
1082         }
1083
1084         [Test]
1085         public void ToOADate_MinValue ()
1086         {
1087                 AssertEquals ("MinValue", 0, DateTime.MinValue.ToOADate ());
1088         }
1089
1090         [Test]
1091         public void MaxValueYear () // bug52075
1092         {
1093                 AssertEquals ("#01", "9999", DateTime.MaxValue.Year.ToString ());
1094         }
1095
1096         [Test]
1097         public void X509Certificate ()
1098         {
1099                 // if this test fails then *ALL* or *MOST* X509Certificate tests will also fails
1100                 DateTime dt = DateTime.ParseExact ("19960312183847Z", "yyyyMMddHHmmssZ", null);
1101 #if NET_2_0
1102                 AssertEquals ("Kind-Local-1", DateTimeKind.Local, dt.Kind);
1103                 dt = dt.ToUniversalTime ();
1104                 AssertEquals ("Kind-Utc-1", DateTimeKind.Utc, dt.Kind);
1105 #else
1106                 dt = dt.ToUniversalTime ();
1107 #endif
1108                 AssertEquals ("yyyyMMddHHmmssZ", "03/12/1996 18:38:47", dt.ToString ());
1109
1110                 // technically this is invalid (PKIX) because of the missing seconds but it exists so...
1111                 dt = DateTime.ParseExact ("9602231915Z", "yyMMddHHmmZ", null);
1112 #if NET_2_0
1113                 AssertEquals ("Kind-Local-2", DateTimeKind.Local, dt.Kind);
1114                 dt = dt.ToUniversalTime ();
1115                 AssertEquals ("Kind-Utc-2", DateTimeKind.Utc, dt.Kind);
1116 #else
1117                 dt = dt.ToUniversalTime ();
1118 #endif
1119                 AssertEquals ("yyMMddHHmmZ", "02/23/1996 19:15:00", dt.ToString ());
1120         }
1121
1122         [Test]
1123 #if NET_2_0
1124         [Category ("NotWorking")]       // see bug #
1125 #endif
1126         public void ZLiteral ()
1127         {
1128                 // However, "Z" and "'Z'" are different.
1129                 DateTime dt = DateTime.ParseExact ("19960312183847Z", "yyyyMMddHHmmss'Z'", null);
1130                 DateTime dtz = DateTime.ParseExact ("19960312183847Z", "yyyyMMddHHmmssZ", null);
1131 #if NET_2_0
1132                 AssertEquals ("Kind-Unspecified-3", DateTimeKind.Unspecified, dt.Kind);
1133                 dt = dt.ToLocalTime ();
1134                 AssertEquals ("Kind-Local-3a", DateTimeKind.Local, dt.Kind);
1135                 AssertEquals ("Kind-Local-3b", DateTimeKind.Local, dtz.Kind);
1136 #else
1137                 dt = dt.ToLocalTime ();
1138 #endif
1139                 AssertEquals ("Z timezone handling", dt, dtz);
1140         }
1141
1142         [Test]
1143         public void QuotedFormat () // bug 56436
1144         {
1145                 string date = "28/Mar/2004:19:12:37 +0200";
1146                 string [] expectedFormats = {"dd\"/\"MMM\"/\"yyyy:HH:mm:ss zz\"00\""};
1147                 DateTime mydate = DateTime.ParseExact (date, expectedFormats, null, DateTimeStyles.AllowWhiteSpaces);
1148         }
1149
1150         [Test]
1151         public void CultureIndependentTests ()
1152         {
1153                 // Here I aggregated some tests mainly because of test
1154                 // performance (iterating all the culture is heavy process).
1155
1156                 for (int i = 0; i < 32768; i++) {
1157                         CultureInfo ci = null;
1158                         string stage = "init";
1159                         try {
1160                                 try {
1161                                         ci = new CultureInfo (i);
1162                                         // In fact InvatiantCulture is not neutral.
1163                                         // See bug #59716.
1164                                         if (ci.IsNeutralCulture && ci != CultureInfo.InvariantCulture)
1165                                                 continue;
1166                                 } catch (Exception) {
1167                                         continue;
1168                                 }
1169                                 Thread.CurrentThread.CurrentCulture = ci;
1170                                 DateTime dt;
1171
1172                                 // Common patterns
1173                                 // X509Certificate pattern is _always_ accepted.
1174                                 stage = "1";
1175                                 dt = DateTime.ParseExact ("19960312183847Z", "yyyyMMddHHmmssZ", null);
1176 #if NET_1_1
1177                                 stage = "2";
1178                                 // culture 1025 ar-SA fails
1179 //                              if (i != 127)
1180 //                                      dt = DateTime.Parse ("19960312183847Z");
1181 #endif
1182                                 stage = "3";
1183                                 dt = DateTime.Parse ("2004-05-26T03:29:01.1234567");
1184                                 stage = "4";
1185                                 dt = DateTime.Parse ("2004-05-26T03:29:01.1234567-07:00");
1186
1187                                 // memo: the least LCID is 127, and then 1025(ar-SA)
1188
1189                                 // "th-TH" locale rejects them since in
1190                                 // ThaiBuddhistCalendar the week of a day is different.
1191                                 // (and also for years).
1192                                 if (ci.LCID != 1054) {
1193                                         try {
1194                                                 stage = "5";
1195                                                 dt = DateTime.Parse ("Sat, 29 Oct 1994 12:00:00 GMT", ci);
1196                                         } catch (FormatException ex) {
1197                                                 Fail (String.Format ("stage 5.1 RFC1123: culture {0} {1} failed: {2}", i, ci, ex.Message));
1198                                         }
1199 /* comment out until we fix RFC1123
1200                                         // bug #47720
1201                                         if (dt != TimeZone.CurrentTimeZone.ToUniversalTime (dt))
1202                                                 Assert (String.Format ("bug #47720 on culture {0} {1}", ci.LCID, ci), 12 != dt.Hour);
1203 */
1204                                         // variant of RFC1123
1205                                         try {
1206                                                 stage = "6";
1207                                                 dt = DateTime.Parse ("Sat, 1 Oct 1994 03:00:00", ci);
1208                                         } catch (FormatException ex) {
1209                                                 Fail (String.Format ("stage 6.1 RFC1123 variant: culture {0} {1} failed: {2}", i, ci, ex.Message));
1210                                         }
1211                                         stage = "7";
1212                                         AssertEquals (String.Format ("stage 7.1 RFC1123 variant on culture {0} {1}", ci.LCID, ci), 3, dt.Hour);
1213                                 }
1214
1215                                 switch (ci.LCID) {
1216                                 case 1025: // ar-SA
1217                                 case 1054: // th-TH
1218                                 case 1125: // div-MV
1219                                         break;
1220                                 default:
1221                                         stage = "8";
1222                                         // 02/25/2002 04:25:13 as is
1223                                         long tick1 = 631502079130000000;
1224                                         long tick2 = TimeZone.CurrentTimeZone.ToLocalTime (new DateTime (tick1)).Ticks; // adjusted to local time
1225                                         dt = DateTime.Parse ("Mon, 25 Feb 2002 04:25:13 GMT", ci);
1226                                         AssertEquals (String.Format ("GMT variant. culture={0} {1}", i, ci), tick2, dt.Ticks);
1227                                         break;
1228                                 }
1229
1230 #if NET_1_1
1231                                 // ka-GE rejects these formats under MS.NET.
1232                                 // I wonder why. Also, those tests fail under .NET 1.0.
1233                                 if (ci.LCID != 1079) {
1234                                         stage = "9";
1235                                         dt = DateTime.Parse ("2002-02-25");
1236                                         stage = "10";
1237                                         dt = DateTime.Parse ("2002-02-25Z");
1238                                         stage = "11";
1239                                         dt = DateTime.Parse ("2002-02-25T19:20:00+09:00");
1240                                         switch (ci.LCID) {
1241                                         case 1038: // FIXME: MS passes this culture.
1242                                         case 1062: // FIXME: MS passes this culture.
1243                                         case 1078: // MS does not pass this culture. Dunno why.
1244                                                 break;
1245                                         default:
1246 #if ONLY_1_1
1247                                                 // bug #58938
1248                                                 stage = "12";
1249                                                 dt = DateTime.Parse ("2002#02#25 19:20:00");
1250                                                 // this stage fails under MS 2.0
1251                                                 stage = "13";
1252                                                 AssertEquals (String.Format ("bug #58938 on culture {0} {1}", ci.LCID, ci), 19, dt.Hour);
1253 #endif
1254                                                 break;
1255                                         }
1256                                         stage = "14";
1257                                         dt = DateTime.Parse ("2002-02-25 12:01:03");
1258 #if ONLY_1_1
1259                                         stage = "15";
1260                                         dt = DateTime.Parse ("2002#02#25 12:01:03");
1261                                         stage = "16";
1262                                         dt = DateTime.Parse ("2002%02%25 12:01:03");
1263 #endif
1264                                         stage = "17";
1265                                         if (ci.DateTimeFormat.TimeSeparator != ".")
1266                                                 dt = DateTime.Parse ("2002.02.25 12:01:03");
1267                                         stage = "18";
1268                                         dt = DateTime.Parse ("2003/01/23 01:34:56 GMT");
1269                                         dt = TimeZone.CurrentTimeZone.ToUniversalTime (dt);
1270                                         AssertEquals (String.Format ("stage 18.1 RFC1123 UTC {0} {1}", i, ci), 1, dt.Hour);
1271                                         stage = "19";
1272                                         // This test was fixed from 12:34:56 to
1273                                         // 01:34:56 since 1078 af-ZA failed
1274                                         // because of hour interpretation
1275                                         // difference (af-ZA expects 0).
1276                                         // (IMHO it is MS BUG though.)
1277                                         dt = DateTime.Parse ("2003/01/23 12:34:56 GMT");
1278                                         dt = TimeZone.CurrentTimeZone.ToUniversalTime (dt);
1279                                         if (i != 1078)
1280                                                 AssertEquals (String.Format ("stage 18.1 RFC1123 UTC {0} {1}", i, ci), 12, dt.Hour);
1281                                 }
1282 #endif
1283                         } catch (FormatException ex) {
1284                                 Fail (String.Format ("stage {3}: Culture {0} {1} failed: {2}", i, ci, ex.Message, stage));
1285                         }
1286                 }
1287         }
1288
1289         [Test]
1290         [ExpectedException (typeof (ArgumentOutOfRangeException))]
1291         public void ToFileTime_MinValue ()
1292         {
1293                 DateTime.FromFileTime (Int64.MinValue);
1294         }
1295
1296         [Test]
1297         [ExpectedException (typeof (ArgumentOutOfRangeException))]
1298         public void ToFileTime_Negative ()
1299         {
1300                 DateTime.FromFileTime (-1);
1301         }
1302
1303         [Test]
1304         public void ToFileTime ()
1305         {
1306                 long u = DateTime.FromFileTimeUtc (0).Ticks;
1307                 AssertEquals ("Utc-0", 504911232000000000, u);
1308                 long max = DateTime.MaxValue.Ticks - 504911232000000000; // w32file_epoch
1309                 AssertEquals ("Utc-MaxValue", 3155378975999999999, DateTime.FromFileTimeUtc (max).Ticks);
1310
1311                 long t = DateTime.FromFileTime (0).Ticks;
1312                 Assert ("ToFileTime>", t > (u - TimeSpan.TicksPerDay));
1313                 Assert ("ToFileTime<", t < (u + TimeSpan.TicksPerDay));
1314         }
1315
1316         [Test]
1317         [ExpectedException (typeof (ArgumentOutOfRangeException))]
1318         public void ToFileTimeUtc_MinValue ()
1319         {
1320                 DateTime.FromFileTimeUtc (Int64.MinValue);
1321         }
1322
1323         [Test]
1324         [ExpectedException (typeof (ArgumentOutOfRangeException))]
1325         public void ToFileTimeUtc_Negative ()
1326         {
1327                 DateTime.FromFileTimeUtc (-1);
1328         }
1329
1330         [Test]
1331         public void Milliseconds ()
1332         {
1333                 DateTime dt = DateTime.Parse ("2004-05-26T03:29:01.1234567-07:00");
1334                 dt = TimeZone.CurrentTimeZone.ToUniversalTime (dt);
1335                 AssertEquals ("DateTime with milliseconds", 632211641411234567, dt.Ticks);
1336         }
1337
1338         [Test]
1339 #if NET_2_0
1340         [ExpectedException (typeof (FormatException))]
1341 #else
1342         [Ignore ("Works only under MS 1.x (not Mono or MS 2.0).")]
1343 #endif
1344         public void ParseNotExact ()
1345         {
1346                 // The error reported is:
1347                 // String was not recognized as valid DateTime
1348                 DateTime dt = DateTime.Parse ("2004-05-26T03:29:01-07:00 foo");
1349                 dt = TimeZone.CurrentTimeZone.ToUniversalTime (dt);
1350                 AssertEquals ("DateTime.Parse not exact", 632211641410000000, dt.Ticks);
1351         }
1352
1353         [Test]
1354         public void ParseExact_Bug80094 ()
1355         {
1356                 // we can safely change the curernt culture, as the original value will
1357                 // be restored on TearDown
1358                 Thread.CurrentThread.CurrentCulture = new CultureInfo ("ja-JP");
1359                 string y = string.Format ("{0}-{1}-{2} {3}", DateTime.Now.Year.ToString (),
1360                         "11", "29", "06:34");
1361                 DateTime date = DateTime.ParseExact (y, "yyyy-MMM-dd hh:mm", null);
1362                 AssertEquals ("#1", DateTime.Now.Year, date.Year);
1363                 AssertEquals ("#2", 11, date.Month);
1364                 AssertEquals ("#3", 29, date.Day);
1365                 AssertEquals ("#4", 6, date.Hour);
1366                 AssertEquals ("#5", 34, date.Minute);
1367                 AssertEquals ("#6", 0, date.Second);
1368                 AssertEquals ("#7", 0, date.Millisecond);
1369         }
1370
1371         [Test]
1372         [ExpectedException (typeof (FormatException))]
1373         public void ParseExactIsExact()
1374         {
1375                 DateTime.ParseExact ("2004-05-26T03:29:01-07:00 foo", "yyyy-MM-ddTHH:mm:sszzz", null);
1376         }
1377
1378         [Test]
1379         [ExpectedException (typeof (FormatException))]
1380         public void ParseExactDoesNotEatZ ()
1381         {
1382                 DateTime.ParseExact ("2004-05-26T03:29:01", "yyyy-MM-ddTHH:mm:ssZ", null);
1383         }
1384
1385         [Test]
1386         public void ParseExactMilliseconds ()
1387         {
1388                 DateTime dt = DateTime.ParseExact ("2004-05-26T03:29:01.1234567-07:00", "yyyy-MM-ddTHH:mm:ss.fffffffzzz", null);
1389                 dt = TimeZone.CurrentTimeZone.ToUniversalTime (dt);
1390                 AssertEquals ("DateTime.ParseExact with milliseconds", 632211641411234567, dt.Ticks);
1391         }
1392
1393         [Test]
1394         public void NoColonTimeZone ()
1395         {
1396                 AssertEquals ("DateTime with colon-less timezone", true, DateTime.Parse ("2004-05-26T03:29:01-0700").Ticks != DateTime.Parse ("2004-05-26T03:29:01-0800").Ticks);
1397         }
1398
1399         [Test]
1400         public void WithColonTimeZone ()
1401         {
1402                 AssertEquals ("DateTime with colon tiemzone", true, DateTime.Parse ("2004-05-26T03:29:01-07:00").Ticks != DateTime.Parse ("2004-05-26T03:29:01-08:00").Ticks);
1403         }
1404
1405         [Test]
1406         [ExpectedException (typeof (FormatException))]
1407         public void EmptyFormatPattern ()
1408         {
1409                 DateTime.ParseExact (String.Empty, String.Empty, null);
1410         }
1411
1412         [Test]
1413         [ExpectedException (typeof (InvalidCastException))]
1414         public void IConvertible_ToType_Boolean ()
1415         {
1416                 ((IConvertible)DateTime.Now).ToType (typeof (bool), null);
1417         }
1418
1419         [Test]
1420         [ExpectedException (typeof (InvalidCastException))]
1421         public void IConvertible_ToType_Byte ()
1422         {
1423                 ((IConvertible)DateTime.Now).ToType (typeof (byte), null);
1424         }
1425
1426         [Test]
1427         [ExpectedException (typeof (InvalidCastException))]
1428         public void IConvertible_ToType_Char ()
1429         {
1430                 ((IConvertible)DateTime.Now).ToType (typeof (char), null);
1431         }
1432
1433         [Test]
1434         public void IConvertible_ToType_DateTime ()
1435         {
1436                 DateTime dt = DateTime.Now;
1437                 DateTime dt2 = (DateTime) ((IConvertible)dt).ToType (typeof (DateTime), null);
1438                 Assert ("Object", dt.Equals (dt2));
1439         }
1440
1441         [Test]
1442         [ExpectedException (typeof (InvalidCastException))]
1443         public void IConvertible_ToType_DBNull ()
1444         {
1445                 ((IConvertible)DateTime.Now).ToType (typeof (DBNull), null);
1446         }
1447
1448         [Test]
1449         [ExpectedException (typeof (InvalidCastException))]
1450         public void IConvertible_ToType_Decimal ()
1451         {
1452                 ((IConvertible)DateTime.Now).ToType (typeof (decimal), null);
1453         }
1454
1455         [Test]
1456         [ExpectedException (typeof (InvalidCastException))]
1457         public void IConvertible_ToType_Double ()
1458         {
1459                 ((IConvertible)DateTime.Now).ToType (typeof (double), null);
1460         }
1461
1462         [Test]
1463         [ExpectedException (typeof (ArgumentNullException))]
1464         public void IConvertible_ToType_Empty ()
1465         {
1466                 ((IConvertible)DateTime.Now).ToType (null, null);
1467         }
1468
1469         [Test]
1470         [ExpectedException (typeof (InvalidCastException))]
1471         public void IConvertible_ToType_Int16 ()
1472         {
1473                 ((IConvertible)DateTime.Now).ToType (typeof (short), null);
1474         }
1475
1476         [Test]
1477         [ExpectedException (typeof (InvalidCastException))]
1478         public void IConvertible_ToType_Int32 ()
1479         {
1480                 ((IConvertible)DateTime.Now).ToType (typeof (int), null);
1481         }
1482
1483         [Test]
1484         [ExpectedException (typeof (InvalidCastException))]
1485         public void IConvertible_ToType_Int64 ()
1486         {
1487                 ((IConvertible)DateTime.Now).ToType (typeof (long), null);
1488         }
1489
1490         [Test]
1491         public void IConvertible_ToType_Object ()
1492         {
1493                 DateTime dt = DateTime.Now;
1494                 object o = ((IConvertible)dt).ToType (typeof (object), null);
1495                 Assert ("Object", dt.Equals (o));
1496         }
1497
1498         [Test]
1499         [ExpectedException (typeof (InvalidCastException))]
1500         public void IConvertible_ToType_SByte ()
1501         {
1502                 ((IConvertible)DateTime.Now).ToType (typeof (sbyte), null);
1503         }
1504
1505         [Test]
1506         [ExpectedException (typeof (InvalidCastException))]
1507         public void IConvertible_ToType_Single ()
1508         {
1509                 ((IConvertible)DateTime.Now).ToType (typeof (float), null);
1510         }
1511
1512         [Test]
1513         public void IConvertible_ToType_String ()
1514         {
1515                 DateTime dt = DateTime.Now;
1516                 string s = (string) ((IConvertible)dt).ToType (typeof (string), null);
1517                 AssertEquals ("String", dt.ToString (), s);
1518         }
1519
1520         [Test]
1521         [ExpectedException (typeof (InvalidCastException))]
1522         public void IConvertible_ToType_UInt16 ()
1523         {
1524                 ((IConvertible)DateTime.Now).ToType (typeof (ushort), null);
1525         }
1526
1527         [Test]
1528         [ExpectedException (typeof (InvalidCastException))]
1529         public void IConvertible_ToType_UInt32 ()
1530         {
1531                 ((IConvertible)DateTime.Now).ToType (typeof (uint), null);
1532         }
1533
1534         [Test]
1535         [ExpectedException (typeof (InvalidCastException))]
1536         public void IConvertible_ToType_UInt64 ()
1537         {
1538                 ((IConvertible)DateTime.Now).ToType (typeof (ulong), null);
1539         }
1540
1541 #if NET_2_0
1542         [Test]
1543         public void Kind ()
1544         {
1545                 if (DateTime.Now == DateTime.UtcNow)
1546                         return; // This test does not make sense.
1547                 if (TimeZone.CurrentTimeZone.GetUtcOffset (DateTime.UtcNow)
1548                     != TimeZone.CurrentTimeZone.GetUtcOffset (DateTime.Now))
1549                         return; // In this case it does not satisfy the test premises.
1550
1551                 AssertEquals ("#0", DateTimeKind.Local, DateTime.Now.Kind);
1552                 AssertEquals ("#0a", DateTimeKind.Local, DateTime.Today.Kind);
1553
1554                 DateTime utc = DateTime.UtcNow;
1555                 DateTime now = new DateTime (utc.Ticks + TimeZone.
1556                         CurrentTimeZone.GetUtcOffset (utc).Ticks, DateTimeKind.Local);
1557                 DateTime utctouniv = utc.ToUniversalTime ();
1558                 DateTime nowtouniv = now.ToUniversalTime ();
1559                 DateTime utctoloc = utc.ToLocalTime ();
1560                 DateTime nowtoloc = now.ToLocalTime ();
1561
1562                 AssertEquals ("#1", DateTimeKind.Utc, utc.Kind);
1563                 AssertEquals ("#2", DateTimeKind.Local, now.Kind);
1564                 AssertEquals ("#3", DateTimeKind.Utc, utctouniv.Kind);
1565                 AssertEquals ("#4", DateTimeKind.Utc, nowtouniv.Kind);
1566                 AssertEquals ("#5", DateTimeKind.Local, utctoloc.Kind);
1567                 AssertEquals ("#6", DateTimeKind.Local, nowtoloc.Kind);
1568                 AssertEquals ("#7", utc, utctouniv);
1569                 AssertEquals ("#8", utc, nowtouniv);
1570                 AssertEquals ("#9", now, nowtoloc);
1571                 AssertEquals ("#10", now, utctoloc);
1572         }
1573
1574         [Test]
1575         public void InstanceMembersAndKind ()
1576         {
1577                 AssertEquals ("#1", DateTimeKind.Utc, DateTime.UtcNow.Date.Kind);
1578                 AssertEquals ("#2", DateTimeKind.Utc, DateTime.UtcNow.Add (TimeSpan.FromMinutes (1)).Kind);
1579                 AssertEquals ("#3", DateTimeKind.Utc, DateTime.UtcNow.Subtract (TimeSpan.FromMinutes (1)).Kind);
1580                 AssertEquals ("#4-1", DateTimeKind.Utc, DateTime.UtcNow.AddDays (1).Kind);
1581                 AssertEquals ("#4-2", DateTimeKind.Utc, DateTime.UtcNow.AddTicks (1).Kind);
1582                 AssertEquals ("#4-3", DateTimeKind.Utc, DateTime.UtcNow.AddHours (1).Kind);
1583                 AssertEquals ("#4-4", DateTimeKind.Utc, DateTime.UtcNow.AddMinutes (1).Kind);
1584                 AssertEquals ("#4-5", DateTimeKind.Utc, DateTime.UtcNow.AddSeconds (1).Kind);
1585                 AssertEquals ("#4-6", DateTimeKind.Utc, DateTime.UtcNow.AddMilliseconds (1).Kind);
1586                 AssertEquals ("#4-7", DateTimeKind.Utc, DateTime.UtcNow.AddMonths (1).Kind);
1587                 AssertEquals ("#4-8", DateTimeKind.Utc, DateTime.UtcNow.AddYears (1).Kind);
1588                 AssertEquals ("#5-1", DateTimeKind.Utc, (DateTime.UtcNow + TimeSpan.FromMinutes (1)).Kind);
1589                 AssertEquals ("#5-2", DateTimeKind.Utc, (DateTime.UtcNow - TimeSpan.FromMinutes (1)).Kind);
1590         }
1591
1592         [Test]
1593         public void FromBinary ()
1594         {
1595                 DateTime dt_utc = DateTime.FromBinary (0x4000000000000001);
1596                 AssertEquals ("Utc", DateTimeKind.Utc, dt_utc.Kind);
1597                 AssertEquals ("Utc/Ticks", 1, dt_utc.Ticks);
1598
1599                 DateTime dt_local = DateTime.FromBinary (unchecked ((long) 0x8000000000000001));
1600                 AssertEquals ("Local", DateTimeKind.Local, dt_local.Kind);
1601
1602                 DateTime dt_unspecified = DateTime.FromBinary (0x0000000000000001);
1603                 AssertEquals ("Unspecified", DateTimeKind.Unspecified, dt_unspecified.Kind);
1604                 AssertEquals ("Unspecified/Ticks", 1, dt_unspecified.Ticks);
1605
1606                 DateTime dt_local2 = DateTime.FromBinary (unchecked ((long) 0xC000000000000001));
1607                 AssertEquals ("Local2", DateTimeKind.Local, dt_local2.Kind);
1608                 AssertEquals ("Local/Ticks", dt_local.Ticks, dt_local2.Ticks);
1609         }
1610
1611         [Test]
1612         public void ToBinary ()
1613         {
1614                 DateTime dt_local = new DateTime (1, DateTimeKind.Local);
1615                 AssertEquals ("Local.ToBinary", 1, (ulong) dt_local.ToBinary () >> 63);
1616                 AssertEquals ("Local.Ticks", 1, dt_local.Ticks);
1617
1618                 DateTime dt_utc = new DateTime (1, DateTimeKind.Utc);
1619                 AssertEquals ("Utc.ToBinary", 0x4000000000000001, dt_utc.ToBinary ());
1620                 AssertEquals ("Utc.Ticks", 1, dt_utc.Ticks);
1621
1622                 DateTime dt_unspecified = new DateTime (1, DateTimeKind.Unspecified);
1623                 AssertEquals ("Unspecified.ToBinary", 1, dt_unspecified.ToBinary ());
1624                 AssertEquals ("Unspecified.Ticks", 1, dt_unspecified.Ticks);
1625         }
1626
1627         [Test]
1628         public void TestMin ()
1629         {
1630                 // This should never throw.
1631                 DateTime.MinValue.ToLocalTime ();
1632         }
1633
1634         [Test]
1635         public void OmittedSecondsFraction ()
1636         {
1637                 DateTime today = DateTime.Today;
1638                 AssertEquals ("#1", "00:00:00.13579", today.AddTicks (1357900).ToString ("HH:mm:ss.FFFFFFF"));
1639                 DateTime dt = DateTime.ParseExact ("00:00:00.13579", "HH:mm:ss.FFFFFFF", CultureInfo.InvariantCulture);
1640                 AssertEquals ("#2", today, dt.AddTicks (-1357900));
1641                 // it's more than strange ...
1642                 AssertEquals ("#3", String.Empty, today.ToString (".FFFFFFF"));
1643                 AssertEquals ("#4", "$", today.ToString ("$FFFFFFF"));
1644         }
1645 #endif
1646 }
1647
1648 }