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 System;
  12 using System.IO;
  13 using System.Threading;
  14 using System.Globalization;
  15
  16 using NUnit.Framework;
  17
  18 namespace MonoTests.System
  19 {
  20         [TestFixture]
  21         public class DateTimeTest
  22         {
  23                 [Flags]
  24                 internal enum Resolution : ushort
  25                 {
  26                         Year = 64,
  27                         Month = 96,
  28                         Day = 112,
  29                         Hour = 120,
  30                         Minute = 124,
  31                         Second = 126,
  32                         Millisecond = 127,
  33                         _Month = 32,
  34                         _Day = 16,
  35                         _Hour = 8,
  36                         _Minute = 4,
  37                         _Second = 2,
  38                         _Millisecond = 1
  39                 }
  40
  41                 internal void DTAssertEquals (DateTime actual, DateTime expected, Resolution resolution)
  42                 {
  43                         DTAssertEquals ("", actual, expected, resolution);
  44                 }
  45
  46                 internal void DTAssertEquals (string message, DateTime expected, DateTime actual, Resolution resolution)
  47                 {
  48                         if ((resolution & Resolution.Year) != 0)
  49                                 Assert.AreEqual (expected.Year, actual.Year, message);
  50                         if ((resolution & Resolution._Month) != 0)
  51                                 Assert.AreEqual (expected.Month, actual.Month, message);
  52                         if ((resolution & Resolution._Day) != 0)
  53                                 Assert.AreEqual (expected.Day, actual.Day, message);
  54                         if ((resolution & Resolution._Hour) != 0)
  55                                 Assert.AreEqual (expected.Hour, actual.Hour, message);
  56                         if ((resolution & Resolution._Minute) != 0)
  57                                 Assert.AreEqual (expected.Minute, actual.Minute, message);
  58                         if ((resolution & Resolution._Second) != 0)
  59                                 Assert.AreEqual (expected.Second, actual.Second, message);
  60                         if ((resolution & Resolution._Millisecond) != 0)
  61                                 Assert.AreEqual (expected.Millisecond, actual.Millisecond, message);
  62                 }
  63
  64                 private CultureInfo oldcult;
  65
  66                 long[] myTicks = {
  67                         631501920000000000L,    // 25 Feb 2002 - 00:00:00
  68                         631502475130080000L,    // 25 Feb 2002 - 15:25:13,8
  69                         631502115130080000L,    // 25 Feb 2002 - 05:25:13,8
  70                         631502115000000000L,    // 25 Feb 2002 - 05:25:00
  71                         631502115130000000L,    // 25 Feb 2002 - 05:25:13
  72                         631502079130000000L,    // 25 Feb 2002 - 04:25:13
  73                         629197085770000000L,    // 06 Nov 1994 - 08:49:37
  74                         631796544000000000L,    // 01 Feb 2003 - 00:00:00
  75                 };
  76
  77                 [SetUp]
  78                 public void SetUp()
  79                 {
  80                         // the current culture determines the result of formatting
  81                         oldcult = Thread.CurrentThread.CurrentCulture;
  82                         Thread.CurrentThread.CurrentCulture = new CultureInfo ("");
  83                 }
  84
  85                 [TearDown]
  86                 public void TearDown ()
  87                 {
  88                         Thread.CurrentThread.CurrentCulture = oldcult;
  89                 }
  90
  91                 [Test]
  92                 public void TestCtors ()
  93                 {
  94                         DateTime t1 = new DateTime (2002,2,25);
  95                         Assert.AreEqual (myTicks [0], t1.Ticks, "A01");
  96                         DateTime t2 = new DateTime (2002,2,25,15,25,13,8);
  97                         Assert.AreEqual (myTicks [1], t2.Ticks, "A02");
  98                         Assert.AreEqual (myTicks [0], t2.Date.Ticks, "A03");
  99                         Assert.AreEqual (2002, t2.Year, "A04");
 100                         Assert.AreEqual (2, t2.Month, "A05");
 101                         Assert.AreEqual (25, t2.Day, "A06");
 102                         Assert.AreEqual (15, t2.Hour, "A07");
 103                         Assert.AreEqual (25, t2.Minute, "A08");
 104                         Assert.AreEqual (13, t2.Second, "A09");
 105                         Assert.AreEqual (8, t2.Millisecond, "A10");
 106                         DateTime t3 = new DateTime (2002,2,25,5,25,13,8);
 107                         Assert.AreEqual (myTicks [2], t3.Ticks, "A11");
 108                 }
 109
 110                 [Test]
 111                 public void Constructor_Max ()
 112                 {
 113                         Assert.AreEqual (3155378975999990000, new DateTime (9999, 12, 31, 23, 59, 59, 999).Ticks, "Max");
 114                 }
 115
 116                 [Test]
 117                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
 118                 public void Constructor_Milliseconds_Negative ()
 119                 {
 120                         new DateTime (9999, 12, 31, 23, 59, 59, -1);
 121                 }
 122
 123                 [Test]
 124                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
 125                 public void Constructor_Milliseconds_1000 ()
 126                 {
 127                         new DateTime (9999, 12, 31, 23, 59, 59, 1000);
 128                 }
 129
 130                 [Test]
 131                 public void Fields ()
 132                 {
 133                         Assert.AreEqual (3155378975999999999L, DateTime.MaxValue.Ticks, "#1");
 134                         Assert.AreEqual (0, DateTime.MinValue.Ticks, "#2");
 135                 }
 136
 137                 [Test]
 138                 public void Add ()
 139                 {
 140                         DateTime t1 = new DateTime (myTicks [1]);
 141                         TimeSpan span = new TimeSpan (3, 54, 1);
 142                         DateTime t2 = t1.Add (span);
 143
 144                         Assert.AreEqual (25, t2.Day, "#1");
 145                         Assert.AreEqual (19, t2.Hour, "#2");
 146                         Assert.AreEqual (19, t2.Minute, "#3");
 147                         Assert.AreEqual (14, t2.Second, "#4");
 148
 149                         Assert.AreEqual (25, t1.Day, "#5");
 150                         Assert.AreEqual (15, t1.Hour, "#6");
 151                         Assert.AreEqual (25, t1.Minute, "#7");
 152                         Assert.AreEqual (13, t1.Second, "#8");
 153                 }
 154
 155                 [Test]
 156                 [ExpectedException(typeof (ArgumentOutOfRangeException))]
 157                 public void AddOutOfRangeException1 ()
 158                 {
 159                         DateTime t1 = new DateTime (myTicks [1]);
 160                         t1.Add (TimeSpan.MaxValue);
 161                 }
 162
 163                 [Test]
 164                 [ExpectedException(typeof (ArgumentOutOfRangeException))]
 165                 public void AddOutOfRangeException2 ()
 166                 {
 167                         DateTime t1 = new DateTime (myTicks [1]);
 168                         t1.Add (TimeSpan.MinValue);
 169                 }
 170
 171                 [Test]
 172                 public void AddDays ()
 173                 {
 174                         DateTime t1 = new DateTime (myTicks [1]);
 175                         t1 = t1.AddDays (3);
 176                         Assert.AreEqual (28, t1.Day, "#A1");
 177                         Assert.AreEqual (15, t1.Hour, "#A2");
 178                         Assert.AreEqual (25, t1.Minute, "#A3");
 179                         Assert.AreEqual (13, t1.Second, "#A4");
 180
 181                         t1 = t1.AddDays (1.9);
 182                         Assert.AreEqual (2, t1.Day, "#B1");
 183                         Assert.AreEqual (13, t1.Hour, "#B2");
 184                         Assert.AreEqual (1, t1.Minute, "#B3");
 185                         Assert.AreEqual (13, t1.Second, "#B4");
 186
 187                         t1 = t1.AddDays (0.2);
 188                         Assert.AreEqual (2, t1.Day, "#C1");
 189                         Assert.AreEqual (17, t1.Hour, "#C2");
 190                         Assert.AreEqual (49, t1.Minute, "#C3");
 191                         Assert.AreEqual (13, t1.Second, "#C4");
 192                 }
 193
 194                 [Test]
 195                 [ExpectedException(typeof (ArgumentOutOfRangeException))]
 196                 public void AddDaysOutOfRangeException1 ()
 197                 {
 198                         DateTime t1 = new DateTime (myTicks [1]);
 199                         t1.AddDays (10000000);
 200                 }
 201
 202                 [Test]
 203                 [ExpectedException(typeof (ArgumentOutOfRangeException))]
 204                 public void AddDaysOutOfRangeException2 ()
 205                 {
 206                         DateTime t1 = new DateTime (myTicks [1]);
 207                         t1.AddDays (-10000000);
 208                 }
 209
 210                 [Test]
 211                 public void AddHours ()
 212                 {
 213                         DateTime t1 = new DateTime (myTicks [1]);
 214                         t1 = t1.AddHours (10);
 215                         Assert.AreEqual (26, t1.Day, "#A1");
 216                         Assert.AreEqual (1, t1.Hour, "#A2");
 217                         Assert.AreEqual (25, t1.Minute, "#A3");
 218                         Assert.AreEqual (13, t1.Second, "#A4");
 219
 220                         t1 = t1.AddHours (-3.7);
 221                         Assert.AreEqual (25, t1.Day, "#B1");
 222                         Assert.AreEqual (21, t1.Hour, "#B2");
 223                         Assert.AreEqual (43, t1.Minute, "#B3");
 224                         Assert.AreEqual (13, t1.Second, "#B4");
 225
 226                         t1 = t1.AddHours (3.732);
 227                         Assert.AreEqual (26, t1.Day, "#C1");
 228                         Assert.AreEqual (1, t1.Hour, "#C2");
 229                         Assert.AreEqual (27, t1.Minute, "#C3");
 230                         Assert.AreEqual (8, t1.Second, "#C4");
 231                 }
 232
 233                 [Test]
 234                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
 235                 public void AddHoursOutOfRangeException1 ()
 236                 {
 237                         DateTime t1 = new DateTime (myTicks [1]);
 238                         t1.AddHours (9E100);
 239                 }
 240
 241                 [Test]
 242                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
 243                 public void AddHoursOutOfRangeException2 ()
 244                 {
 245                         DateTime t1 = new DateTime (myTicks [1]);
 246                         t1.AddHours (-9E100);
 247                 }
 248
 249                 [Test]
 250                 public void AddMilliseconds ()
 251                 {
 252                         DateTime t1 = new DateTime (myTicks [1]);
 253                         t1 = t1.AddMilliseconds (1E10);
 254                         Assert.AreEqual (21, t1.Day, "#A1");
 255                         Assert.AreEqual (9, t1.Hour, "#A2");
 256                         Assert.AreEqual (11, t1.Minute, "#A3");
 257                         Assert.AreEqual (53, t1.Second, "#A4");
 258
 259                         t1 = t1.AddMilliseconds (-19E10);
 260                         Assert.AreEqual (13, t1.Day, "#B1");
 261                         Assert.AreEqual (7, t1.Hour, "#B2");
 262                         Assert.AreEqual (25, t1.Minute, "#B3");
 263                         Assert.AreEqual (13, t1.Second, "#B4");
 264
 265                         t1 = t1.AddMilliseconds (15.623);
 266                         Assert.AreEqual (13, t1.Day, "#C1");
 267                         Assert.AreEqual (7, t1.Hour, "#C2");
 268                         Assert.AreEqual (25, t1.Minute, "#C3");
 269                         Assert.AreEqual (13, t1.Second, "#C4");
 270                 }
 271
 272                 [Test]
 273                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
 274                 public void AddMillisecondsOutOfRangeException1 ()
 275                 {
 276                         DateTime t1 = new DateTime (myTicks [1]);
 277                         t1.AddMilliseconds (9E100);
 278                 }
 279
 280                 [Test]
 281                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
 282                 public void AddMillisecondsOutOfRangeException2 ()
 283                 {
 284                         DateTime t1 = new DateTime (myTicks [1]);
 285                         t1.AddMilliseconds (-9E100);
 286                 }
 287
 288                 [Test]
 289                 public void TestToString ()
 290                 {
 291                         DateTime t1 = new DateTime (myTicks[2]);
 292                         DateTime t2 = new DateTime (myTicks[1]);
 293                         DateTime t3 = new DateTime (999, 1, 2, 3, 4, 5);
 294                         // Standard patterns
 295                         Assert.AreEqual ("02/25/2002", t1.ToString ("d"), "#A1");
 296                         Assert.AreEqual ("Monday, 25 February 2002", t1.ToString ("D"), "#A2");
 297                         Assert.AreEqual ("Monday, 25 February 2002 05:25", t1.ToString ("f"), "#A3");
 298                         Assert.AreEqual ("Monday, 25 February 2002 05:25:13", t1.ToString ("F"), "#A4");
 299                         Assert.AreEqual ("02/25/2002 05:25", t1.ToString ("g"), "#A5");
 300                         Assert.AreEqual ("02/25/2002 05:25:13", t1.ToString ("G"), "#A6");
 301                         Assert.AreEqual ("February 25", t1.ToString ("m"), "#A7");
 302                         Assert.AreEqual ("February 25", t1.ToString ("M"), "#A8");
 303                         Assert.AreEqual ("Mon, 25 Feb 2002 05:25:13 GMT", t1.ToString ("r"), "#A9");
 304                         Assert.AreEqual ("Mon, 25 Feb 2002 05:25:13 GMT", t1.ToString ("R"), "#A10");
 305                         Assert.AreEqual ("2002-02-25T05:25:13", t1.ToString ("s"), "#A11");
 306                         Assert.AreEqual ("05:25", t1.ToString ("t"), "#A12");
 307                         Assert.AreEqual ("05:25:13", t1.ToString ("T"), "#A13");
 308                         Assert.AreEqual ("2002-02-25 05:25:13Z", t1.ToString ("u"), "#A14");
 309                         // FIXME: this test is timezone dependent
 310                         // Assert.AreEqual ("Sunday, 24 February 2002 11:25:13", t1.ToString ("U"), "#A15");
 311                         Assert.AreEqual ("2002 February", t1.ToString ("y"), "#A16");
 312                         Assert.AreEqual ("2002 February", t1.ToString ("Y"), "#A17");
 313                         Assert.AreEqual ("02/25/2002 05:25:13", t1.ToString (""), "#A18");
 314
 315                         // Custom patterns
 316                         Assert.AreEqual ("25", t1.ToString ("%d"), "#B1");
 317                         Assert.AreEqual ("25", t1.ToString ("dd"), "#B2");
 318                         Assert.AreEqual ("Mon", t1.ToString ("ddd"), "#B3");
 319                         Assert.AreEqual ("Monday", t1.ToString ("dddd"), "#B4");
 320                         Assert.AreEqual ("2", t1.ToString ("%M"), "#B5");
 321                         Assert.AreEqual ("02", t1.ToString ("MM"), "#B6");
 322                         Assert.AreEqual ("Feb", t1.ToString ("MMM"), "#B7");
 323                         Assert.AreEqual ("February", t1.ToString ("MMMM"), "#B8");
 324                         Assert.AreEqual ("2", t1.ToString ("%y"), "#B9");
 325                         Assert.AreEqual ("02", t1.ToString ("yy"), "#B10");
 326                         Assert.AreEqual ("2002", t1.ToString ("yyyy"), "#B11");
 327                         Assert.AreEqual ("5", t1.ToString ("%h"), "#B12");
 328                         Assert.AreEqual ("05", t1.ToString ("hh"), "#B13");
 329                         Assert.AreEqual ("3", t2.ToString ("%h"), "#B14");
 330                         Assert.AreEqual ("03", t2.ToString ("hh"), "#B15");
 331                         Assert.AreEqual ("15", t2.ToString ("%H"), "#B16");
 332                         Assert.AreEqual ("15", t2.ToString ("HH"), "#B17");
 333                         Assert.AreEqual ("25", t2.ToString ("%m"), "#B18");
 334                         Assert.AreEqual ("25", t2.ToString ("mm"), "#B19");
 335                         Assert.AreEqual ("13", t2.ToString ("%s"), "#B20");
 336                         Assert.AreEqual ("13", t2.ToString ("ss"), "#B21");
 337                         Assert.AreEqual ("A", t1.ToString ("%t"), "#B22");
 338                         Assert.AreEqual ("P", t2.ToString ("%t"), "#B23");
 339                         Assert.AreEqual ("AM", t1.ToString ("tt"), "#B24");
 340                         Assert.AreEqual ("PM", t2.ToString ("tt"), "#B25");
 341                         long offset = TimeZone.CurrentTimeZone.GetUtcOffset(t1).Ticks / 36000000000;
 342                         // Must specify '+0' for GMT
 343                         Assert.AreEqual (offset.ToString ("+#;-#;+0"), t1.ToString ("%z"), "#B26");
 344                         Assert.AreEqual (offset.ToString ("+00;-00;+00"), t1.ToString ("zz"), "#B28");
 345                         // This does not work in, eg banglore, because their timezone has an offset of
 346                         // +05:30
 347                         //Assert.AreEqual (offset.ToString("+00;-00;00") + ":00", t1.ToString ("zzz"), "#B28");
 348                         Assert.AreEqual (" : ", t1.ToString (" : "), "#B29");
 349                         Assert.AreEqual (" / ", t1.ToString (" / "), "#B30");
 350                         Assert.AreEqual (" yyy ", t1.ToString (" 'yyy' "), "#B31");
 351                         Assert.AreEqual (" d", t1.ToString (" \\d"), "#B32");
 352                         Assert.AreEqual ("2002", t1.ToString ("yyy"), "#B33");
 353                         Assert.AreEqual ("0002002", t1.ToString ("yyyyyyy"), "#B34");
 354                         Assert.AreEqual ("999", t3.ToString ("yyy"), "#B33");
 355                         Assert.AreEqual ("0999", t3.ToString ("yyyy"), "#B33");
 356                 }
 357
 358                 [Test]
 359                 public void ParseExact_Format_Empty ()
 360                 {
 361                         try {
 362                                 DateTime.ParseExact ("2002-02-25 04:25:13Z", string.Empty, null);
 363                                 Assert.Fail ("#A1");
 364                         } catch (FormatException ex) {
 365                                 // Format specifier was invalid
 366                                 Assert.AreEqual (typeof (FormatException), ex.GetType (), "#B2");
 367                                 Assert.IsNull (ex.InnerException, "#B3");
 368                                 Assert.IsNotNull (ex.Message, "#B4");
 369                         }
 370
 371                         try {
 372                                 DateTime.ParseExact ("2002-02-25 04:25:13Z", string.Empty, null,
 373                                         DateTimeStyles.None);
 374                                 Assert.Fail ("#B1");
 375                         } catch (FormatException ex) {
 376                                 // Format specifier was invalid
 377                                 Assert.AreEqual (typeof (FormatException), ex.GetType (), "#B2");
 378                                 Assert.IsNull (ex.InnerException, "#B3");
 379                                 Assert.IsNotNull (ex.Message, "#B4");
 380                         }
 381                 }
 382
 383                 [Test]
 384                 public void ParseExact_Format_Null ()
 385                 {
 386                         try {
 387                                 DateTime.ParseExact ("2002-02-25 04:25:13Z", (string) null, null);
 388                                 Assert.Fail ("#A1");
 389                         } catch (ArgumentNullException ex) {
 390                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 391                                 Assert.IsNull (ex.InnerException, "#A3");
 392                                 Assert.IsNotNull (ex.Message, "#A4");
 393                                 Assert.IsNotNull (ex.ParamName, "#A5");
 394                                 Assert.AreEqual ("format", ex.ParamName, "#A6");
 395                         }
 396
 397                         try {
 398                                 DateTime.ParseExact ("2002-02-25 04:25:13Z", (string) null, null,
 399                                         DateTimeStyles.None);
 400                                 Assert.Fail ("#B1");
 401                         } catch (ArgumentNullException ex) {
 402                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
 403                                 Assert.IsNull (ex.InnerException, "#B3");
 404                                 Assert.IsNotNull (ex.Message, "#B4");
 405                                 Assert.IsNotNull (ex.ParamName, "#B5");
 406                                 Assert.AreEqual ("format", ex.ParamName, "#B6");
 407                         }
 408                 }
 409
 410                 [Test]
 411                 public void ParseExact_Formats_Empty ()
 412                 {
 413                         try {
 414                                 DateTime.ParseExact ("2002-02-25 04:25:13Z", new string [0],
 415                                         null, DateTimeStyles.None);
 416                                 Assert.Fail ("#A1");
 417                         } catch (FormatException ex) {
 418                                 // Format specifier was invalid
 419                                 Assert.AreEqual (typeof (FormatException), ex.GetType (), "#A2");
 420                                 Assert.IsNull (ex.InnerException, "#A3");
 421                                 Assert.IsNotNull (ex.Message, "#A4");
 422                         }
 423
 424                         string [] formats = new string [] { "G", string.Empty, "d" };
 425                         try {
 426                                 DateTime.ParseExact ("2002-02-25 04:25:13Z", formats, null,
 427                                         DateTimeStyles.None);
 428                                 Assert.Fail ("#B1");
 429                         } catch (FormatException ex) {
 430                                 // Format specifier was invalid
 431                                 Assert.AreEqual (typeof (FormatException), ex.GetType (), "#B2");
 432                                 Assert.IsNull (ex.InnerException, "#B3");
 433                                 Assert.IsNotNull (ex.Message, "#B4");
 434                         }
 435                 }
 436
 437                 [Test]
 438                 public void ParseExact_Formats_Null ()
 439                 {
 440                         try {
 441                                 DateTime.ParseExact ("2002-02-25 04:25:13Z", (string []) null,
 442                                         null, DateTimeStyles.None);
 443                                 Assert.Fail ("#A1");
 444                         } catch (ArgumentNullException ex) {
 445                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 446                                 Assert.IsNull (ex.InnerException, "#A3");
 447                                 Assert.IsNotNull (ex.Message, "#A4");
 448                                 Assert.IsNotNull (ex.ParamName, "#A5");
 449                                 Assert.AreEqual ("formats", ex.ParamName, "#A6");
 450                         }
 451
 452                         string [] formats = new string [] { "G", null, "d" };
 453                         try {
 454                                 DateTime.ParseExact ("2002-02-25 04:25:13Z", formats, null,
 455                                         DateTimeStyles.None);
 456                                 Assert.Fail ("#B1");
 457                         } catch (FormatException ex) {
 458                                 // Format specifier was invalid
 459                                 Assert.AreEqual (typeof (FormatException), ex.GetType (), "#B2");
 460                                 Assert.IsNull (ex.InnerException, "#B3");
 461                                 Assert.IsNotNull (ex.Message, "#B4");
 462                         }
 463                 }
 464
 465                 [Test]
 466                 public void ParseExact_String_Empty ()
 467                 {
 468                         try {
 469                                 DateTime.ParseExact (string.Empty, "G", null);
 470                                 Assert.Fail ("#A1");
 471                         } catch (FormatException ex) {
 472                                 // Format specifier was invalid
 473                                 Assert.AreEqual (typeof (FormatException), ex.GetType (), "#A2");
 474                                 Assert.IsNull (ex.InnerException, "#A3");
 475                                 Assert.IsNotNull (ex.Message, "#A4");
 476                         }
 477
 478                         try {
 479                                 DateTime.ParseExact (string.Empty, "G", null, DateTimeStyles.None);
 480                                 Assert.Fail ("#B1");
 481                         } catch (FormatException ex) {
 482                                 // Format specifier was invalid
 483                                 Assert.AreEqual (typeof (FormatException), ex.GetType (), "#B2");
 484                                 Assert.IsNull (ex.InnerException, "#B3");
 485                                 Assert.IsNotNull (ex.Message, "#B4");
 486                         }
 487
 488                         try {
 489                                 DateTime.ParseExact (string.Empty, new string [] { "G" }, null,
 490                                         DateTimeStyles.None);
 491                                 Assert.Fail ("#C1");
 492                         } catch (FormatException ex) {
 493                                 // Format specifier was invalid
 494                                 Assert.AreEqual (typeof (FormatException), ex.GetType (), "#C2");
 495                                 Assert.IsNull (ex.InnerException, "#C3");
 496                                 Assert.IsNotNull (ex.Message, "#C4");
 497                         }
 498                 }
 499
 500                 [Test]
 501                 public void ParseExact_String_Null ()
 502                 {
 503                         try {
 504                                 DateTime.ParseExact ((string) null, "G", null);
 505                                 Assert.Fail ("#A1");
 506                         } catch (ArgumentNullException ex) {
 507                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 508                                 Assert.IsNull (ex.InnerException, "#A3");
 509                                 Assert.IsNotNull (ex.Message, "#A4");
 510                                 Assert.IsNotNull (ex.ParamName, "#A5");
 511                                 Assert.AreEqual ("s", ex.ParamName, "#A6");
 512                         }
 513
 514                         try {
 515                                 DateTime.ParseExact ((string) null, "G", null, DateTimeStyles.None);
 516                                 Assert.Fail ("#B1");
 517                         } catch (ArgumentNullException ex) {
 518                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
 519                                 Assert.IsNull (ex.InnerException, "#B3");
 520                                 Assert.IsNotNull (ex.Message, "#B4");
 521                                 Assert.IsNotNull (ex.ParamName, "#B5");
 522                                 Assert.AreEqual ("s", ex.ParamName, "#B6");
 523                         }
 524
 525                         try {
 526                                 DateTime.ParseExact ((string) null, new string [] { "G" }, null,
 527                                         DateTimeStyles.None);
 528                                 Assert.Fail ("#C1");
 529                         } catch (ArgumentNullException ex) {
 530                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#C2");
 531                                 Assert.IsNull (ex.InnerException, "#C3");
 532                                 Assert.IsNotNull (ex.Message, "#C4");
 533                                 Assert.IsNotNull (ex.ParamName, "#C5");
 534                                 Assert.AreEqual ("s", ex.ParamName, "#C6");
 535                         }
 536                 }
 537
 538                 [Test]
 539                 public void TestParseExact3 ()
 540                 {
 541                         DateTime t1 = DateTime.ParseExact ("2002-02-25 04:25:13Z", "u", null);
 542                         Assert.AreEqual (2002, t1.Year, "#1");
 543                         Assert.AreEqual (02, t1.Month, "#2");
 544                         Assert.AreEqual (25, t1.Day, "#3");
 545                         Assert.AreEqual (04, t1.Hour, "#4");
 546                         Assert.AreEqual (25, t1.Minute, "#5");
 547                         Assert.AreEqual (13, t1.Second, "#6");
 548                 }
 549
 550                 [Test]
 551                 public void TestParseExact4 ()
 552                 {
 553                         // bug #60912, modified hour as 13:00
 554                         string s = "6/28/2004 13:00:00 AM";
 555                         string f = "M/d/yyyy HH':'mm':'ss tt";
 556                         DateTime.ParseExact (s, f, CultureInfo.InvariantCulture);
 557
 558                         // bug #63137
 559                         DateTime.ParseExact ("Wed, 12 May 2004 20:51:09 +0200",
 560                                 @"ddd, d MMM yyyy H:m:s zzz",
 561                                 CultureInfo.CreateSpecificCulture("en-us"),
 562                                 DateTimeStyles.AllowInnerWhite);
 563                 }
 564
 565                 [Test]
 566                 public void TestParseExact ()
 567                 {
 568                         // Standard patterns
 569                         DateTime t1 = DateTime.ParseExact ("02/25/2002", "d", null);
 570                         Assert.AreEqual (myTicks [0], t1.Ticks, "#A1");
 571                         t1 = DateTime.ParseExact ("Monday, 25 February 2002", "D", null);
 572                         Assert.AreEqual (myTicks [0], t1.Ticks, "#A2");
 573                         t1 = DateTime.ParseExact ("Monday, 25 February 2002 05:25", "f", null);
 574                         Assert.AreEqual (myTicks [3], t1.Ticks, "#A3");
 575                         t1 = DateTime.ParseExact ("Monday, 25 February 2002 05:25:13", "F", null);
 576                         Assert.AreEqual (myTicks [4], t1.Ticks, "#A4");
 577                         t1 = DateTime.ParseExact ("02/25/2002 05:25", "g", null);
 578                         Assert.AreEqual (myTicks [3], t1.Ticks, "#A5");
 579                         t1 = DateTime.ParseExact ("02/25/2002 05:25:13", "G", null);
 580                         Assert.AreEqual (myTicks [4], t1.Ticks, "#A6");
 581                         t1 = DateTime.ParseExact ("Monday, 25 February 2002 04:25:13", "U", null);
 582                         t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1);
 583                         Assert.AreEqual (2002, t1.Year, "#A7");
 584                         Assert.AreEqual (02, t1.Month, "#A8");
 585                         Assert.AreEqual (25, t1.Day, "#A9");
 586                         Assert.AreEqual (04, t1.Hour, "#A10");
 587                         Assert.AreEqual (25, t1.Minute, "#A11");
 588                         Assert.AreEqual (13, t1.Second, "#A12");
 589                         t1 = DateTime.ParseExact ("Monday, 25 February 2002 04:25:13", "U", null);
 590                         Assert.AreEqual ("Monday, 25 February 2002 04:25:13", t1.ToString ("U"), "#A13");
 591
 592                         DateTime t2 = new DateTime (DateTime.Today.Year, 2, 25);
 593                         t1 = DateTime.ParseExact ("February 25", "m", null);
 594                         Assert.AreEqual (t2.Ticks, t1.Ticks, "#B1");
 595
 596                         t2 = new DateTime (DateTime.Today.Year, 2, 25);
 597                         t1 = DateTime.ParseExact ("February 25", "M", null);
 598                         Assert.AreEqual (t2.Ticks, t1.Ticks, "#B2");
 599
 600                         t1 = DateTime.ParseExact ("Mon, 25 Feb 2002 04:25:13 GMT", "r", null);
 601                         Assert.AreEqual (2002, t1.Year, "#C1");
 602                         Assert.AreEqual (02, t1.Month, "#C2");
 603                         Assert.AreEqual (25, t1.Day, "#C3");
 604                         Assert.AreEqual (04, t1.Hour, "#C4");
 605                         Assert.AreEqual (25, t1.Minute, "#C5");
 606                         Assert.AreEqual (13, t1.Second, "#C6");
 607
 608                         t1 = DateTime.ParseExact ("Mon, 25 Feb 2002 04:25:13 GMT", "R", null);
 609                         Assert.AreEqual (2002, t1.Year, "#D1");
 610                         Assert.AreEqual (02, t1.Month, "#D2");
 611                         Assert.AreEqual (25, t1.Day, "#D3");
 612                         Assert.AreEqual (04, t1.Hour, "#D4");
 613                         Assert.AreEqual (25, t1.Minute, "#D5");
 614                         Assert.AreEqual (13, t1.Second, "#D6");
 615
 616                         t1 = DateTime.ParseExact ("2002-02-25T05:25:13", "s", null);
 617                         Assert.AreEqual (myTicks [4], t1.Ticks, "#E1");
 618
 619                         t2 = DateTime.Today + new TimeSpan (5,25,0);
 620                         t1 = DateTime.ParseExact ("05:25", "t", null);
 621                         Assert.AreEqual (t2.Ticks, t1.Ticks, "#E2");
 622
 623                         t2 = DateTime.Today + new TimeSpan (5,25,13);
 624                         t1 = DateTime.ParseExact ("05:25:13", "T", null);
 625                         Assert.AreEqual (t2.Ticks, t1.Ticks, "#E3");
 626
 627                         t2 = new DateTime (2002, 2, 1);
 628                         t1 = DateTime.ParseExact ("2002 February", "y", null);
 629                         Assert.AreEqual (t2.Ticks, t1.Ticks, "#E4");
 630
 631                         t2 = new DateTime (2002, 2, 1);
 632                         t1 = DateTime.ParseExact ("2002 February", "Y", null);
 633                         Assert.AreEqual (t2.Ticks, t1.Ticks, "#E5");
 634
 635                         // Custom patterns
 636                         t2 = new DateTime (DateTime.Now.Year, 1, 25);
 637                         t1 = DateTime.ParseExact ("25", "%d", null);
 638                         Assert.AreEqual (t2.Ticks, t1.Ticks, "#F1");
 639                         t1 = DateTime.ParseExact ("25", "dd", null);
 640                         Assert.AreEqual (t2.Ticks, t1.Ticks, "#F2");
 641
 642                         t2 = new DateTime (DateTime.Today.Year, 2, 1);
 643                         t1 = DateTime.ParseExact ("2", "%M", null);
 644                         Assert.AreEqual (t2.Ticks, t1.Ticks, "#G1");
 645                         t1 = DateTime.ParseExact ("02", "MM", null);
 646                         Assert.AreEqual (t2.Ticks, t1.Ticks, "#G2");
 647                         t1 = DateTime.ParseExact ("Feb", "MMM", null);
 648                         Assert.AreEqual (t2.Ticks, t1.Ticks, "#G3");
 649                         t1 = DateTime.ParseExact ("February", "MMMM", null);
 650                         Assert.AreEqual (t2.Ticks, t1.Ticks, "#G4");
 651
 652                         t2 = new DateTime (2005, 1, 1);
 653                         t1 = DateTime.ParseExact ("5", "%y", null);
 654                         Assert.AreEqual (t2.Ticks, t1.Ticks, "#G5");
 655                         t1 = DateTime.ParseExact ("05", "yy", null);
 656                         Assert.AreEqual (t2.Ticks, t1.Ticks, "#G6");
 657                         t1 = DateTime.ParseExact ("2005", "yyyy", null);
 658                         Assert.AreEqual (t2.Ticks, t1.Ticks, "#G7");
 659
 660                         t2 = DateTime.Today + new TimeSpan (5, 0, 0);
 661                         t1 = DateTime.ParseExact ("5A", "ht", null);
 662                         Assert.AreEqual (t2.Ticks, t1.Ticks, "#G8");
 663                         t1 = DateTime.ParseExact ("05A", "hht", null);
 664                         Assert.AreEqual (t2.Ticks, t1.Ticks, "#G9");
 665
 666                         t2 = DateTime.Today + new TimeSpan (15, 0, 0);
 667                         t1 = DateTime.ParseExact ("3P", "ht", null);
 668                         Assert.AreEqual (t2.Ticks, t1.Ticks, "#G10");
 669                         t1 = DateTime.ParseExact ("03P", "hht", null);
 670                         Assert.AreEqual (t2.Ticks, t1.Ticks, "#G11");
 671
 672                         t2 = DateTime.Today + new TimeSpan (5, 0, 0);
 673                         t1 = DateTime.ParseExact ("5", "%H", null);
 674                         Assert.AreEqual (t2.Ticks, t1.Ticks, "#G12");
 675
 676                         t2 = DateTime.Today + new TimeSpan (15, 0, 0);
 677                         t1 = DateTime.ParseExact ("15", "%H", null);
 678                         Assert.AreEqual (t2.Ticks, t1.Ticks, "#G13");
 679                         t1 = DateTime.ParseExact ("15", "HH", null);
 680                         Assert.AreEqual (t2.Ticks, t1.Ticks, "#G14");
 681
 682                         // Time zones
 683 #if false
 684                         // Fails durring DST for msft and mono
 685                         t2 = DateTime.Today + new TimeSpan (17, 18, 0);
 686                         t1 = DateTime.ParseExact ("11:18AM -5", "h:mmtt z", null);
 687                         t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1);
 688                         if (!TimeZone.CurrentTimeZone.IsDaylightSavingTime(t1))
 689                                 t1 += new TimeSpan(1, 0, 0);
 690                         Assert.AreEqual (t2.Ticks, t1.Ticks, "#H1");
 691
 692                         t1 = DateTime.ParseExact ("11:18AM -05:00", "h:mmtt zzz", null);
 693                         t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1);
 694                         if (!TimeZone.CurrentTimeZone.IsDaylightSavingTime(t1))
 695                                 t1 += new TimeSpan(1, 0, 0);
 696                         Assert.AreEqual (t2.Ticks, t1.Ticks, "#H2");
 697
 698                         t1 = DateTime.ParseExact ("7:18PM +03", "h:mmtt zz", null);
 699                         t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1);
 700                         if (!TimeZone.CurrentTimeZone.IsDaylightSavingTime(t1))
 701                                 t1 += new TimeSpan(1, 0, 0);
 702                         Assert.AreEqual (t2.Ticks, t1.Ticks, "#H3");
 703
 704                         t1 = DateTime.ParseExact ("7:48PM +03:30", "h:mmtt zzz", null);
 705                         t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1);
 706                         if (!TimeZone.CurrentTimeZone.IsDaylightSavingTime(t1))
 707                                 t1 += new TimeSpan(1, 0, 0);
 708                         Assert.AreEqual (t2.Ticks, t1.Ticks, "#H4");
 709 #endif
 710
 711                         // Options
 712                         t2 = DateTime.Today + new TimeSpan (16, 18, 0);
 713                         t1 = DateTime.ParseExact ("11:18AM -5", "h:mmtt z",
 714                                                   null, DateTimeStyles.AdjustToUniversal);
 715                         Assert.AreEqual (t2.Ticks, t1.Ticks, "#I1");
 716
 717                         t1 = DateTime.ParseExact ("Monday, 25 February 2002 05:25:13", "F",
 718                                                   null, DateTimeStyles.AdjustToUniversal);
 719                         Assert.AreEqual (myTicks [4], t1.Ticks, "#I2");
 720                         t1 = DateTime.ParseExact ("Monday, 25 February 2002 05:25:13",
 721                                                   "dddd, dd MMMM yyyy HH:mm:ss",
 722                                                   null, DateTimeStyles.AdjustToUniversal);
 723                         Assert.AreEqual (myTicks [4], t1.Ticks, "#I3");
 724
 725                         t1 = DateTime.ParseExact ("02/25/2002", "d", null,
 726                                                   DateTimeStyles.AllowWhiteSpaces);
 727                         Assert.AreEqual (myTicks [0], t1.Ticks, "#I4");
 728
 729                         t1 = DateTime.ParseExact ("    02/25/2002", "d", null,
 730                                                   DateTimeStyles.AllowLeadingWhite);
 731                         Assert.AreEqual (myTicks [0], t1.Ticks, "#I5");
 732
 733                         t1 = DateTime.ParseExact ("02/25/2002    ", "d", null,
 734                                                   DateTimeStyles.AllowTrailingWhite);
 735                         Assert.AreEqual (myTicks [0], t1.Ticks, "#I6");
 736
 737                         t1 = DateTime.ParseExact ("  02 / 25 / 2002    ", "d", null,
 738                                                   DateTimeStyles.AllowWhiteSpaces);
 739                         Assert.AreEqual (myTicks [0], t1.Ticks, "#I7");
 740
 741                         // Multi Custom Patterns
 742                         string rfc1123_date = "r";
 743                         string rfc850_date = "dddd, dd'-'MMM'-'yy HH':'mm':'ss 'GMT'";
 744                         string asctime_date = "ddd MMM d HH':'mm':'ss yyyy";
 745                         string [] formats = new string [] {rfc1123_date, rfc850_date, asctime_date};
 746                         CultureInfo enUS = new CultureInfo("en-US", false);
 747                         t1 = DateTime.ParseExact ("Sun, 06 Nov 1994 08:49:37 GMT", formats[0], enUS,
 748                                                 DateTimeStyles.AllowWhiteSpaces);
 749                         Assert.AreEqual (myTicks [6], t1.Ticks, "#J1");
 750                         t1 = DateTime.ParseExact ("Sunday, 06-Nov-94 08:49:37 GMT", formats[1], enUS,
 751                                                 DateTimeStyles.AllowWhiteSpaces);
 752                         Assert.AreEqual (myTicks [6], t1.Ticks, "#J2");
 753                         t1 = DateTime.ParseExact ("Sun Nov  6 08:49:37 1994", formats[2], enUS,
 754                                                 DateTimeStyles.AllowWhiteSpaces);
 755                         Assert.AreEqual (myTicks [6], t1.Ticks, "#J3");
 756                         t1 = DateTime.ParseExact ("Sun, 06 Nov 1994 08:49:37 GMT", formats, enUS,
 757                                                 DateTimeStyles.AllowWhiteSpaces);
 758                         Assert.AreEqual (myTicks [6], t1.Ticks, "#J4");
 759                         t1 = DateTime.ParseExact ("Sunday, 06-Nov-94 08:49:37 GMT", formats, enUS,
 760                                                 DateTimeStyles.AllowWhiteSpaces);
 761                         Assert.AreEqual (myTicks [6], t1.Ticks, "#J5");
 762                         t1 = DateTime.ParseExact ("Sun Nov  6 08:49:37 1994", formats, enUS,
 763                                                 DateTimeStyles.AllowWhiteSpaces);
 764                         Assert.AreEqual (myTicks [6], t1.Ticks, "#J6");
 765                         t1 = DateTime.ParseExact ("Monday, 25 February 2002 05:25:13",
 766                                                 "ddddddd, dd MMMMMMM yyyy HHHHH:mmmmm:sssss",
 767                                                 null, DateTimeStyles.AdjustToUniversal);
 768                         Assert.AreEqual (myTicks[4], t1.Ticks, "#J7");
 769
 770                         // Bug 52274
 771                         t1 = DateTime.ParseExact ("--12--", "--MM--" , null);
 772                         Assert.AreEqual (12, t1.Month, "#K1");
 773                         t1=DateTime.ParseExact ("--12-24", "--MM-dd" , null);
 774                         Assert.AreEqual (24, t1.Day, "#K2");
 775                         Assert.AreEqual (12, t1.Month, "#K3");
 776                         t1=DateTime.ParseExact ("---24", "---dd" , null);
 777                         Assert.AreEqual (24, t1.Day, "#K4");
 778
 779                         // Bug 63376
 780                         t1 = DateTime.ParseExact ("18Aug2004 12:33:00", "ddMMMyyyy hh:mm:ss", new CultureInfo ("en-US"));
 781                         Assert.AreEqual (0, t1.Hour, "hh allows 12, though it's useless");
 782
 783                         // Bug 74775
 784                         DateTime.ParseExact ("Tue, 12 Apr 2005 10:10:04 +0100",
 785                                 "Tue, 12 Apr 2005 10:10:04 +0100", enUS);
 786                         try {
 787                                 DateTime.ParseExact ("Tue, 12 Apr 2005 10:10:04 +00000",
 788                                         "ddd, dd MMM yyyy HH':'mm':'ss zzz", enUS);
 789                                 Assert.Fail ("#L1");
 790                         } catch (FormatException) {
 791                         }
 792
 793                         // Bug #75213 : literal escaping.
 794                         t1 = DateTime.ParseExact ("20050707132527Z",
 795                                 "yyyyMMddHHmmss\\Z", CultureInfo.InvariantCulture);
 796                         Assert.AreEqual (632563395270000000, t1.Ticks, "#L2");
 797                 }
 798
 799                 [Test]
 800                 [Ignore ("need to fix tests that run on different timezones")]
 801                 public void TestParse2 ()
 802                 {
 803                         DateTime t1 = DateTime.Parse ("Mon, 25 Feb 2002 04:25:13 GMT");
 804                         t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1);
 805                         Assert.AreEqual (04 - TimeZone.CurrentTimeZone.GetUtcOffset (t1).Hours, t1.Hour);
 806                 }
 807
 808                 [Test]
 809                 public void TestParseDateFirst ()
 810                 {
 811                         // Standard patterns
 812                         CultureInfo USCultureInfo = new CultureInfo("en-US");
 813                         DateTime t1 = DateTime.Parse ("02/25/2002", USCultureInfo);
 814                         Assert.AreEqual (myTicks [0], t1.Ticks, "#A1");
 815                         t1 = DateTime.Parse ("2002-02-25", USCultureInfo);
 816                         Assert.AreEqual (myTicks [0], t1.Ticks, "#A2");
 817                         t1 = DateTime.Parse ("Monday, 25 February 2002");
 818                         Assert.AreEqual (myTicks [0], t1.Ticks, "#A3");
 819                         t1 = DateTime.Parse ("Monday, 25 February 2002 05:25");
 820                         Assert.AreEqual (myTicks [3], t1.Ticks, "#A4");
 821                         t1 = DateTime.Parse ("Monday, 25 February 2002 05:25:13");
 822                         Assert.AreEqual (myTicks [4], t1.Ticks, "#A5");
 823                         t1 = DateTime.Parse ("02/25/2002 05:25", USCultureInfo);
 824                         Assert.AreEqual (myTicks [3], t1.Ticks, "#A6");
 825                         t1 = DateTime.Parse ("02/25/2002 05:25:13", USCultureInfo);
 826                         Assert.AreEqual (myTicks [4], t1.Ticks, "#A7");
 827                         t1 = DateTime.Parse ("2002-02-25 04:25:13Z");
 828                         t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1);
 829                         Assert.AreEqual (2002, t1.Year, "#A8");
 830                         Assert.AreEqual (02, t1.Month, "#A9");
 831                         Assert.AreEqual (25, t1.Day, "#A10");
 832                         Assert.AreEqual (04, t1.Hour, "#A11");
 833                         Assert.AreEqual (25, t1.Minute, "#A12");
 834                         Assert.AreEqual (13, t1.Second, "#A13");
 835                         t1 = DateTime.Parse ("Mon,02/25/2002", USCultureInfo);
 836                         Assert.AreEqual (myTicks [0], t1.Ticks, "#A14");
 837                         DateTime t2 = new DateTime (1999, 1, 2, 0, 3, 4);
 838                         t1 = DateTime.Parse (t2.ToLongTimeString ());
 839                         Assert.AreEqual (0, t1.Hour, "#A14");
 840
 841                         // parsed as UTC string
 842                         t1 = DateTime.Parse ("Mon, 25 Feb 2002 04:25:13 GMT");
 843                         t1 = TimeZone.CurrentTimeZone.ToUniversalTime (t1);
 844                         Assert.AreEqual (2002, t1.Year, "#C1");
 845                         Assert.AreEqual (02, t1.Month, "#C2");
 846                         Assert.AreEqual (25, t1.Day, "#C3");
 847                         Assert.AreEqual (4, t1.Hour, "#C4");
 848                         Assert.AreEqual (25, t1.Minute, "#C5");
 849                         Assert.AreEqual (13, t1.Second, "#C6");
 850
 851                         // Some date 'T' time formats
 852 #if NET_2_0 // Net_1_1 requires hh:mm:ss
 853                         t1 = DateTime.Parse ("2002-02-25T05:25");
 854                         Assert.AreEqual (myTicks [3], t1.Ticks, "#D1");
 855 #endif
 856                         t1 = DateTime.Parse ("2002-02-25T05:25:13");
 857                         Assert.AreEqual (myTicks [4], t1.Ticks, "#D1");
 858                         t1 = DateTime.Parse ("2002-02-25T05:25:13.008");
 859                         Assert.AreEqual (myTicks [2], t1.Ticks, "#D1");
 860                         t1 = DateTime.Parse ("02-2002-25T05:25:13");
 861                         Assert.AreEqual (myTicks [4], t1.Ticks, "#D1");
 862
 863                         // Day month
 864                         t2 = new DateTime (DateTime.Today.Year, 2, 25);
 865                         t1 = DateTime.Parse ("February 25", USCultureInfo);
 866                         Assert.AreEqual (t2.Ticks, t1.Ticks, "#B1");
 867
 868                         t2 = new DateTime (DateTime.Today.Year, 2, 8);
 869                         t1 = DateTime.Parse ("February 08", USCultureInfo);
 870                         Assert.AreEqual (t2.Ticks, t1.Ticks, "#B2");
 871
 872                         t2 = new DateTime (DateTime.Today.Year, 2, 8);
 873                         t1 = DateTime.Parse ("February 8", USCultureInfo);
 874                         Assert.AreEqual (t2.Ticks, t1.Ticks, "#D6");
 875
 876                         // Month year
 877                         t2 = new DateTime (2002, 2, 1);
 878                         t1 = DateTime.Parse ("2002 February");
 879                         Assert.AreEqual (t2.Ticks, t1.Ticks, "#D4");
 880
 881                         t2 = new DateTime (2002, 2, 1);
 882                         t1 = DateTime.Parse ("2002 February", new CultureInfo ("ja-JP"));
 883                         Assert.AreEqual (t2.Ticks, t1.Ticks, "#D5");
 884
 885                         // bug #72132
 886                         t2 = new DateTime (2002, 2, 25, 5, 25, 22);
 887                         t1 = DateTime.Parse ("Monday, 25 February 2002 05:25:22",
 888                                 new CultureInfo ("hi-IN"));
 889                         Assert.AreEqual (t2.Ticks, t1.Ticks, "#D7");
 890                         t2 = new DateTime (2002, 2, 25, 5, 25, 0);
 891                         t1 = DateTime.Parse ("Monday, 25 February 2002 05:25",
 892                                 new CultureInfo ("hi-IN"));
 893                         Assert.AreEqual (t2.Ticks, t1.Ticks, "#D8");
 894
 895                         // MM-yyyy-dd + different time formats
 896                         t1 = DateTime.Parse ("02-2002-25 05:25", USCultureInfo);
 897                         Assert.AreEqual (myTicks[3], t1.Ticks, "#E1");
 898                         t1 = DateTime.Parse ("02-2002-25 05:25:13", USCultureInfo);
 899                         Assert.AreEqual (myTicks[4], t1.Ticks, "#E1");
 900                         t1 = DateTime.Parse ("02-2002-25 05:25:13 Mon", USCultureInfo);
 901                         Assert.AreEqual (myTicks[4], t1.Ticks, "#E2");
 902                         t1 = DateTime.Parse ("02-2002-25 05:25:13 Monday", USCultureInfo);
 903                         Assert.AreEqual (myTicks[4], t1.Ticks, "#E3");
 904                         t1 = DateTime.Parse ("02-2002-25 05:25:13.008", USCultureInfo);
 905                         Assert.AreEqual (myTicks[2], t1.Ticks, "#E4");
 906
 907                         // Formats with timezone
 908                         long offset = TimeZone.CurrentTimeZone.GetUtcOffset(t1).Ticks;
 909                         long hourTicks = 36000000000L;
 910                         long halfHourTicks = hourTicks / 2;
 911                         t1 = DateTime.Parse ("02-2002-25 05:25+01", USCultureInfo);
 912                         Assert.AreEqual (myTicks[3], t1.Ticks + hourTicks - offset, "#F1");
 913                         t1 = DateTime.Parse ("02-2002-25 05:25-01", USCultureInfo);
 914                         Assert.AreEqual (myTicks[3], t1.Ticks - hourTicks - offset, "#F2");
 915                         t1 = DateTime.Parse ("02-2002-25 05:25+00:30", USCultureInfo);
 916                         Assert.AreEqual (myTicks[3], t1.Ticks + hourTicks/2 - offset, "#F3");
 917                         t1 = DateTime.Parse ("02-2002-25 05:25:13+02", USCultureInfo);
 918                         Assert.AreEqual (myTicks[4], t1.Ticks + 2*hourTicks - offset, "#F4");
 919 #if NET_2_0
 920                         // NET 1.0 doesn't accept second fractions and time zone.
 921                         t1 = DateTime.Parse ("2002-02-25 05:25:13.008-02");
 922                         Assert.AreEqual (myTicks[2], t1.Ticks - 2*hourTicks - offset, "#F5");
 923                         // NET 1.0 doesn't parse well time zone with AM afterwards.
 924                         t1 = DateTime.Parse ("02-25-2002 05:25:13-02 AM", USCultureInfo);
 925                         Assert.AreEqual (myTicks[4], t1.Ticks - 2*hourTicks - offset, "#F6");
 926                         t1 = DateTime.Parse ("25 Feb 2002 05:25:13-02 AM", USCultureInfo);
 927                         Assert.AreEqual (myTicks[4], t1.Ticks - 2*hourTicks - offset, "#F6");
 928 #endif
 929                 }
 930
 931                 [Test]
 932                 public void TestParseTimeFirst ()
 933                 {
 934                         CultureInfo USCultureInfo = new CultureInfo("en-US");
 935
 936                         // Hour only patterns
 937                         DateTime t2 = DateTime.Today + new TimeSpan (5,25,0);
 938                         DateTime t1 = DateTime.Parse ("05:25");
 939                         Assert.AreEqual (t2.Ticks, t1.Ticks, "#C1");
 940                         t2 = DateTime.Today + new TimeSpan (5,25,13);
 941                         t1 = DateTime.Parse ("05:25:13");
 942                         Assert.AreEqual (t2.Ticks, t1.Ticks, "#B2");
 943
 944                         // Test with different date formats
 945                         t1 = DateTime.Parse ("05:25 02/25/2002", USCultureInfo);
 946                         Assert.AreEqual (myTicks[3], t1.Ticks, "#B1");
 947                         t1 = DateTime.Parse ("05:25:13 2002-02-25");
 948                         Assert.AreEqual (myTicks[4], t1.Ticks, "#B2");
 949                         t1 = DateTime.Parse ("05:25:13.008 02-2002-25");
 950                         Assert.AreEqual (myTicks[2], t1.Ticks, "#B3");
 951                         t1 = DateTime.Parse ("05:25:13.008 Feb 25 2002");
 952                         Assert.AreEqual (myTicks[2], t1.Ticks, "#B4");
 953                         t1 = DateTime.Parse ("05:25:13.008 25 Feb 2002");
 954                         Assert.AreEqual (myTicks[2], t1.Ticks, "#B5");
 955
 956                         // Add AM and day of the week
 957                         t1 = DateTime.Parse ("AM 05:25:13 2002-02-25");
 958                         Assert.AreEqual (myTicks[4], t1.Ticks, "#C1");
 959                         t1 = DateTime.Parse ("Monday05:25 02/25/2002", USCultureInfo);
 960                         Assert.AreEqual (myTicks[3], t1.Ticks, "#C2");
 961                         t1 = DateTime.Parse ("Mon 05:25 AM 02/25/2002", USCultureInfo);
 962                         Assert.AreEqual (myTicks[3], t1.Ticks, "#C3");
 963                         t1 = DateTime.Parse ("AM 05:25 Monday, 02/25/2002", USCultureInfo);
 964                         Assert.AreEqual (myTicks[3], t1.Ticks, "#C4");
 965                         t1 = DateTime.Parse ("05:25 02/25/2002 Monday", USCultureInfo);
 966                         Assert.AreEqual (myTicks[3], t1.Ticks, "#C5");
 967                         t1 = DateTime.Parse ("PM 03:25:13.008 02-2002-25");
 968                         Assert.AreEqual (myTicks[1], t1.Ticks, "#C6");
 969
 970                         // ASP.NET QuickStarts
 971                         t2 = new DateTime (2002, 10, 7, 15, 6, 0);
 972                         t1 = DateTime.Parse ("3:06 PM 10/7/2002", USCultureInfo);
 973                         Assert.AreEqual (t2.Ticks, t1.Ticks, "#D1");
 974                         t2 = new DateTime (2002, 10, 7, 15, 6, 0);
 975                         t1 = DateTime.Parse ("3:06 pm 10/7/2002", USCultureInfo);
 976                         Assert.AreEqual (t2.Ticks, t1.Ticks, "#D2");
 977                         t2 = new DateTime (2002, 10, 7, 3, 6, 0);
 978                         t1 = DateTime.Parse ("3:06 AM 10/7/2002", USCultureInfo);
 979                         Assert.AreEqual (t2.Ticks, t1.Ticks, "#D3");
 980                         t2 = new DateTime (2002, 10, 7, 3, 6, 0);
 981                         t1 = DateTime.Parse ("3:06 am 10/7/2002", USCultureInfo);
 982                         Assert.AreEqual (t2.Ticks, t1.Ticks, "#D4");
 983                 }
 984
 985                 [Test]
 986                 public void TestParseWithDifferentShortDatePatterns ()
 987                 {
 988                         CultureInfo cultureInfo = new CultureInfo("en-US");
 989                         DateTimeFormatInfo dateFormatInfo = cultureInfo.DateTimeFormat;
 990                         DateTime t1 = DateTime.Parse ("02/01/2003", cultureInfo);
 991                         Assert.AreEqual (myTicks[7], t1.Ticks, "#A1");
 992
 993                         // Day, month year behaviour
 994                         dateFormatInfo.ShortDatePattern = "dd/MM/yyyy";
 995                         t1 = DateTime.Parse ("01/02/03", cultureInfo);
 996                         Assert.AreEqual (myTicks[7], t1.Ticks, "#B1");
 997                         t1 = DateTime.Parse ("01/02/2003", cultureInfo);
 998                         Assert.AreEqual (myTicks[7], t1.Ticks, "#B2");
 999                         t1 = DateTime.Parse ("2003/02/01", cultureInfo);
1000                         Assert.AreEqual (myTicks[7], t1.Ticks, "#B3");
1001                         t1 = DateTime.Parse ("01/Feb/03", cultureInfo);
1002                         Assert.AreEqual (myTicks[7], t1.Ticks, "#B4");
1003                         t1 = DateTime.Parse ("Feb/01/03", cultureInfo);
1004                         Assert.AreEqual (myTicks[7], t1.Ticks, "#B5");
1005
1006                         // Month, day year behaviour
1007                         dateFormatInfo.ShortDatePattern = "MM/dd/yyyy";
1008                         t1 = DateTime.Parse ("02/01/03", cultureInfo);
1009                         Assert.AreEqual (myTicks[7], t1.Ticks, "#C1");
1010                         t1 = DateTime.Parse ("02/01/2003", cultureInfo);
1011                         Assert.AreEqual (myTicks[7], t1.Ticks, "#C2");
1012                         t1 = DateTime.Parse ("2003/02/01", cultureInfo);
1013                         Assert.AreEqual (myTicks[7], t1.Ticks, "#C3");
1014                         t1 = DateTime.Parse ("01/Feb/03", cultureInfo);
1015                         Assert.AreEqual (myTicks[7], t1.Ticks, "#C4");
1016                         t1 = DateTime.Parse ("Feb/01/03", cultureInfo);
1017                         Assert.AreEqual (myTicks[7], t1.Ticks, "#C5");
1018
1019                         // Year, month day behaviour
1020                         dateFormatInfo.ShortDatePattern = "yyyy/MM/dd";
1021                         t1 = DateTime.Parse ("03/02/01", cultureInfo);
1022                         Assert.AreEqual (myTicks[7], t1.Ticks, "#D1");
1023                         t1 = DateTime.Parse ("02/01/2003", cultureInfo);
1024                         Assert.AreEqual (myTicks[7], t1.Ticks, "#D2");
1025                         t1 = DateTime.Parse ("2003/02/01", cultureInfo);
1026                         Assert.AreEqual (myTicks[7], t1.Ticks, "#D3");
1027                         t1 = DateTime.Parse ("03/Feb/01", cultureInfo);
1028                         Assert.AreEqual (myTicks[7], t1.Ticks, "#D4");
1029                         t1 = DateTime.Parse ("Feb/03/01", cultureInfo);
1030                         Assert.AreEqual (myTicks[7], t1.Ticks, "#D5");
1031
1032                         // Year, day month behaviour
1033                         // Note that no culture I am aware of has this pattern, and indeed
1034                         dateFormatInfo.ShortDatePattern = "yyyy/dd/MM";
1035                         t1 = DateTime.Parse ("03/01/02", cultureInfo);
1036                         Assert.AreEqual (myTicks[7], t1.Ticks, "#E1");
1037                         t1 = DateTime.Parse ("01/02/2003", cultureInfo);
1038                         Assert.AreEqual (myTicks[7], t1.Ticks, "#E2");
1039 #if NET_2_0
1040                         t1 = DateTime.Parse ("2003/01/02", cultureInfo);
1041                         Assert.AreEqual (myTicks[7], t1.Ticks, "#E3");
1042 #else
1043                         t1 = DateTime.Parse ("2003/02/01", cultureInfo);
1044                         Assert.AreEqual (myTicks[7], t1.Ticks, "#E3");
1045 #endif
1046                         // For some reason the following throws an exception on .Net
1047                         // t1 = DateTime.Parse ("03/Feb/01", cultureInfo);
1048                         // Assert.AreEqual (myTicks[7], t1.Ticks, "#E4");
1049                         // t1 = DateTime.Parse ("03/01/Feb", cultureInfo);
1050                         // Assert.AreEqual (myTicks[7], t1.Ticks, "#E5");
1051                         // t1 = DateTime.Parse ("Feb/01/03", cultureInfo);
1052                         // Assert.AreEqual (myTicks[7], t1.Ticks, "#E6");
1053                 }
1054
1055                 [Test]
1056                 public void TestParseWithDifferentMonthDayPatterns ()
1057                 {
1058                         CultureInfo cultureInfo = new CultureInfo("en-US");
1059                         DateTimeFormatInfo dateFormatInfo = cultureInfo.DateTimeFormat;
1060                         DateTime t1 = DateTime.Parse ("Feb 03", cultureInfo);
1061                         Assert.AreEqual (2, t1.Month, "#A1");
1062                         Assert.AreEqual (3, t1.Day, "#A2");
1063
1064                         // Day month behaviour
1065                         dateFormatInfo.MonthDayPattern = "dd/MM";
1066 #if NET_2_0
1067                         t1 = DateTime.Parse ("Feb 03", cultureInfo);
1068                         Assert.AreEqual (2, t1.Month, "#B1");
1069                         Assert.AreEqual (1, t1.Day, "#B2");
1070                         Assert.AreEqual (2003, t1.Year, "#B3");
1071 #else // In .Net 1.0 "Feb 03" is always Feb 3rd (and not Feb 2003).
1072                         t1 = DateTime.Parse ("Feb 03", cultureInfo);
1073                         Assert.AreEqual (2, t1.Month, "#B4");
1074                         Assert.AreEqual (3, t1.Day, "#B5");
1075 #endif
1076                         t1 = DateTime.Parse ("03/02", cultureInfo);
1077                         Assert.AreEqual (2, t1.Month, "#B6");
1078                         Assert.AreEqual (3, t1.Day, "#B7");
1079                         t1 = DateTime.Parse ("03 Feb", cultureInfo);
1080                         Assert.AreEqual (2, t1.Month, "#B8");
1081                         Assert.AreEqual (3, t1.Day, "#B9");
1082
1083                         // Month day behaviour
1084                         dateFormatInfo.MonthDayPattern = "MM/dd";
1085                         t1 = DateTime.Parse ("Feb 03", cultureInfo);
1086                         Assert.AreEqual (2, t1.Month, "#C1");
1087                         Assert.AreEqual (3, t1.Day, "#C2");
1088                         t1 = DateTime.Parse ("02/03", cultureInfo);
1089                         Assert.AreEqual (2, t1.Month, "#C3");
1090                         Assert.AreEqual (3, t1.Day, "#C4");
1091                         t1 = DateTime.Parse ("03 Feb", cultureInfo);
1092                         Assert.AreEqual (2, t1.Month, "#C5");
1093                         Assert.AreEqual (3, t1.Day, "#C6");
1094                 }
1095
1096                 [Test]
1097                 public void TestParse3 ()
1098                 {
1099                         string s = "Wednesday, 09 June 2004";
1100                         DateTime.ParseExact (s, "dddd, dd MMMM yyyy", CultureInfo.InvariantCulture);
1101                         try {
1102                                 DateTime.ParseExact (s, "dddd, dd MMMM yyyy", new CultureInfo ("ja-JP"));
1103                                 Assert.Fail ("ja-JP culture does not support format \"dddd, dd MMMM yyyy\"");
1104                         } catch (FormatException) {
1105                         }
1106
1107                         // Ok, now we can assume ParseExact() works expectedly.
1108
1109                         DateTime.Parse (s, CultureInfo.InvariantCulture, DateTimeStyles.AllowWhiteSpaces);
1110                         DateTime.Parse (s, new CultureInfo ("ja-JP"), DateTimeStyles.AllowWhiteSpaces);
1111                         //DateTime.Parse (s, null); currently am not sure if it works for _every_ culture.
1112                 }
1113
1114
1115                 [Test] // bug #74936
1116                 public void TestParse4 ()
1117                 {
1118                         try {
1119                                 DateTime.Parse("1");
1120                                 Assert.Fail ("#1");
1121                         } catch (FormatException) {
1122                         }
1123
1124                         try {
1125                                 DateTime.Parse("1000");
1126                                 Assert.Fail ("#2");
1127                         } catch (FormatException) {
1128                         }
1129
1130                         try {
1131                                 DateTime.Parse("8:");
1132                                 Assert.Fail ("#3");
1133                         } catch (FormatException) {
1134                         }
1135                 }
1136
1137                 [Test] // bug #71289
1138                 public void Parse_Bug71289a ()
1139                 {
1140                         DateTime.Parse ("Sat,,,,,, 01 Oct 1994 03:00:00", CultureInfo.InvariantCulture);
1141                 }
1142
1143                 [Test]
1144                 public void Parse_Bug71289b ()
1145                 {
1146                         // more example...
1147                         DateTime.Parse ("Sat,,, 01,,, Oct,,, ,,,1994 03:00:00", CultureInfo.InvariantCulture);
1148                 }
1149
1150 #if NET_2_0
1151                 [Test]
1152                 [ExpectedException (typeof (FormatException))]
1153                 public void Parse_CommaAfterHours ()
1154                 {
1155                         // ',' after 03 is not allowed.
1156                         DateTime.Parse ("Sat,,, 01,,, Oct,,, ,,,1994 03,:00:00", CultureInfo.InvariantCulture);
1157                 }
1158 #endif
1159
1160                 [Test] // bug #72788
1161                 public void Parse_Bug72788 ()
1162                 {
1163                         DateTime dt = DateTime.Parse ("21/02/05", new CultureInfo ("fr-FR"));
1164                         Assert.AreEqual (2005, dt.Year, "#1");
1165                         Assert.AreEqual (02, dt.Month, "#2");
1166                         Assert.AreEqual (21, dt.Day, "#3");
1167                 }
1168
1169                 [Test]
1170                 // FIXME: This test doesn't work on cultures like es-DO which have patterns
1171                 // for both dd/MM/yyyy & MM/dd/yyyy
1172                 [Category ("NotWorking")]
1173                 public void Parse_Bug53023a ()
1174                 {
1175                         foreach (CultureInfo ci in CultureInfo.GetCultures (CultureTypes.SpecificCultures)) {
1176                                 FormatException e = null;
1177                                 try {
1178                                         // this fails for MOST culture under MS 1.1 SP1
1179                                         DateTime.Parse ("8/16/2005", ci);
1180                                 }
1181                                 catch (FormatException fe) {
1182                                         e = fe;
1183                                 }
1184                                 string c = ci.ToString ();
1185                                 switch (c) {
1186                                 case "af-ZA":
1187                                 case "en-CB":
1188                                 case "en-PH":
1189                                 case "en-US":
1190                                 case "en-ZA":
1191                                 case "en-ZW":
1192                                 case "es-PA":
1193                                 case "eu-ES":
1194                                 case "fa-IR":
1195                                 case "fr-CA":
1196                                 case "hu-HU":
1197                                 case "ja-JP":
1198                                 case "ko-KR":
1199                                 case "lv-LV":
1200                                 case "lt-LT":
1201                                 case "mn-MN":
1202                                 case "pl-PL":
1203                                 case "sq-AL":
1204                                 case "sv-SE":
1205                                 case "sw-KE":
1206                                 case "zh-CN":
1207                                 case "zh-TW":
1208 #if NET_2_0
1209                                 case "ns-ZA":
1210                                 case "se-SE":
1211                                 case "sma-SE":
1212                                 case "smj-SE":
1213                                 case "tn-ZA":
1214                                 case "xh-ZA":
1215                                 case "zu-ZA":
1216 #endif
1217                                         Assert.IsNull (e, c);
1218                                         break;
1219                                 default:
1220                                         Assert.IsNotNull (e, c);
1221                                         break;
1222                                 }
1223                         }
1224                 }
1225
1226                 [Test]
1227                 public void Parse_Bug53023b ()
1228                 {
1229                         foreach (CultureInfo ci in CultureInfo.GetCultures (CultureTypes.SpecificCultures)) {
1230                                 DateTime.Parse ("01-Sep-05", ci);
1231                                 DateTime.Parse ("4:35:35 AM", ci);
1232                         }
1233                 }
1234
1235                 [Test]
1236                 [ExpectedException (typeof (FormatException))]
1237                 [Category ("NotWorking")]
1238                 public void Parse_RequireSpaceSeparator ()
1239                 {
1240                         DateTime.Parse ("05:25:132002-02-25", CultureInfo.InvariantCulture);
1241                 }
1242
1243                 [Test]
1244                 [ExpectedException (typeof (FormatException))]
1245                 public void Parse_DontAccept2DigitsYears ()
1246                 {
1247                         // don't allow 2 digit years where we require 4.
1248                         DateTime.ParseExact ("05", "yyyy", CultureInfo.InvariantCulture);
1249                 }
1250
1251                 [Test]
1252                 [ExpectedException (typeof (FormatException))]
1253                 public void Parse_DontAcceptEmptyHours ()
1254                 {
1255                         DateTime.ParseExact (":05", "H:m", CultureInfo.InvariantCulture);
1256                 }
1257
1258                 [Test]
1259                 [ExpectedException (typeof (FormatException))]
1260                 public void Parse_DontAcceptEmptyMinutes ()
1261                 {
1262                         DateTime.ParseExact ("0::0", "H:m:s", CultureInfo.InvariantCulture);
1263                 }
1264
1265                 [Test]
1266                 public void ParseCOMDependentFormat ()
1267                 {
1268                         // Japanese format.
1269                         DateTime.Parse (String.Format (
1270                                 "{0}\u5E74{1}\u6708{2}\u65E5 {3}\u6642{4}\u5206{5}\u79D2",
1271                                 2006, 3, 1, 15, 32, 42), new CultureInfo (""));
1272
1273                         try {
1274                                 // incorrect year mark.
1275                                 DateTime.Parse (String.Format (
1276                                         "{0}\u4E00{1}\u6708{2}\u65E5 {3}\u6642{4}\u5206{5}\u79D2",
1277                                         2006, 3, 1, 15, 32, 42), new CultureInfo (""));
1278                                 Assert.Fail ();
1279                         } catch (FormatException) {
1280                         }
1281                 }
1282
1283                 [Test]
1284                 [ExpectedException(typeof (FormatException))]
1285                 public void ParseFormatException1 ()
1286                 {
1287                         // Following string is not a correct French date i.e.
1288                         // MM/dd/yyyy HH:mm:ss since it expects d/M/yyyy HH:mm:ss
1289                         // instead (however fr-FR accepts both MM/dd/yyyy and
1290                         // dd/MM/yyyy, which means that we can't just throw exceptions
1291                         // on overflow).
1292                         String frDateTime = "11/13/2003 11:28:15";
1293                         IFormatProvider format = new CultureInfo("fr-FR", true);
1294                         DateTime t1 = DateTime.Parse(frDateTime, format);
1295                 }
1296
1297                 [Test]
1298 #if NET_2_0
1299                 [ExpectedException(typeof (FormatException))]
1300 #else
1301                 [ExpectedException(typeof (ArgumentOutOfRangeException))]
1302 #endif
1303                 public void ParseFormatExceptionForInvalidYear ()
1304                 {
1305                         // Bug #77633.  In .NET 1..1, the expected exception is ArgumentOutOfRangeException
1306                         // In .NET 2.0, the expected exception is FormatException
1307                         // build a string with the year of 5 digits
1308                         string s = "1/1/10000";
1309                         DateTime dt = DateTime.Parse (s);
1310                 }
1311
1312                 [Test]
1313                 public void TestOA ()
1314                 {
1315                         double number=5000.41443;
1316                         DateTime d = DateTime.FromOADate(number);
1317                         DTAssertEquals ("#1", d, new DateTime(1913, 9, 8, 9, 56, 46, 0), Resolution.Second);
1318                         Assert.AreEqual (d.ToOADate(), number, "#2");
1319                 }
1320
1321                 [Test]
1322                 public void ParseAllowsQueerString ()
1323                 {
1324                         DateTime.Parse ("Sat,,,,,, 01 Oct 1994 03:00:00", CultureInfo.InvariantCulture);
1325                 }
1326
1327                 [Test]
1328                 public void ParseUtcNonUtc ()
1329                 {
1330                         Thread.CurrentThread.CurrentCulture = new CultureInfo ("es-ES");
1331
1332                         CultureInfo ci;
1333                         string s, s2, s3, d;
1334                         DateTime dt;
1335                         DateTimeFormatInfo dfi = DateTimeFormatInfo.InvariantInfo;
1336                         s = dfi.UniversalSortableDateTimePattern;
1337                         s2 = "r";
1338
1339                         s3 = "s";
1340
1341                         long tick1 = 631789220960000000; // 2003-01-23 12:34:56 as is
1342                         long tick2 = TimeZone.CurrentTimeZone.ToLocalTime (new DateTime (tick1)).Ticks; // adjusted to local time
1343
1344                         // invariant
1345                         ci = CultureInfo.InvariantCulture;
1346
1347                         d = "2003/01/23 12:34:56";
1348                         dt = DateTime.Parse (d, ci);
1349                         Assert.AreEqual (tick1, dt.Ticks, "#1:" + d);
1350
1351                         d = "2003/01/23 12:34:56 GMT";
1352                         dt = DateTime.Parse (d, ci);
1353                         Assert.AreEqual (tick2, dt.Ticks, "#2:" + d);
1354
1355                         d = "Thu, 23 Jan 2003 12:34:56 GMT";
1356                         dt = DateTime.ParseExact (d, s2, ci);
1357                         Assert.AreEqual (tick1, dt.Ticks, "#3:" + d);
1358
1359                         d = "2003-01-23 12:34:56Z";
1360                         dt = DateTime.ParseExact (d, s, ci);
1361                         Assert.AreEqual (tick1, dt.Ticks, "#4:" + d);
1362
1363                         d = "2003-01-23T12:34:56";
1364                         dt = DateTime.ParseExact (d, s3, ci);
1365                         Assert.AreEqual (tick1, dt.Ticks, "#5:" + d);
1366
1367                         // ja-JP ... it should be culture independent
1368                         ci = new CultureInfo ("ja-JP");
1369
1370                         d = "2003/01/23 12:34:56";
1371                         dt = DateTime.Parse (d, ci);
1372                         Assert.AreEqual (tick1, dt.Ticks, "#6:" + d);
1373
1374                         d = "2003/01/23 12:34:56 GMT";
1375                         dt = DateTime.Parse (d, ci);
1376                         Assert.AreEqual (tick2, dt.Ticks, "#7:" + d);
1377
1378                         d = "Thu, 23 Jan 2003 12:34:56 GMT";
1379                         dt = DateTime.ParseExact (d, s2, ci);
1380                         Assert.AreEqual (tick1, dt.Ticks, "#8:" + d);
1381
1382                         d = "2003-01-23 12:34:56Z";
1383                         dt = DateTime.ParseExact (d, s, ci);
1384                         Assert.AreEqual (tick1, dt.Ticks, "#9:" + d);
1385
1386                         d = "2003-01-23T12:34:56";
1387                         dt = DateTime.ParseExact (d, s3, ci);
1388                         Assert.AreEqual (tick1, dt.Ticks, "#10:" + d);
1389                 }
1390
1391                 [Test]
1392                 public void TimeZoneAdjustment ()
1393                 {
1394                         CultureInfo ci = Thread.CurrentThread.CurrentCulture;
1395                         try {
1396                                 Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US");
1397                                 DateTime d1 = DateTime.ParseExact ("2004/06/30", "yyyy/MM/dd", null);
1398                                 DateTime d2 = DateTime.ParseExact ("2004/06/30Z", "yyyy/MM/dd'Z'", null);
1399                                 DateTime d3 = DateTime.ParseExact ("Wed, 30 Jun 2004 00:00:00 GMT", "ddd, dd MMM yyyy HH':'mm':'ss 'GMT'", null);
1400                                 DateTime d4 = DateTime.ParseExact ("2004-06-30 00:00:00Z", "yyyy'-'MM'-'dd HH':'mm':'ss'Z'", null);
1401                                 StringWriter sw = new StringWriter ();
1402                                 sw.Write ("{0} {1}", d1.Ticks, d1);
1403                                 Assert.AreEqual ("632241504000000000 6/30/2004 12:00:00 AM", sw.ToString (), "#1");
1404                                 sw.GetStringBuilder ().Length = 0;
1405                                 sw.Write ("{0} {1}", d2.Ticks, d2);
1406                                 Assert.AreEqual ("632241504000000000 6/30/2004 12:00:00 AM", sw.ToString (), "#2");
1407                                 sw.GetStringBuilder ().Length = 0;
1408                                 sw.Write ("{0} {1}", d3.Ticks, d3);
1409                                 Assert.AreEqual ("632241504000000000 6/30/2004 12:00:00 AM", sw.ToString (), "#3");
1410                                 sw.GetStringBuilder ().Length = 0;
1411                                 sw.Write ("{0} {1}", d4.Ticks, d4);
1412                                 Assert.AreEqual ("632241504000000000 6/30/2004 12:00:00 AM", sw.ToString (), "#4");
1413                         } finally {
1414                                 Thread.CurrentThread.CurrentCulture = ci;
1415                         }
1416
1417                         // bug #76082
1418                         Assert.AreEqual (DateTime.MinValue, DateTime.ParseExact ("00010101T00:00:00",
1419                                         "yyyyMMdd'T'HH':'mm':'ss", DateTimeFormatInfo.InvariantInfo), "#5");
1420                 }
1421
1422                 [Test]
1423                 public void DateTimeStylesAdjustToUniversal ()
1424                 {
1425                         // bug #75995 : AdjustToUniversal
1426                         DateTime t1 = DateTime.Parse ("2005-09-05T22:29:00Z",
1427                                 CultureInfo.InvariantCulture,
1428                                 DateTimeStyles.AdjustToUniversal);
1429                         Assert.AreEqual ("2005-09-05 22:29:00Z", t1.ToString ("u"));
1430                 }
1431
1432                 [Test]
1433                 [ExpectedException (typeof (ArgumentException))]
1434                 public void FromOADate_Min ()
1435                 {
1436                         // minimum documented value isn't inclusive
1437                         DateTime.FromOADate (-657435.0d);
1438                 }
1439
1440                 [Test]
1441                 [ExpectedException (typeof (ArgumentException))]
1442                 public void FromOADate_Max ()
1443                 {
1444                         // maximum documented value isn't inclusive
1445                         DateTime.FromOADate (2958466.0d);
1446                 }
1447
1448                 [Test]
1449                 public void FromOADate ()
1450                 {
1451                         // Note: OA (OLE Automation) dates aren't timezone sensitive
1452                         Assert.AreEqual (599264352000000000, DateTime.FromOADate (0.0d).Ticks, "#1");
1453                         Assert.AreEqual (31242239136000000, DateTime.FromOADate (-657434.999d).Ticks, "#2");
1454                         Assert.AreEqual (3155378975136000000, DateTime.FromOADate (2958465.999d).Ticks, "#3");
1455                 }
1456
1457                 [Test]
1458                 public void ToOADate ()
1459                 {
1460                         // Note: OA (OLE Automation) dates aren't timezone sensitive
1461                         DateTime d = new DateTime (0);
1462                         Assert.AreEqual (0.0d, d.ToOADate (), "#1");
1463                         d = new DateTime (599264352000000000);
1464                         Assert.AreEqual (0.0d, d.ToOADate (), "#2");
1465                         d = new DateTime (31242239136000000);
1466                         Assert.AreEqual (-657434.999d, d.ToOADate (), "#3");
1467                         d = new DateTime (3155378975136000000);
1468                         Assert.AreEqual (2958465.999d, d.ToOADate (), "#4");
1469                 }
1470
1471                 [Test]
1472                 public void ToOADate_OverMax ()
1473                 {
1474                         DateTime d = new DateTime (3155378975136000001);
1475                         Assert.AreEqual (2958465.999d, d.ToOADate ());
1476                 }
1477
1478                 [Test]
1479                 public void ToOADate_MaxValue ()
1480                 {
1481                         Assert.AreEqual (2958465.99999999d, DateTime.MaxValue.ToOADate ());
1482                 }
1483
1484                 [Test]
1485                 public void ToOADate_UnderMin ()
1486                 {
1487                         DateTime d = new DateTime (31242239135999999);
1488                         Assert.AreEqual (-657434.999d, d.ToOADate ());
1489                 }
1490
1491                 [Test]
1492                 public void ToOADate_MinValue ()
1493                 {
1494                         Assert.AreEqual (0, DateTime.MinValue.ToOADate ());
1495                 }
1496
1497                 [Test] // bug52075
1498                 public void MaxValueYear ()
1499                 {
1500                         Assert.AreEqual ("9999", DateTime.MaxValue.Year.ToString ());
1501                 }
1502
1503                 [Test]
1504                 public void X509Certificate ()
1505                 {
1506                         // if this test fails then *ALL* or *MOST* X509Certificate tests will also fails
1507                         DateTime dt = DateTime.ParseExact ("19960312183847Z", "yyyyMMddHHmmssZ", null);
1508 #if NET_2_0
1509                         Assert.AreEqual (DateTimeKind.Local, dt.Kind, "#1");
1510                         dt = dt.ToUniversalTime ();
1511                         Assert.AreEqual (DateTimeKind.Utc, dt.Kind, "#2");
1512 #else
1513                         dt = dt.ToUniversalTime ();
1514 #endif
1515                         Assert.AreEqual ("03/12/1996 18:38:47", dt.ToString (), "#3");
1516
1517                         // technically this is invalid (PKIX) because of the missing seconds but it exists so...
1518                         dt = DateTime.ParseExact ("9602231915Z", "yyMMddHHmmZ", null);
1519 #if NET_2_0
1520                         Assert.AreEqual (DateTimeKind.Local, dt.Kind, "#4");
1521                         dt = dt.ToUniversalTime ();
1522                         Assert.AreEqual (DateTimeKind.Utc, dt.Kind, "#5");
1523 #else
1524                         dt = dt.ToUniversalTime ();
1525 #endif
1526                         Assert.AreEqual ("02/23/1996 19:15:00", dt.ToString (), "#6");
1527                 }
1528
1529                 [Test]
1530 #if NET_2_0
1531                 [Category ("NotWorking")]
1532 #endif
1533                 public void ZLiteral ()
1534                 {
1535                         // However, "Z" and "'Z'" are different.
1536                         DateTime dt = DateTime.ParseExact ("19960312183847Z", "yyyyMMddHHmmss'Z'", null);
1537                         DateTime dtz = DateTime.ParseExact ("19960312183847Z", "yyyyMMddHHmmssZ", null);
1538 #if NET_2_0
1539                         Assert.AreEqual (DateTimeKind.Unspecified, dt.Kind, "#1");
1540                         dt = dt.ToLocalTime ();
1541                         Assert.AreEqual (DateTimeKind.Local, dt.Kind, "#2");
1542                         Assert.AreEqual (DateTimeKind.Local, dtz.Kind, "#3");
1543 #else
1544                         dt = dt.ToLocalTime ();
1545 #endif
1546                         Assert.AreEqual (dt, dtz, "#4");
1547                 }
1548
1549                 [Test] // bug 56436
1550                 public void QuotedFormat ()
1551                 {
1552                         string date = "28/Mar/2004:19:12:37 +0200";
1553                         string [] expectedFormats = {"dd\"/\"MMM\"/\"yyyy:HH:mm:ss zz\"00\""};
1554                         DateTime.ParseExact (date, expectedFormats, null, DateTimeStyles.AllowWhiteSpaces);
1555                 }
1556
1557                 [Test]
1558                 public void CultureIndependentTests ()
1559                 {
1560                         // Here I aggregated some tests mainly because of test
1561                         // performance (iterating all the culture is heavy process).
1562
1563                         for (int i = 0; i < 32768; i++) {
1564                                 CultureInfo ci = null;
1565                                 string stage = "init";
1566                                 try {
1567                                         try {
1568                                                 ci = new CultureInfo (i);
1569                                                 // In fact InvatiantCulture is not neutral.
1570                                                 // See bug #59716.
1571                                                 if (ci.IsNeutralCulture && ci != CultureInfo.InvariantCulture)
1572                                                         continue;
1573                                         } catch (Exception) {
1574                                                 continue;
1575                                         }
1576                                         Thread.CurrentThread.CurrentCulture = ci;
1577                                         DateTime dt;
1578
1579                                         // Common patterns
1580                                         // X509Certificate pattern is _always_ accepted.
1581                                         stage = "1";
1582                                         dt = DateTime.ParseExact ("19960312183847Z", "yyyyMMddHHmmssZ", null);
1583 #if NET_1_1
1584                                         stage = "2";
1585                                         // culture 1025 ar-SA fails
1586         //                              if (i != 127)
1587         //                                      dt = DateTime.Parse ("19960312183847Z");
1588 #endif
1589                                         stage = "3";
1590                                         dt = DateTime.Parse ("2004-05-26T03:29:01.1234567");
1591                                         stage = "4";
1592                                         dt = DateTime.Parse ("2004-05-26T03:29:01.1234567-07:00");
1593
1594                                         // memo: the least LCID is 127, and then 1025(ar-SA)
1595
1596                                         // "th-TH" locale rejects them since in
1597                                         // ThaiBuddhistCalendar the week of a day is different.
1598                                         // (and also for years).
1599                                         if (ci.LCID != 1054) {
1600                                                 try {
1601                                                         stage = "5";
1602                                                         dt = DateTime.Parse ("Sat, 29 Oct 1994 12:00:00 GMT", ci);
1603                                                 } catch (FormatException ex) {
1604                                                         Assert.Fail (String.Format ("stage 5.1 RFC1123: culture {0} {1} failed: {2}", i, ci, ex.Message));
1605                                                 }
1606
1607                                                 // bug #47720
1608                                                 if (dt != TimeZone.CurrentTimeZone.ToUniversalTime (dt))
1609                                                         Assert.IsTrue (12 != dt.Hour, String.Format ("bug #47720 on culture {0} {1}", ci.LCID, ci));
1610
1611                                                 // variant of RFC1123
1612                                                 try {
1613                                                         stage = "6";
1614                                                         dt = DateTime.Parse ("Sat, 1 Oct 1994 03:00:00", ci);
1615                                                 } catch (FormatException ex) {
1616                                                         Assert.Fail (String.Format ("stage 6.1 RFC1123 variant: culture {0} {1} failed: {2}", i, ci, ex.Message));
1617                                                 }
1618                                                 stage = "7";
1619                                                 Assert.AreEqual (3, dt.Hour, String.Format ("stage 7.1 RFC1123 variant on culture {0} {1}", ci.LCID, ci));
1620                                         }
1621
1622                                         switch (ci.LCID) {
1623                                         case 1025: // ar-SA
1624                                         case 1054: // th-TH
1625                                         case 1125: // div-MV
1626                                                 break;
1627                                         default:
1628                                                 stage = "8";
1629                                                 // 02/25/2002 04:25:13 as is
1630                                                 long tick1 = 631502079130000000;
1631                                                 long tick2 = TimeZone.CurrentTimeZone.ToLocalTime (new DateTime (tick1)).Ticks; // adjusted to local time
1632                                                 dt = DateTime.Parse ("Mon, 25 Feb 2002 04:25:13 GMT", ci);
1633                                                 Assert.AreEqual (tick2, dt.Ticks, String.Format ("GMT variant. culture={0} {1}", i, ci));
1634                                                 break;
1635                                         }
1636
1637 #if NET_1_1
1638                                         // ka-GE rejects these formats under MS.NET.
1639                                         // I wonder why. Also, those tests fail under .NET 1.0.
1640                                         if (ci.LCID != 1079) {
1641                                                 stage = "9";
1642                                                 dt = DateTime.Parse ("2002-02-25");
1643                                                 stage = "10";
1644                                                 dt = DateTime.Parse ("2002-02-25Z");
1645                                                 stage = "11";
1646                                                 dt = DateTime.Parse ("2002-02-25T19:20:00+09:00");
1647                                                 switch (ci.LCID) {
1648                                                 case 1038: // FIXME: MS passes this culture.
1649                                                 case 1062: // FIXME: MS passes this culture.
1650                                                 case 1078: // MS does not pass this culture. Dunno why.
1651                                                         break;
1652                                                 default:
1653 #if ONLY_1_1
1654                                                         // bug #58938
1655                                                         stage = "12";
1656                                                         dt = DateTime.Parse ("2002#02#25 19:20:00");
1657                                                         // this stage fails under MS 2.0
1658                                                         stage = "13";
1659                                                         Assert.AreEqual (19, dt.Hour, String.Format ("bug #58938 on culture {0} {1}", ci.LCID, ci));
1660 #endif
1661                                                         break;
1662                                                 }
1663                                                 stage = "14";
1664                                                 dt = DateTime.Parse ("2002-02-25 12:01:03");
1665 #if ONLY_1_1
1666                                                 stage = "15";
1667                                                 dt = DateTime.Parse ("2002#02#25 12:01:03");
1668                                                 stage = "16";
1669                                                 dt = DateTime.Parse ("2002%02%25 12:01:03");
1670 #endif
1671                                                 stage = "17";
1672                                                 if (ci.DateTimeFormat.TimeSeparator != ".")
1673                                                         dt = DateTime.Parse ("2002.02.25 12:01:03");
1674                                                 stage = "18";
1675                                                 dt = DateTime.Parse ("2003/01/23 01:34:56 GMT");
1676                                                 dt = TimeZone.CurrentTimeZone.ToUniversalTime (dt);
1677                                                 Assert.AreEqual (1, dt.Hour, String.Format ("stage 18.1 RFC1123 UTC {0} {1}", i, ci));
1678                                                 stage = "19";
1679                                                 // This test was fixed from 12:34:56 to
1680                                                 // 01:34:56 since 1078 af-ZA failed
1681                                                 // because of hour interpretation
1682                                                 // difference (af-ZA expects 0).
1683                                                 // (IMHO it is MS BUG though.)
1684                                                 dt = DateTime.Parse ("2003/01/23 12:34:56 GMT");
1685                                                 dt = TimeZone.CurrentTimeZone.ToUniversalTime (dt);
1686                                                 if (i != 1078)
1687                                                         Assert.AreEqual (12, dt.Hour, String.Format ("stage 18.1 RFC1123 UTC {0} {1}", i, ci));
1688                                         }
1689 #endif
1690                                 } catch (FormatException ex) {
1691                                         Assert.Fail (String.Format ("stage {3}: Culture {0} {1} failed: {2}", i, ci, ex.Message, stage));
1692                                 }
1693                         }
1694                 }
1695
1696                 [Test]
1697                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
1698                 public void ToFileTime_MinValue ()
1699                 {
1700                         DateTime.FromFileTime (Int64.MinValue);
1701                 }
1702
1703                 [Test]
1704                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
1705                 public void ToFileTime_Negative ()
1706                 {
1707                         DateTime.FromFileTime (-1);
1708                 }
1709
1710                 [Test]
1711                 public void ToFileTime ()
1712                 {
1713                         long u = DateTime.FromFileTimeUtc (0).Ticks;
1714                         Assert.AreEqual (504911232000000000, u, "#A1");
1715                         long max = DateTime.MaxValue.Ticks - 504911232000000000; // w32file_epoch
1716                         Assert.AreEqual (3155378975999999999, DateTime.FromFileTimeUtc (max).Ticks, "#A2");
1717
1718                         long t = DateTime.FromFileTime (0).Ticks;
1719                         Assert.IsTrue (t > (u - TimeSpan.TicksPerDay), "#B1");
1720                         Assert.IsTrue (t < (u + TimeSpan.TicksPerDay), "#B2");
1721                 }
1722
1723                 [Test]
1724                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
1725                 public void ToFileTimeUtc_MinValue ()
1726                 {
1727                         DateTime.FromFileTimeUtc (Int64.MinValue);
1728                 }
1729
1730                 [Test]
1731                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
1732                 public void ToFileTimeUtc_Negative ()
1733                 {
1734                         DateTime.FromFileTimeUtc (-1);
1735                 }
1736
1737                 [Test]
1738                 public void Milliseconds ()
1739                 {
1740                         DateTime dt = DateTime.Parse ("2004-05-26T03:29:01.1234567-07:00");
1741                         dt = TimeZone.CurrentTimeZone.ToUniversalTime (dt);
1742                         Assert.AreEqual (632211641411234567, dt.Ticks);
1743                 }
1744
1745                 [Test]
1746 #if NET_2_0
1747                 [ExpectedException (typeof (FormatException))]
1748 #else
1749                 [Ignore ("Works only under MS 1.x (not Mono or MS 2.0).")]
1750 #endif
1751                 public void ParseNotExact ()
1752                 {
1753                         // The error reported is:
1754                         // String was not recognized as valid DateTime
1755                         DateTime dt = DateTime.Parse ("2004-05-26T03:29:01-07:00 foo");
1756                         dt = TimeZone.CurrentTimeZone.ToUniversalTime (dt);
1757                         Assert.AreEqual (632211641410000000, dt.Ticks);
1758                 }
1759
1760                 [Test]
1761                 public void ParseExact_Bug80094 ()
1762                 {
1763                         // we can safely change the curernt culture, as the original value will
1764                         // be restored on TearDown
1765                         Thread.CurrentThread.CurrentCulture = new CultureInfo ("ja-JP");
1766                         string y = string.Format ("{0}-{1}-{2} {3}", DateTime.Now.Year.ToString (),
1767                                 "11", "29", "06:34");
1768                         DateTime date = DateTime.ParseExact (y, "yyyy-MMM-dd hh:mm", null);
1769                         Assert.AreEqual (DateTime.Now.Year, date.Year, "#1");
1770                         Assert.AreEqual (11, date.Month, "#2");
1771                         Assert.AreEqual (29, date.Day, "#3");
1772                         Assert.AreEqual (6, date.Hour, "#4");
1773                         Assert.AreEqual (34, date.Minute, "#5");
1774                         Assert.AreEqual (0, date.Second, "#6");
1775                         Assert.AreEqual (0, date.Millisecond, "#7");
1776                 }
1777
1778 #if NET_2_0
1779                 [Test]
1780                 public void ParseExact_Bug324845 ()
1781                 {
1782                         DateTime ctime = new DateTime (2007, 7, 23, 19, 19, 45);
1783                         ctime = ctime.ToUniversalTime ();
1784                         string instr = ctime.ToString ("yyyyMMddHHmmss");
1785
1786                         DateTime t = DateTime.ParseExact (instr, "yyyyMMddHHmmss", null, DateTimeStyles.AssumeUniversal);
1787                         Assert.AreEqual (2007, t.Year);
1788                         Assert.AreEqual (7, t.Month);
1789                         Assert.AreEqual (23, t.Day);
1790                         Assert.AreEqual (19, t.Hour);
1791                         Assert.AreEqual (19, t.Minute);
1792                         Assert.AreEqual (45, t.Second);
1793
1794                 }
1795 #endif
1796
1797                 [Test]
1798                 [ExpectedException (typeof (FormatException))]
1799                 public void ParseExactIsExact()
1800                 {
1801                         DateTime.ParseExact ("2004-05-26T03:29:01-07:00 foo", "yyyy-MM-ddTHH:mm:sszzz", null);
1802                 }
1803
1804                 [Test]
1805                 [ExpectedException (typeof (FormatException))]
1806                 public void ParseExactDoesNotEatZ ()
1807                 {
1808                         DateTime.ParseExact ("2004-05-26T03:29:01", "yyyy-MM-ddTHH:mm:ssZ", null);
1809                 }
1810
1811                 [Test]
1812                 public void ParseExactMilliseconds ()
1813                 {
1814                         DateTime dt = DateTime.ParseExact ("2004-05-26T03:29:01.1234567-07:00", "yyyy-MM-ddTHH:mm:ss.fffffffzzz", null);
1815                         dt = TimeZone.CurrentTimeZone.ToUniversalTime (dt);
1816                         Assert.AreEqual (632211641411234567, dt.Ticks);
1817                 }
1818
1819                 [Test]
1820                 public void NoColonTimeZone ()
1821                 {
1822                         Assert.IsTrue (DateTime.Parse ("2004-05-26T03:29:01-0700").Ticks
1823                                 != DateTime.Parse ("2004-05-26T03:29:01-0800").Ticks);
1824                 }
1825
1826                 [Test]
1827                 public void WithColonTimeZone ()
1828                 {
1829                         Assert.IsTrue (DateTime.Parse ("2004-05-26T03:29:01-07:00").Ticks
1830                                 != DateTime.Parse ("2004-05-26T03:29:01-08:00").Ticks);
1831                 }
1832
1833                 [Test]
1834                 [ExpectedException (typeof (FormatException))]
1835                 public void EmptyFormatPattern ()
1836                 {
1837                         DateTime.ParseExact (String.Empty, String.Empty, null);
1838                 }
1839
1840                 [Test]
1841                 [ExpectedException (typeof (InvalidCastException))]
1842                 public void IConvertible_ToType_Boolean ()
1843                 {
1844                         ((IConvertible)DateTime.Now).ToType (typeof (bool), null);
1845                 }
1846
1847                 [Test]
1848                 [ExpectedException (typeof (InvalidCastException))]
1849                 public void IConvertible_ToType_Byte ()
1850                 {
1851                         ((IConvertible)DateTime.Now).ToType (typeof (byte), null);
1852                 }
1853
1854                 [Test]
1855                 [ExpectedException (typeof (InvalidCastException))]
1856                 public void IConvertible_ToType_Char ()
1857                 {
1858                         ((IConvertible)DateTime.Now).ToType (typeof (char), null);
1859                 }
1860
1861                 [Test]
1862                 public void IConvertible_ToType_DateTime ()
1863                 {
1864                         DateTime dt = DateTime.Now;
1865                         DateTime dt2 = (DateTime) ((IConvertible)dt).ToType (typeof (DateTime), null);
1866                         Assert.IsTrue (dt.Equals (dt2));
1867                 }
1868
1869                 [Test]
1870                 [ExpectedException (typeof (InvalidCastException))]
1871                 public void IConvertible_ToType_DBNull ()
1872                 {
1873                         ((IConvertible)DateTime.Now).ToType (typeof (DBNull), null);
1874                 }
1875
1876                 [Test]
1877                 [ExpectedException (typeof (InvalidCastException))]
1878                 public void IConvertible_ToType_Decimal ()
1879                 {
1880                         ((IConvertible)DateTime.Now).ToType (typeof (decimal), null);
1881                 }
1882
1883                 [Test]
1884                 [ExpectedException (typeof (InvalidCastException))]
1885                 public void IConvertible_ToType_Double ()
1886                 {
1887                         ((IConvertible)DateTime.Now).ToType (typeof (double), null);
1888                 }
1889
1890                 [Test]
1891                 [ExpectedException (typeof (ArgumentNullException))]
1892                 public void IConvertible_ToType_Empty ()
1893                 {
1894                         ((IConvertible)DateTime.Now).ToType (null, null);
1895                 }
1896
1897                 [Test]
1898                 [ExpectedException (typeof (InvalidCastException))]
1899                 public void IConvertible_ToType_Int16 ()
1900                 {
1901                         ((IConvertible)DateTime.Now).ToType (typeof (short), null);
1902                 }
1903
1904                 [Test]
1905                 [ExpectedException (typeof (InvalidCastException))]
1906                 public void IConvertible_ToType_Int32 ()
1907                 {
1908                         ((IConvertible)DateTime.Now).ToType (typeof (int), null);
1909                 }
1910
1911                 [Test]
1912                 [ExpectedException (typeof (InvalidCastException))]
1913                 public void IConvertible_ToType_Int64 ()
1914                 {
1915                         ((IConvertible)DateTime.Now).ToType (typeof (long), null);
1916                 }
1917
1918                 [Test]
1919                 public void IConvertible_ToType_Object ()
1920                 {
1921                         DateTime dt = DateTime.Now;
1922                         object o = ((IConvertible)dt).ToType (typeof (object), null);
1923                         Assert.IsTrue (dt.Equals (o));
1924                 }
1925
1926                 [Test]
1927                 [ExpectedException (typeof (InvalidCastException))]
1928                 public void IConvertible_ToType_SByte ()
1929                 {
1930                         ((IConvertible)DateTime.Now).ToType (typeof (sbyte), null);
1931                 }
1932
1933                 [Test]
1934                 [ExpectedException (typeof (InvalidCastException))]
1935                 public void IConvertible_ToType_Single ()
1936                 {
1937                         ((IConvertible)DateTime.Now).ToType (typeof (float), null);
1938                 }
1939
1940                 [Test]
1941                 public void IConvertible_ToType_String ()
1942                 {
1943                         DateTime dt = DateTime.Now;
1944                         string s = (string) ((IConvertible)dt).ToType (typeof (string), null);
1945                         Assert.AreEqual (s, dt.ToString ());
1946                 }
1947
1948                 [Test]
1949                 [ExpectedException (typeof (InvalidCastException))]
1950                 public void IConvertible_ToType_UInt16 ()
1951                 {
1952                         ((IConvertible)DateTime.Now).ToType (typeof (ushort), null);
1953                 }
1954
1955                 [Test]
1956                 [ExpectedException (typeof (InvalidCastException))]
1957                 public void IConvertible_ToType_UInt32 ()
1958                 {
1959                         ((IConvertible)DateTime.Now).ToType (typeof (uint), null);
1960                 }
1961
1962                 [Test]
1963                 [ExpectedException (typeof (InvalidCastException))]
1964                 public void IConvertible_ToType_UInt64 ()
1965                 {
1966                         ((IConvertible)DateTime.Now).ToType (typeof (ulong), null);
1967                 }
1968
1969 #if NET_2_0
1970                 [Test]
1971                 public void Kind ()
1972                 {
1973                         if (DateTime.Now == DateTime.UtcNow)
1974                                 return; // This test does not make sense.
1975                         if (TimeZone.CurrentTimeZone.GetUtcOffset (DateTime.UtcNow)
1976                                 != TimeZone.CurrentTimeZone.GetUtcOffset (DateTime.Now))
1977                                 return; // In this case it does not satisfy the test premises.
1978
1979                         Assert.AreEqual (DateTimeKind.Local, DateTime.Now.Kind, "#A1");
1980                         Assert.AreEqual (DateTimeKind.Local, DateTime.Today.Kind, "#A2");
1981
1982                         DateTime utc = DateTime.UtcNow;
1983                         DateTime now = new DateTime (utc.Ticks + TimeZone.
1984                                 CurrentTimeZone.GetUtcOffset (utc).Ticks, DateTimeKind.Local);
1985                         DateTime utctouniv = utc.ToUniversalTime ();
1986                         DateTime nowtouniv = now.ToUniversalTime ();
1987                         DateTime utctoloc = utc.ToLocalTime ();
1988                         DateTime nowtoloc = now.ToLocalTime ();
1989
1990                         Assert.AreEqual (DateTimeKind.Utc, utc.Kind, "#B1");
1991                         Assert.AreEqual (DateTimeKind.Local, now.Kind, "#B2");
1992                         Assert.AreEqual (DateTimeKind.Utc, utctouniv.Kind, "#B3");
1993                         Assert.AreEqual (DateTimeKind.Utc, nowtouniv.Kind, "#B4");
1994                         Assert.AreEqual (DateTimeKind.Local, utctoloc.Kind, "#B5");
1995                         Assert.AreEqual (DateTimeKind.Local, nowtoloc.Kind, "#B6");
1996                         Assert.AreEqual (utc, utctouniv, "#B7");
1997                         Assert.AreEqual (utc, nowtouniv, "#B8");
1998                         Assert.AreEqual (now, nowtoloc, "#B9");
1999                         Assert.AreEqual (now, utctoloc, "#B10");
2000                 }
2001
2002                 [Test]
2003                 public void InstanceMembersAndKind ()
2004                 {
2005                         Assert.AreEqual (DateTimeKind.Utc, DateTime.UtcNow.Date.Kind, "#1");
2006                         Assert.AreEqual (DateTimeKind.Utc, DateTime.UtcNow.Add (TimeSpan.FromMinutes (1)).Kind, "#2");
2007                         Assert.AreEqual (DateTimeKind.Utc, DateTime.UtcNow.Subtract (TimeSpan.FromMinutes (1)).Kind, "#3");
2008                         Assert.AreEqual (DateTimeKind.Utc, DateTime.UtcNow.AddDays (1).Kind, "#4");
2009                         Assert.AreEqual (DateTimeKind.Utc, DateTime.UtcNow.AddTicks (1).Kind, "#5");
2010                         Assert.AreEqual (DateTimeKind.Utc, DateTime.UtcNow.AddHours (1).Kind, "#6");
2011                         Assert.AreEqual (DateTimeKind.Utc, DateTime.UtcNow.AddMinutes (1).Kind, "#7");
2012                         Assert.AreEqual (DateTimeKind.Utc, DateTime.UtcNow.AddSeconds (1).Kind, "#8");
2013                         Assert.AreEqual (DateTimeKind.Utc, DateTime.UtcNow.AddMilliseconds (1).Kind, "#9");
2014                         Assert.AreEqual (DateTimeKind.Utc, DateTime.UtcNow.AddMonths (1).Kind, "#10");
2015                         Assert.AreEqual (DateTimeKind.Utc, DateTime.UtcNow.AddYears (1).Kind, "#11");
2016                         Assert.AreEqual (DateTimeKind.Utc, (DateTime.UtcNow + TimeSpan.FromMinutes (1)).Kind, "#12");
2017                         Assert.AreEqual (DateTimeKind.Utc, (DateTime.UtcNow - TimeSpan.FromMinutes (1)).Kind, "#13");
2018                 }
2019
2020                 [Test]
2021                 public void FromBinary ()
2022                 {
2023                         DateTime dt_utc = DateTime.FromBinary (0x4000000000000001);
2024                         Assert.AreEqual (DateTimeKind.Utc, dt_utc.Kind, "#1");
2025                         Assert.AreEqual (1, dt_utc.Ticks, "#2");
2026
2027                         DateTime dt_local = DateTime.FromBinary (unchecked ((long) 0x8000000000000001));
2028                         Assert.AreEqual (DateTimeKind.Local, dt_local.Kind, "#3");
2029
2030                         DateTime dt_unspecified = DateTime.FromBinary (0x0000000000000001);
2031                         Assert.AreEqual (DateTimeKind.Unspecified, dt_unspecified.Kind, "#4");
2032                         Assert.AreEqual (1, dt_unspecified.Ticks, "#5");
2033
2034                         DateTime dt_local2 = DateTime.FromBinary (unchecked ((long) 0xC000000000000001));
2035                         Assert.AreEqual (DateTimeKind.Local, dt_local2.Kind, "#6");
2036                         Assert.AreEqual (dt_local.Ticks, dt_local2.Ticks, "#7");
2037                 }
2038
2039                 [Test]
2040                 public void ToBinary ()
2041                 {
2042                         DateTime dt_local = new DateTime (1, DateTimeKind.Local);
2043                         Assert.AreEqual (1, (ulong) dt_local.ToBinary () >> 63, "#1");
2044                         Assert.AreEqual (1, dt_local.Ticks, "#2");
2045
2046                         DateTime dt_utc = new DateTime (1, DateTimeKind.Utc);
2047                         Assert.AreEqual (0x4000000000000001, dt_utc.ToBinary (), "#3");
2048                         Assert.AreEqual (1, dt_utc.Ticks, "#4");
2049
2050                         DateTime dt_unspecified = new DateTime (1, DateTimeKind.Unspecified);
2051                         Assert.AreEqual (1, dt_unspecified.ToBinary (), "#5");
2052                         Assert.AreEqual (1, dt_unspecified.Ticks, "#6");
2053                 }
2054
2055                 [Test]
2056                 public void TestMin ()
2057                 {
2058                         // This should never throw.
2059                         DateTime.MinValue.ToLocalTime ();
2060                 }
2061
2062                 [Test]
2063                 public void OmittedSecondsFraction ()
2064                 {
2065                         DateTime today = DateTime.Today;
2066                         Assert.AreEqual ("00:00:00.13579", today.AddTicks (1357900).ToString ("HH:mm:ss.FFFFFFF"), "#1");
2067                         DateTime dt = DateTime.ParseExact ("00:00:00.13579", "HH:mm:ss.FFFFFFF", CultureInfo.InvariantCulture);
2068                         Assert.AreEqual (today, dt.AddTicks (-1357900), "#2");
2069                         // it's more than strange ...
2070                         Assert.AreEqual (String.Empty, today.ToString (".FFFFFFF"), "#3");
2071                         Assert.AreEqual ("$", today.ToString ("$FFFFFFF"), "#4");
2072                 }
2073
2074                 [Test]
2075                 public void KindInPattern ()
2076                 {
2077                         // only 2.0 supports 'K'
2078                         Assert.AreEqual ("00:00:00", new DateTime (2000, 1, 1).ToString ("HH:mm:ssK"), "#1");
2079                         Assert.AreEqual ('Z', DateTime.Today.ToUniversalTime ().ToString ("HH:mm:ssK") [8], "#2");
2080                         Assert.AreEqual ("00:00:00+09:00".Length, DateTime.Today.ToString ("HH:mm:ssK").Length, "#3");
2081                 }
2082
2083                 [Test]
2084                 public void RoundtripPattern ()
2085                 {
2086                         // only 2.0 supports 'o'
2087                         Assert.AreEqual ("2000-01-01T00:00:00.0000000", new DateTime (2000, 1, 1).ToString ("o"), "#1");
2088                         Assert.AreEqual ("2000-01-01T00:00:00.0000000Z", DateTime.SpecifyKind (new DateTime (2000, 1, 1), DateTimeKind.Utc).ToString ("o"), "#2");
2089                         Assert.AreEqual ("2000-01-01T00:00:00.0000000+09:00".Length, DateTime.SpecifyKind (
2090                                 new DateTime (2000, 1, 1), DateTimeKind.Local).ToString ("o").Length, "#3");
2091                 }
2092 #endif
2093         }
2094 }