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