-//\r
-// DateTimeTest.cs - NUnit Test Cases for the System.DateTime struct\r
-//\r
-// author:\r
-// Martin Baulig (martin@gnome.org)\r
-//\r
-// (C) 2002 Free Software Foundation\r
-// Copyright (C) 2004 Novell (http://www.novell.com)\r
-//\r
-\r
-using NUnit.Framework;\r
-using System;\r
-using System.IO;\r
-using System.Threading;\r
-using System.Globalization;\r
-\r
-namespace MonoTests.System\r
-{\r
-\r
-[TestFixture]\r
-public class DateTimeTest : Assertion\r
-{\r
- [Flags]\r
- internal enum Resolution : ushort {\r
- Year = 64,\r
- Month = 96,\r
- Day = 112,\r
- Hour = 120,\r
- Minute = 124,\r
- Second = 126,\r
- Millisecond = 127,\r
- _Month = 32,\r
- _Day = 16,\r
- _Hour = 8,\r
- _Minute = 4,\r
- _Second = 2,\r
- _Millisecond = 1\r
- }\r
- \r
- internal void DTAssertEquals (DateTime actual, DateTime expected, Resolution resolution) {\r
- DTAssertEquals ("", actual, expected, resolution);\r
- }\r
-\r
- internal void DTAssertEquals (string message, DateTime expected, DateTime actual, Resolution resolution) {\r
- if ((resolution & Resolution.Year) != 0)\r
- AssertEquals (message, expected.Year, actual.Year);\r
- if ((resolution & Resolution._Month) != 0)\r
- AssertEquals (message, expected.Month, actual.Month);\r
- if ((resolution & Resolution._Day) != 0)\r
- AssertEquals (message, expected.Day, actual.Day);\r
- if ((resolution & Resolution._Hour) != 0)\r
- AssertEquals (message, expected.Hour, actual.Hour);\r
- if ((resolution & Resolution._Minute) != 0)\r
- AssertEquals (message, expected.Minute, actual.Minute);\r
- if ((resolution & Resolution._Second) != 0)\r
- AssertEquals (message, expected.Second, actual.Second);\r
- if ((resolution & Resolution._Millisecond) != 0)\r
- AssertEquals (message, expected.Millisecond, actual.Millisecond);\r
- }\r
-\r
- private CultureInfo oldcult;\r
- \r
- long[] myTicks = {\r
- 631501920000000000L, // 25 Feb 2002 - 00:00:00\r
- 631502475130080000L, // 25 Feb 2002 - 15:25:13,8\r
- 631502115130080000L, // 25 Feb 2002 - 05:25:13,8\r
- 631502115000000000L, // 25 Feb 2002 - 05:25:00\r
- 631502115130000000L, // 25 Feb 2002 - 05:25:13\r
- 631502079130000000L, // 25 Feb 2002 - 04:25:13\r
- 629197085770000000L // 06 Nov 1994 - 08:49:37 \r
- };\r
-\r
- public DateTimeTest() {}\r
-\r
- [SetUp]\r
- public void SetUp() \r
- {\r
- // the current culture determines the result of formatting\r
- oldcult = Thread.CurrentThread.CurrentCulture;\r
- Thread.CurrentThread.CurrentCulture = new CultureInfo ("");\r
- }\r
- \r
- [TearDown]\r
- public void TearDown ()\r
- {\r
- Thread.CurrentThread.CurrentCulture = oldcult; \r
- }\r
- \r
- public void TestCtors ()\r
- {\r
- DateTime t1 = new DateTime (2002,2,25);\r
- AssertEquals("A01", myTicks[0], t1.Ticks);\r
- DateTime t2 = new DateTime (2002,2,25,15,25,13,8);\r
- AssertEquals("A02", myTicks[1], t2.Ticks);\r
- AssertEquals("A03", myTicks[0], t2.Date.Ticks);\r
- AssertEquals("A04", 2002, t2.Year);\r
- AssertEquals("A05", 2, t2.Month);\r
- AssertEquals("A06", 25, t2.Day);\r
- AssertEquals("A07", 15, t2.Hour);\r
- AssertEquals("A08", 25, t2.Minute);\r
- AssertEquals("A09", 13, t2.Second);\r
- AssertEquals("A10", 8, t2.Millisecond);\r
- DateTime t3 = new DateTime (2002,2,25,5,25,13,8);\r
- AssertEquals("A11", myTicks[2], t3.Ticks);\r
- }\r
-\r
- [Test]\r
- public void Constructor_Max () \r
- {\r
- AssertEquals ("Max", 3155378975999990000, new DateTime (9999, 12, 31, 23, 59, 59, 999).Ticks);\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (ArgumentOutOfRangeException))]\r
- public void Constructor_Milliseconds_Negative () \r
- {\r
- new DateTime (9999, 12, 31, 23, 59, 59, -1);\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (ArgumentOutOfRangeException))]\r
- public void Constructor_Milliseconds_1000 () \r
- {\r
- new DateTime (9999, 12, 31, 23, 59, 59, 1000);\r
- }\r
- \r
- [Test]\r
- public void Fields ()\r
- {\r
- AssertEquals ("J01", 3155378975999999999L, DateTime.MaxValue.Ticks); \r
- AssertEquals ("J02", 0, DateTime.MinValue.Ticks);\r
- }\r
- \r
- [Test]\r
- public void Add ()\r
- {\r
- DateTime t1 = new DateTime (myTicks [1]);\r
- TimeSpan span = new TimeSpan (3, 54, 1);\r
- DateTime t2 = t1.Add (span);\r
- \r
- AssertEquals ("K01", 25, t2.Day);\r
- AssertEquals ("K02", 19, t2.Hour);\r
- AssertEquals ("K03", 19, t2.Minute);\r
- AssertEquals ("K04", 14, t2.Second);\r
- \r
- AssertEquals ("K05", 25, t1.Day);\r
- AssertEquals ("K06", 15, t1.Hour);\r
- AssertEquals ("K07", 25, t1.Minute);\r
- AssertEquals ("K08", 13, t1.Second); \r
- }\r
- \r
- [Test]\r
- [ExpectedException(typeof (ArgumentOutOfRangeException))]\r
- public void AddOutOfRangeException1 ()\r
- {\r
- DateTime t1 = new DateTime (myTicks [1]);\r
- t1.Add (TimeSpan.MaxValue);\r
- }\r
-\r
- [Test]\r
- [ExpectedException(typeof (ArgumentOutOfRangeException))]\r
- public void AddOutOfRangeException2 ()\r
- {\r
- DateTime t1 = new DateTime (myTicks [1]);\r
- t1.Add (TimeSpan.MinValue);\r
- }\r
- \r
- [Test]\r
- public void AddDays ()\r
- {\r
- DateTime t1 = new DateTime (myTicks [1]);\r
- t1 = t1.AddDays (3);\r
- AssertEquals ("L01", 28, t1.Day);\r
- AssertEquals ("L02", 15, t1.Hour);\r
- AssertEquals ("L03", 25, t1.Minute);\r
- AssertEquals ("L04", 13, t1.Second); \r
- \r
- t1 = t1.AddDays (1.9);\r
- AssertEquals ("L05", 2, t1.Day);\r
- AssertEquals ("L06", 13, t1.Hour);\r
- AssertEquals ("L07", 1, t1.Minute);\r
- AssertEquals ("L08", 13, t1.Second); \r
-\r
- t1 = t1.AddDays (0.2);\r
- AssertEquals ("L09", 2, t1.Day);\r
- AssertEquals ("L10", 17, t1.Hour);\r
- AssertEquals ("L11", 49, t1.Minute);\r
- AssertEquals ("L12", 13, t1.Second); \r
- }\r
- \r
- [Test]\r
- [ExpectedException(typeof (ArgumentOutOfRangeException))]\r
- public void AddDaysOutOfRangeException1 ()\r
- {\r
- DateTime t1 = new DateTime (myTicks [1]);\r
- t1.AddDays (10000000);\r
- }\r
-\r
- [Test]\r
- [ExpectedException(typeof (ArgumentOutOfRangeException))]\r
- public void AddDaysOutOfRangeException2 ()\r
- {\r
- DateTime t1 = new DateTime (myTicks [1]);\r
- t1.AddDays (-10000000);\r
- }\r
-\r
- [Test]\r
- public void AddHours ()\r
- {\r
- DateTime t1 = new DateTime (myTicks [1]);\r
- t1 = t1.AddHours (10);\r
- AssertEquals ("N01", 26, t1.Day);\r
- AssertEquals ("N02", 1, t1.Hour);\r
- AssertEquals ("N03", 25, t1.Minute);\r
- AssertEquals ("N04", 13, t1.Second); \r
- \r
- t1 = t1.AddHours (-3.7);\r
- AssertEquals ("N05", 25, t1.Day);\r
- AssertEquals ("N06", 21, t1.Hour);\r
- AssertEquals ("N07", 43, t1.Minute);\r
- AssertEquals ("N08", 13, t1.Second); \r
-\r
- t1 = t1.AddHours (3.732);\r
- AssertEquals ("N09", 26, t1.Day);\r
- AssertEquals ("N10", 1, t1.Hour);\r
- AssertEquals ("N11", 27, t1.Minute);\r
- AssertEquals ("N12", 8, t1.Second); \r
- }\r
- \r
- [Test]\r
- [ExpectedException (typeof (ArgumentOutOfRangeException))]\r
- public void AddHoursOutOfRangeException1 ()\r
- {\r
- DateTime t1 = new DateTime (myTicks [1]);\r
- t1.AddHours (9E100);\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (ArgumentOutOfRangeException))]\r
- public void AddHoursOutOfRangeException2 ()\r
- {\r
- DateTime t1 = new DateTime (myTicks [1]);\r
- t1.AddHours (-9E100);\r
- }\r
- \r
- [Test]\r
- public void AddMilliseconds ()\r
- {\r
- DateTime t1 = new DateTime (myTicks [1]);\r
- t1 = t1.AddMilliseconds (1E10);\r
- AssertEquals ("O01", 21, t1.Day);\r
- AssertEquals ("O02", 9, t1.Hour);\r
- AssertEquals ("O03", 11, t1.Minute);\r
- AssertEquals ("O04", 53, t1.Second); \r
- \r
- t1 = t1.AddMilliseconds (-19E10);\r
- AssertEquals ("O05", 13, t1.Day);\r
- AssertEquals ("O06", 7, t1.Hour);\r
- AssertEquals ("O07", 25, t1.Minute);\r
- AssertEquals ("O08", 13, t1.Second); \r
-\r
- t1 = t1.AddMilliseconds (15.623);\r
- AssertEquals ("O09", 13, t1.Day);\r
- AssertEquals ("O10", 7, t1.Hour);\r
- AssertEquals ("O11", 25, t1.Minute);\r
- AssertEquals ("O12", 13, t1.Second); \r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (ArgumentOutOfRangeException))]\r
- public void AddMillisecondsOutOfRangeException1 ()\r
- {\r
- DateTime t1 = new DateTime (myTicks [1]);\r
- t1.AddMilliseconds (9E100);\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (ArgumentOutOfRangeException))]\r
- public void AddMillisecondsOutOfRangeException2 ()\r
- {\r
- DateTime t1 = new DateTime (myTicks [1]);\r
- t1.AddMilliseconds (-9E100);\r
- }\r
-\r
-\r
- public void TestToString ()\r
- {\r
- DateTime t1 = new DateTime (myTicks[2]);\r
- DateTime t2 = new DateTime (myTicks[1]);\r
- // Standard patterns\r
- AssertEquals("B01", "02/25/2002", t1.ToString ("d"));\r
- AssertEquals("B02", "Monday, 25 February 2002", t1.ToString ("D"));\r
- AssertEquals("B03", "Monday, 25 February 2002 05:25", t1.ToString ("f"));\r
- AssertEquals("B04", "Monday, 25 February 2002 05:25:13", t1.ToString ("F"));\r
- AssertEquals("B05", "02/25/2002 05:25", t1.ToString ("g"));\r
- AssertEquals("B06", "02/25/2002 05:25:13", t1.ToString ("G"));\r
- AssertEquals("B07", "February 25", t1.ToString ("m"));\r
- AssertEquals("B08", "February 25", t1.ToString ("M"));\r
- AssertEquals("B09", "Mon, 25 Feb 2002 05:25:13 GMT", t1.ToString ("r"));\r
- AssertEquals("B10", "Mon, 25 Feb 2002 05:25:13 GMT", t1.ToString ("R"));\r
- AssertEquals("B11", "2002-02-25T05:25:13", t1.ToString ("s"));\r
- AssertEquals("B12", "05:25", t1.ToString ("t"));\r
- AssertEquals("B13", "05:25:13", t1.ToString ("T"));\r
- //AssertEquals("B14", "2002-02-25 05:25:13Z", t1.ToString ("u"));\r
- //AssertEquals("B15", "Sunday, 24 February 2002 11:25:13", t1.ToString ("U"));\r
- AssertEquals("B16", "2002 February", t1.ToString ("y"));\r
- AssertEquals("B17", "2002 February", t1.ToString ("Y"));\r
-\r
- // Custom patterns\r
- AssertEquals("C01", "25", t1.ToString ("%d"));\r
- AssertEquals("C02", "25", t1.ToString ("dd"));\r
- AssertEquals("C03", "Mon", t1.ToString ("ddd"));\r
- AssertEquals("C04", "Monday", t1.ToString ("dddd"));\r
- AssertEquals("C05", "2", t1.ToString ("%M"));\r
- AssertEquals("C06", "02", t1.ToString ("MM"));\r
- AssertEquals("C07", "Feb", t1.ToString ("MMM"));\r
- AssertEquals("C08", "February", t1.ToString ("MMMM"));\r
- AssertEquals("C09", "2", t1.ToString ("%y"));\r
- AssertEquals("C10", "02", t1.ToString ("yy"));\r
- AssertEquals("C11", "2002", t1.ToString ("yyyy"));\r
- AssertEquals("C12", "5", t1.ToString ("%h"));\r
- AssertEquals("C13", "05", t1.ToString ("hh"));\r
- AssertEquals("C14", "3", t2.ToString ("%h"));\r
- AssertEquals("C15", "03", t2.ToString ("hh"));\r
- AssertEquals("C16", "15", t2.ToString ("%H"));\r
- AssertEquals("C17", "15", t2.ToString ("HH"));\r
- AssertEquals("C18", "25", t2.ToString ("%m"));\r
- AssertEquals("C19", "25", t2.ToString ("mm"));\r
- AssertEquals("C20", "13", t2.ToString ("%s"));\r
- AssertEquals("C21", "13", t2.ToString ("ss"));\r
- AssertEquals("C22", "A", t1.ToString ("%t"));\r
- AssertEquals("C23", "P", t2.ToString ("%t"));\r
- AssertEquals("C24", "AM", t1.ToString ("tt"));\r
- AssertEquals("C25", "PM", t2.ToString ("tt"));\r
- long offset = TimeZone.CurrentTimeZone.GetUtcOffset(t1).Ticks / 36000000000;\r
- AssertEquals("C26", offset.ToString("+#;-#;0"), t1.ToString ("%z"));\r
- AssertEquals("C27", offset.ToString("+00;-00;00"), t1.ToString ("zz"));
- // This does not work in, eg banglore, because their timezone has an offset of
- // +05:30\r
- //AssertEquals("C28", offset.ToString("+00;-00;00") + ":00", t1.ToString ("zzz"));\r
- AssertEquals("C29", " : ", t1.ToString (" : "));\r
- AssertEquals("C30", " / ", t1.ToString (" / "));\r
- AssertEquals("C31", " yyy ", t1.ToString (" 'yyy' "));\r
- AssertEquals("C32", " d", t1.ToString (" \\d"));\r
- }\r
-\r
- [Ignore ("need a better way to handle these tests with them running on different timezones")]\r
- public void TestParseExact2 () \r
- {\r
- DateTime t1 = DateTime.ParseExact ("2002-02-25 04:25:13Z", "u", null);\r
- t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1);\r
- AssertEquals ("D07d", 04 + TimeZone.CurrentTimeZone.GetUtcOffset(t1).Hours, t1.Hour);\r
-\r
- }\r
-
- [Category ("NotWorking")]
- public void TestParseExact3 ()
+//
+// DateTimeTest.cs - NUnit Test Cases for the System.DateTime struct
+//
+// author:
+// Martin Baulig (martin@gnome.org)
+//
+// (C) 2002 Free Software Foundation
+// Copyright (C) 2004 Novell (http://www.novell.com)
+//
+
+using System;
+using System.IO;
+using System.Threading;
+using System.Globalization;
+
+using NUnit.Framework;
+
+namespace MonoTests.System
+{
+ [TestFixture]
+ public class DateTimeTest
{
- DateTime t1 = DateTime.ParseExact ("2002-02-25 04:25:13Z", "u", null);\r
- AssertEquals ("D07a", 2002, t1.Year);\r
- AssertEquals ("D07b", 02, t1.Month);\r
- AssertEquals ("D07c", 25, t1.Day);\r
- AssertEquals ("D07e", 25, t1.Minute);\r
- AssertEquals ("D07f", 13, t1.Second);\r
- }
+ [Flags]
+ internal enum Resolution : ushort
+ {
+ Year = 64,
+ Month = 96,
+ Day = 112,
+ Hour = 120,
+ Minute = 124,
+ Second = 126,
+ Millisecond = 127,
+ _Month = 32,
+ _Day = 16,
+ _Hour = 8,
+ _Minute = 4,
+ _Second = 2,
+ _Millisecond = 1
+ }
+
+ internal void DTAssertEquals (DateTime actual, DateTime expected, Resolution resolution)
+ {
+ DTAssertEquals (actual, expected, resolution, "");
+ }
+
+ internal void DTAssertEquals (DateTime expected, DateTime actual, Resolution resolution, string message)
+ {
+ if ((resolution & Resolution.Year) != 0)
+ Assert.AreEqual (expected.Year, actual.Year, message);
+ if ((resolution & Resolution._Month) != 0)
+ Assert.AreEqual (expected.Month, actual.Month, message);
+ if ((resolution & Resolution._Day) != 0)
+ Assert.AreEqual (expected.Day, actual.Day, message);
+ if ((resolution & Resolution._Hour) != 0)
+ Assert.AreEqual (expected.Hour, actual.Hour, message);
+ if ((resolution & Resolution._Minute) != 0)
+ Assert.AreEqual (expected.Minute, actual.Minute, message);
+ if ((resolution & Resolution._Second) != 0)
+ Assert.AreEqual (expected.Second, actual.Second, message);
+ if ((resolution & Resolution._Millisecond) != 0)
+ Assert.AreEqual (expected.Millisecond, actual.Millisecond, message);
+ }
+
+ private CultureInfo oldcult;
- \r
- public void TestParseExact ()\r
- {\r
- // Standard patterns\r
- DateTime t1 = DateTime.ParseExact ("02/25/2002", "d", null);\r
- AssertEquals ("D01", myTicks[0], t1.Ticks);\r
- t1 = DateTime.ParseExact ("Monday, 25 February 2002", "D", null);\r
- AssertEquals ("D02", myTicks[0], t1.Ticks);\r
- t1 = DateTime.ParseExact ("Monday, 25 February 2002 05:25", "f", null);\r
- AssertEquals ("D03", myTicks[3], t1.Ticks);\r
- t1 = DateTime.ParseExact ("Monday, 25 February 2002 05:25:13", "F", null);\r
- AssertEquals ("D04", myTicks[4], t1.Ticks);\r
- t1 = DateTime.ParseExact ("02/25/2002 05:25", "g", null);\r
- AssertEquals ("D05", myTicks[3], t1.Ticks);\r
- t1 = DateTime.ParseExact ("02/25/2002 05:25:13", "G", null);\r
- AssertEquals ("D06", myTicks[4], t1.Ticks);\r
- t1 = DateTime.ParseExact ("Monday, 25 February 2002 04:25:13", "U", null);\r
- t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1);\r
- AssertEquals ("D08a", 2002, t1.Year);\r
- AssertEquals ("D08b", 02, t1.Month);\r
- AssertEquals ("D08c", 25, t1.Day);\r
- AssertEquals ("D08d", 04, t1.Hour);\r
- AssertEquals ("D08e", 25, t1.Minute);\r
- AssertEquals ("D08f", 13, t1.Second);\r
-\r
- DateTime t2 = new DateTime (DateTime.Today.Year, 2, 25);\r
- t1 = DateTime.ParseExact ("February 25", "m", null);\r
- AssertEquals ("D09", t2.Ticks, t1.Ticks);\r
-\r
- t2 = new DateTime (DateTime.Today.Year, 2, 25);\r
- t1 = DateTime.ParseExact ("February 25", "M", null);\r
- AssertEquals ("D10", t2.Ticks, t1.Ticks);\r
-\r
- t1 = DateTime.ParseExact ("Mon, 25 Feb 2002 04:25:13 GMT", "r", null);\r
- AssertEquals ("D11a", 2002, t1.Year);\r
- AssertEquals ("D11b", 02, t1.Month);\r
- AssertEquals ("D11c", 25, t1.Day);\r
- AssertEquals ("D11d", 04, t1.Hour);\r
- AssertEquals ("D11e", 25, t1.Minute);\r
- AssertEquals ("D11f", 13, t1.Second);\r
-\r
- t1 = DateTime.ParseExact ("Mon, 25 Feb 2002 04:25:13 GMT", "R", null);\r
- AssertEquals ("D12a", 2002, t1.Year);\r
- AssertEquals ("D12b", 02, t1.Month);\r
- AssertEquals ("D12c", 25, t1.Day);\r
- AssertEquals ("D12d", 04, t1.Hour);\r
- AssertEquals ("D12e", 25, t1.Minute);\r
- AssertEquals ("D12f", 13, t1.Second);\r
-\r
- t1 = DateTime.ParseExact ("2002-02-25T05:25:13", "s", null);\r
- AssertEquals ("D13", myTicks[4], t1.Ticks);\r
-\r
- t2 = DateTime.Today + new TimeSpan (5,25,0);\r
- t1 = DateTime.ParseExact ("05:25", "t", null);\r
- AssertEquals("D14", t2.Ticks, t1.Ticks);\r
-\r
- t2 = DateTime.Today + new TimeSpan (5,25,13);\r
- t1 = DateTime.ParseExact ("05:25:13", "T", null);\r
- AssertEquals("D15", t2.Ticks, t1.Ticks);\r
-\r
- t2 = new DateTime (2002, 2, 1);\r
- t1 = DateTime.ParseExact ("2002 February", "y", null);\r
- AssertEquals ("D16", t2.Ticks, t1.Ticks);\r
-\r
- t2 = new DateTime (2002, 2, 1);\r
- t1 = DateTime.ParseExact ("2002 February", "Y", null);\r
- AssertEquals ("D16", t2.Ticks, t1.Ticks);\r
-\r
- // Custom patterns\r
- t2 = new DateTime (DateTime.Now.Year, 1, 25);\r
- t1 = DateTime.ParseExact ("25", "%d", null);\r
- AssertEquals ("E01: " + t2 + " -- " + t1, t2.Ticks, t1.Ticks);\r
- t1 = DateTime.ParseExact ("25", "dd", null);\r
- AssertEquals ("E02", t2.Ticks, t1.Ticks);\r
-\r
- t2 = new DateTime (DateTime.Today.Year, 2, 1);\r
- t1 = DateTime.ParseExact ("2", "%M", null);\r
- AssertEquals ("E03", t2.Ticks, t1.Ticks);\r
- t1 = DateTime.ParseExact ("02", "MM", null);\r
- AssertEquals ("E04", t2.Ticks, t1.Ticks);\r
- t1 = DateTime.ParseExact ("Feb", "MMM", null);\r
- AssertEquals ("E05", t2.Ticks, t1.Ticks);\r
- t1 = DateTime.ParseExact ("February", "MMMM", null);\r
- AssertEquals ("E06", t2.Ticks, t1.Ticks);\r
-\r
- t2 = new DateTime (2005, 1, 1);\r
- t1 = DateTime.ParseExact ("5", "%y", null);\r
- AssertEquals ("E07", t2.Ticks, t1.Ticks);\r
- t1 = DateTime.ParseExact ("05", "yy", null);\r
- AssertEquals ("E08", t2.Ticks, t1.Ticks);\r
- t1 = DateTime.ParseExact ("2005", "yyyy", null);\r
- AssertEquals ("E09", t2.Ticks, t1.Ticks);\r
-\r
- t2 = DateTime.Today + new TimeSpan (5, 0, 0);\r
- t1 = DateTime.ParseExact ("5A", "ht", null);\r
- AssertEquals ("E10", t2.Ticks, t1.Ticks);\r
- t1 = DateTime.ParseExact ("05A", "hht", null);\r
- AssertEquals ("E11", t2.Ticks, t1.Ticks);\r
-\r
- t2 = DateTime.Today + new TimeSpan (15, 0, 0);\r
- t1 = DateTime.ParseExact ("3P", "ht", null);\r
- AssertEquals ("E12", t2.Ticks, t1.Ticks);\r
- t1 = DateTime.ParseExact ("03P", "hht", null);\r
- AssertEquals ("E13", t2.Ticks, t1.Ticks);\r
-\r
- t2 = DateTime.Today + new TimeSpan (5, 0, 0);\r
- t1 = DateTime.ParseExact ("5", "%H", null);\r
- AssertEquals ("E14", t2.Ticks, t1.Ticks);\r
-\r
- t2 = DateTime.Today + new TimeSpan (15, 0, 0);\r
- t1 = DateTime.ParseExact ("15", "%H", null);\r
- AssertEquals ("E15", t2.Ticks, t1.Ticks);\r
- t1 = DateTime.ParseExact ("15", "HH", null);\r
- AssertEquals ("E16", t2.Ticks, t1.Ticks);\r
-\r
- // Time zones
+ long[] myTicks = {
+ 631501920000000000L, // 25 Feb 2002 - 00:00:00
+ 631502475130080000L, // 25 Feb 2002 - 15:25:13,8
+ 631502115130080000L, // 25 Feb 2002 - 05:25:13,8
+ 631502115000000000L, // 25 Feb 2002 - 05:25:00
+ 631502115130000000L, // 25 Feb 2002 - 05:25:13
+ 631502079130000000L, // 25 Feb 2002 - 04:25:13
+ 629197085770000000L, // 06 Nov 1994 - 08:49:37
+ 631796544000000000L, // 01 Feb 2003 - 00:00:00
+ };
+
+ [SetUp]
+ public void SetUp()
+ {
+ // the current culture determines the result of formatting
+ oldcult = Thread.CurrentThread.CurrentCulture;
+ Thread.CurrentThread.CurrentCulture = new CultureInfo ("");
+ }
+
+ [TearDown]
+ public void TearDown ()
+ {
+ Thread.CurrentThread.CurrentCulture = oldcult;
+ }
+
+ [Test]
+ public void TestCtors ()
+ {
+ DateTime t1 = new DateTime (2002,2,25);
+ Assert.AreEqual (myTicks [0], t1.Ticks, "A01");
+ DateTime t2 = new DateTime (2002,2,25,15,25,13,8);
+ Assert.AreEqual (myTicks [1], t2.Ticks, "A02");
+ Assert.AreEqual (myTicks [0], t2.Date.Ticks, "A03");
+ Assert.AreEqual (2002, t2.Year, "A04");
+ Assert.AreEqual (2, t2.Month, "A05");
+ Assert.AreEqual (25, t2.Day, "A06");
+ Assert.AreEqual (15, t2.Hour, "A07");
+ Assert.AreEqual (25, t2.Minute, "A08");
+ Assert.AreEqual (13, t2.Second, "A09");
+ Assert.AreEqual (8, t2.Millisecond, "A10");
+ DateTime t3 = new DateTime (2002,2,25,5,25,13,8);
+ Assert.AreEqual (myTicks [2], t3.Ticks, "A11");
+ }
+
+ [Test]
+ public void Constructor_Max ()
+ {
+ Assert.AreEqual (3155378975999990000, new DateTime (9999, 12, 31, 23, 59, 59, 999).Ticks, "Max");
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentOutOfRangeException))]
+ public void Constructor_Milliseconds_Negative ()
+ {
+ new DateTime (9999, 12, 31, 23, 59, 59, -1);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentOutOfRangeException))]
+ public void Constructor_Milliseconds_1000 ()
+ {
+ new DateTime (9999, 12, 31, 23, 59, 59, 1000);
+ }
+
+ [Test]
+ public void Fields ()
+ {
+ Assert.AreEqual (3155378975999999999L, DateTime.MaxValue.Ticks, "#1");
+ Assert.AreEqual (0, DateTime.MinValue.Ticks, "#2");
+ }
+
+ [Test]
+ public void Add ()
+ {
+ DateTime t1 = new DateTime (myTicks [1]);
+ TimeSpan span = new TimeSpan (3, 54, 1);
+ DateTime t2 = t1.Add (span);
+
+ Assert.AreEqual (25, t2.Day, "#1");
+ Assert.AreEqual (19, t2.Hour, "#2");
+ Assert.AreEqual (19, t2.Minute, "#3");
+ Assert.AreEqual (14, t2.Second, "#4");
+
+ Assert.AreEqual (25, t1.Day, "#5");
+ Assert.AreEqual (15, t1.Hour, "#6");
+ Assert.AreEqual (25, t1.Minute, "#7");
+ Assert.AreEqual (13, t1.Second, "#8");
+ }
+
+ [Test]
+ [ExpectedException(typeof (ArgumentOutOfRangeException))]
+ public void AddOutOfRangeException1 ()
+ {
+ DateTime t1 = new DateTime (myTicks [1]);
+ t1.Add (TimeSpan.MaxValue);
+ }
+
+ [Test]
+ [ExpectedException(typeof (ArgumentOutOfRangeException))]
+ public void AddOutOfRangeException2 ()
+ {
+ DateTime t1 = new DateTime (myTicks [1]);
+ t1.Add (TimeSpan.MinValue);
+ }
+
+ [Test]
+ public void AddDays ()
+ {
+ DateTime t1 = new DateTime (myTicks [1]);
+ t1 = t1.AddDays (3);
+ Assert.AreEqual (28, t1.Day, "#A1");
+ Assert.AreEqual (15, t1.Hour, "#A2");
+ Assert.AreEqual (25, t1.Minute, "#A3");
+ Assert.AreEqual (13, t1.Second, "#A4");
+
+ t1 = t1.AddDays (1.9);
+ Assert.AreEqual (2, t1.Day, "#B1");
+ Assert.AreEqual (13, t1.Hour, "#B2");
+ Assert.AreEqual (1, t1.Minute, "#B3");
+ Assert.AreEqual (13, t1.Second, "#B4");
+
+ t1 = t1.AddDays (0.2);
+ Assert.AreEqual (2, t1.Day, "#C1");
+ Assert.AreEqual (17, t1.Hour, "#C2");
+ Assert.AreEqual (49, t1.Minute, "#C3");
+ Assert.AreEqual (13, t1.Second, "#C4");
+ }
+
+ [Test]
+ [ExpectedException(typeof (ArgumentOutOfRangeException))]
+ public void AddDaysOutOfRangeException1 ()
+ {
+ DateTime t1 = new DateTime (myTicks [1]);
+ t1.AddDays (10000000);
+ }
+
+ [Test]
+ [ExpectedException(typeof (ArgumentOutOfRangeException))]
+ public void AddDaysOutOfRangeException2 ()
+ {
+ DateTime t1 = new DateTime (myTicks [1]);
+ t1.AddDays (-10000000);
+ }
+
+ [Test]
+ public void AddHours ()
+ {
+ DateTime t1 = new DateTime (myTicks [1]);
+ t1 = t1.AddHours (10);
+ Assert.AreEqual (26, t1.Day, "#A1");
+ Assert.AreEqual (1, t1.Hour, "#A2");
+ Assert.AreEqual (25, t1.Minute, "#A3");
+ Assert.AreEqual (13, t1.Second, "#A4");
+
+ t1 = t1.AddHours (-3.7);
+ Assert.AreEqual (25, t1.Day, "#B1");
+ Assert.AreEqual (21, t1.Hour, "#B2");
+ Assert.AreEqual (43, t1.Minute, "#B3");
+ Assert.AreEqual (13, t1.Second, "#B4");
+
+ t1 = t1.AddHours (3.732);
+ Assert.AreEqual (26, t1.Day, "#C1");
+ Assert.AreEqual (1, t1.Hour, "#C2");
+ Assert.AreEqual (27, t1.Minute, "#C3");
+ Assert.AreEqual (8, t1.Second, "#C4");
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentOutOfRangeException))]
+ public void AddHoursOutOfRangeException1 ()
+ {
+ DateTime t1 = new DateTime (myTicks [1]);
+ t1.AddHours (9E100);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentOutOfRangeException))]
+ public void AddHoursOutOfRangeException2 ()
+ {
+ DateTime t1 = new DateTime (myTicks [1]);
+ t1.AddHours (-9E100);
+ }
+
+ [Test]
+ public void AddMilliseconds ()
+ {
+ DateTime t1 = new DateTime (myTicks [1]);
+ t1 = t1.AddMilliseconds (1E10);
+ Assert.AreEqual (21, t1.Day, "#A1");
+ Assert.AreEqual (9, t1.Hour, "#A2");
+ Assert.AreEqual (11, t1.Minute, "#A3");
+ Assert.AreEqual (53, t1.Second, "#A4");
+
+ t1 = t1.AddMilliseconds (-19E10);
+ Assert.AreEqual (13, t1.Day, "#B1");
+ Assert.AreEqual (7, t1.Hour, "#B2");
+ Assert.AreEqual (25, t1.Minute, "#B3");
+ Assert.AreEqual (13, t1.Second, "#B4");
+
+ t1 = t1.AddMilliseconds (15.623);
+ Assert.AreEqual (13, t1.Day, "#C1");
+ Assert.AreEqual (7, t1.Hour, "#C2");
+ Assert.AreEqual (25, t1.Minute, "#C3");
+ Assert.AreEqual (13, t1.Second, "#C4");
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentOutOfRangeException))]
+ public void AddMillisecondsOutOfRangeException1 ()
+ {
+ DateTime t1 = new DateTime (myTicks [1]);
+ t1.AddMilliseconds (9E100);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentOutOfRangeException))]
+ public void AddMillisecondsOutOfRangeException2 ()
+ {
+ DateTime t1 = new DateTime (myTicks [1]);
+ t1.AddMilliseconds (-9E100);
+ }
+
+ [Test]
+ public void TestToString ()
+ {
+ DateTime t1 = new DateTime (myTicks[2]);
+ DateTime t2 = new DateTime (myTicks[1]);
+ DateTime t3 = new DateTime (999, 1, 2, 3, 4, 5);
+ // Standard patterns
+ Assert.AreEqual ("02/25/2002", t1.ToString ("d"), "#A1");
+ Assert.AreEqual ("Monday, 25 February 2002", t1.ToString ("D"), "#A2");
+ Assert.AreEqual ("Monday, 25 February 2002 05:25", t1.ToString ("f"), "#A3");
+ Assert.AreEqual ("Monday, 25 February 2002 05:25:13", t1.ToString ("F"), "#A4");
+ Assert.AreEqual ("02/25/2002 05:25", t1.ToString ("g"), "#A5");
+ Assert.AreEqual ("02/25/2002 05:25:13", t1.ToString ("G"), "#A6");
+ Assert.AreEqual ("February 25", t1.ToString ("m"), "#A7");
+ Assert.AreEqual ("February 25", t1.ToString ("M"), "#A8");
+ Assert.AreEqual ("Mon, 25 Feb 2002 05:25:13 GMT", t1.ToString ("r"), "#A9");
+ Assert.AreEqual ("Mon, 25 Feb 2002 05:25:13 GMT", t1.ToString ("R"), "#A10");
+ Assert.AreEqual ("2002-02-25T05:25:13", t1.ToString ("s"), "#A11");
+ Assert.AreEqual ("05:25", t1.ToString ("t"), "#A12");
+ Assert.AreEqual ("05:25:13", t1.ToString ("T"), "#A13");
+ Assert.AreEqual ("2002-02-25 05:25:13Z", t1.ToString ("u"), "#A14");
+ // FIXME: this test is timezone dependent
+ // Assert.AreEqual ("Sunday, 24 February 2002 11:25:13", t1.ToString ("U"), "#A15");
+ Assert.AreEqual ("2002 February", t1.ToString ("y"), "#A16");
+ Assert.AreEqual ("2002 February", t1.ToString ("Y"), "#A17");
+ Assert.AreEqual ("02/25/2002 05:25:13", t1.ToString (""), "#A18");
+
+ // Custom patterns
+ Assert.AreEqual ("25", t1.ToString ("%d"), "#B1");
+ Assert.AreEqual ("25", t1.ToString ("dd"), "#B2");
+ Assert.AreEqual ("Mon", t1.ToString ("ddd"), "#B3");
+ Assert.AreEqual ("Monday", t1.ToString ("dddd"), "#B4");
+ Assert.AreEqual ("2", t1.ToString ("%M"), "#B5");
+ Assert.AreEqual ("02", t1.ToString ("MM"), "#B6");
+ Assert.AreEqual ("Feb", t1.ToString ("MMM"), "#B7");
+ Assert.AreEqual ("February", t1.ToString ("MMMM"), "#B8");
+ Assert.AreEqual ("2", t1.ToString ("%y"), "#B9");
+ Assert.AreEqual ("02", t1.ToString ("yy"), "#B10");
+ Assert.AreEqual ("2002", t1.ToString ("yyyy"), "#B11");
+ Assert.AreEqual ("5", t1.ToString ("%h"), "#B12");
+ Assert.AreEqual ("05", t1.ToString ("hh"), "#B13");
+ Assert.AreEqual ("3", t2.ToString ("%h"), "#B14");
+ Assert.AreEqual ("03", t2.ToString ("hh"), "#B15");
+ Assert.AreEqual ("15", t2.ToString ("%H"), "#B16");
+ Assert.AreEqual ("15", t2.ToString ("HH"), "#B17");
+ Assert.AreEqual ("25", t2.ToString ("%m"), "#B18");
+ Assert.AreEqual ("25", t2.ToString ("mm"), "#B19");
+ Assert.AreEqual ("13", t2.ToString ("%s"), "#B20");
+ Assert.AreEqual ("13", t2.ToString ("ss"), "#B21");
+ Assert.AreEqual ("A", t1.ToString ("%t"), "#B22");
+ Assert.AreEqual ("P", t2.ToString ("%t"), "#B23");
+ Assert.AreEqual ("AM", t1.ToString ("tt"), "#B24");
+ Assert.AreEqual ("PM", t2.ToString ("tt"), "#B25");
+ long offset = TimeZone.CurrentTimeZone.GetUtcOffset(t1).Ticks / 36000000000;
+ // Must specify '+0' for GMT
+ Assert.AreEqual (offset.ToString ("+#;-#;+0"), t1.ToString ("%z"), "#B26");
+ Assert.AreEqual (offset.ToString ("+00;-00;+00"), t1.ToString ("zz"), "#B28");
+ // This does not work in, eg banglore, because their timezone has an offset of
+ // +05:30
+ //Assert.AreEqual (offset.ToString("+00;-00;00") + ":00", t1.ToString ("zzz"), "#B28");
+ Assert.AreEqual (" : ", t1.ToString (" : "), "#B29");
+ Assert.AreEqual (" / ", t1.ToString (" / "), "#B30");
+ Assert.AreEqual (" yyy ", t1.ToString (" 'yyy' "), "#B31");
+ Assert.AreEqual (" d", t1.ToString (" \\d"), "#B32");
+ Assert.AreEqual ("2002", t1.ToString ("yyy"), "#B33");
+ Assert.AreEqual ("0002002", t1.ToString ("yyyyyyy"), "#B34");
+ Assert.AreEqual ("999", t3.ToString ("yyy"), "#B33");
+ Assert.AreEqual ("0999", t3.ToString ("yyyy"), "#B33");
+ }
+
+ [Test]
+ public void ParseExact_Format_Empty ()
+ {
+ try {
+ DateTime.ParseExact ("2002-02-25 04:25:13Z", string.Empty, null);
+ Assert.Fail ("#A1");
+ } catch (FormatException ex) {
+ // Format specifier was invalid
+ Assert.AreEqual (typeof (FormatException), ex.GetType (), "#B2");
+ Assert.IsNull (ex.InnerException, "#B3");
+ Assert.IsNotNull (ex.Message, "#B4");
+ }
+
+ try {
+ DateTime.ParseExact ("2002-02-25 04:25:13Z", string.Empty, null,
+ DateTimeStyles.None);
+ Assert.Fail ("#B1");
+ } catch (FormatException ex) {
+ // Format specifier was invalid
+ Assert.AreEqual (typeof (FormatException), ex.GetType (), "#B2");
+ Assert.IsNull (ex.InnerException, "#B3");
+ Assert.IsNotNull (ex.Message, "#B4");
+ }
+ }
+
+ [Test]
+ public void ParseExact_Format_Null ()
+ {
+ try {
+ DateTime.ParseExact ("2002-02-25 04:25:13Z", (string) null, null);
+ Assert.Fail ("#A1");
+ } catch (ArgumentNullException ex) {
+ Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
+ Assert.IsNull (ex.InnerException, "#A3");
+ Assert.IsNotNull (ex.Message, "#A4");
+ Assert.IsNotNull (ex.ParamName, "#A5");
+ Assert.AreEqual ("format", ex.ParamName, "#A6");
+ }
+
+ try {
+ DateTime.ParseExact ("2002-02-25 04:25:13Z", (string) null, null,
+ DateTimeStyles.None);
+ Assert.Fail ("#B1");
+ } catch (ArgumentNullException ex) {
+ Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
+ Assert.IsNull (ex.InnerException, "#B3");
+ Assert.IsNotNull (ex.Message, "#B4");
+ Assert.IsNotNull (ex.ParamName, "#B5");
+ Assert.AreEqual ("format", ex.ParamName, "#B6");
+ }
+ }
+
+ [Test]
+ public void ParseExact_Formats_Empty ()
+ {
+ try {
+ DateTime.ParseExact ("2002-02-25 04:25:13Z", new string [0],
+ null, DateTimeStyles.None);
+ Assert.Fail ("#A1");
+ } catch (FormatException ex) {
+ // Format specifier was invalid
+ Assert.AreEqual (typeof (FormatException), ex.GetType (), "#A2");
+ Assert.IsNull (ex.InnerException, "#A3");
+ Assert.IsNotNull (ex.Message, "#A4");
+ }
+
+ string [] formats = new string [] { "G", string.Empty, "d" };
+ try {
+ DateTime.ParseExact ("2002-02-25 04:25:13Z", formats, null,
+ DateTimeStyles.None);
+ Assert.Fail ("#B1");
+ } catch (FormatException ex) {
+ // Format specifier was invalid
+ Assert.AreEqual (typeof (FormatException), ex.GetType (), "#B2");
+ Assert.IsNull (ex.InnerException, "#B3");
+ Assert.IsNotNull (ex.Message, "#B4");
+ }
+ }
+
+ [Test]
+ public void ParseExact_Formats_Null ()
+ {
+ try {
+ DateTime.ParseExact ("2002-02-25 04:25:13Z", (string []) null,
+ null, DateTimeStyles.None);
+ Assert.Fail ("#A1");
+ } catch (ArgumentNullException ex) {
+ Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
+ Assert.IsNull (ex.InnerException, "#A3");
+ Assert.IsNotNull (ex.Message, "#A4");
+ Assert.IsNotNull (ex.ParamName, "#A5");
+ Assert.AreEqual ("formats", ex.ParamName, "#A6");
+ }
+
+ string [] formats = new string [] { "G", null, "d" };
+ try {
+ DateTime.ParseExact ("2002-02-25 04:25:13Z", formats, null,
+ DateTimeStyles.None);
+ Assert.Fail ("#B1");
+ } catch (FormatException ex) {
+ // Format specifier was invalid
+ Assert.AreEqual (typeof (FormatException), ex.GetType (), "#B2");
+ Assert.IsNull (ex.InnerException, "#B3");
+ Assert.IsNotNull (ex.Message, "#B4");
+ }
+ }
+
+ [Test]
+ public void ParseExact_String_Empty ()
+ {
+ try {
+ DateTime.ParseExact (string.Empty, "G", null);
+ Assert.Fail ("#A1");
+ } catch (FormatException ex) {
+ // Format specifier was invalid
+ Assert.AreEqual (typeof (FormatException), ex.GetType (), "#A2");
+ Assert.IsNull (ex.InnerException, "#A3");
+ Assert.IsNotNull (ex.Message, "#A4");
+ }
+
+ try {
+ DateTime.ParseExact (string.Empty, "G", null, DateTimeStyles.None);
+ Assert.Fail ("#B1");
+ } catch (FormatException ex) {
+ // Format specifier was invalid
+ Assert.AreEqual (typeof (FormatException), ex.GetType (), "#B2");
+ Assert.IsNull (ex.InnerException, "#B3");
+ Assert.IsNotNull (ex.Message, "#B4");
+ }
+
+ try {
+ DateTime.ParseExact (string.Empty, new string [] { "G" }, null,
+ DateTimeStyles.None);
+ Assert.Fail ("#C1");
+ } catch (FormatException ex) {
+ // Format specifier was invalid
+ Assert.AreEqual (typeof (FormatException), ex.GetType (), "#C2");
+ Assert.IsNull (ex.InnerException, "#C3");
+ Assert.IsNotNull (ex.Message, "#C4");
+ }
+ }
+
+ [Test]
+ public void ParseExact_String_Null ()
+ {
+ try {
+ DateTime.ParseExact ((string) null, "G", null);
+ Assert.Fail ("#A1");
+ } catch (ArgumentNullException ex) {
+ Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
+ Assert.IsNull (ex.InnerException, "#A3");
+ Assert.IsNotNull (ex.Message, "#A4");
+ Assert.IsNotNull (ex.ParamName, "#A5");
+ Assert.AreEqual ("s", ex.ParamName, "#A6");
+ }
+
+ try {
+ DateTime.ParseExact ((string) null, "G", null, DateTimeStyles.None);
+ Assert.Fail ("#B1");
+ } catch (ArgumentNullException ex) {
+ Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
+ Assert.IsNull (ex.InnerException, "#B3");
+ Assert.IsNotNull (ex.Message, "#B4");
+ Assert.IsNotNull (ex.ParamName, "#B5");
+ Assert.AreEqual ("s", ex.ParamName, "#B6");
+ }
+
+ try {
+ DateTime.ParseExact ((string) null, new string [] { "G" }, null,
+ DateTimeStyles.None);
+ Assert.Fail ("#C1");
+ } catch (ArgumentNullException ex) {
+ Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#C2");
+ Assert.IsNull (ex.InnerException, "#C3");
+ Assert.IsNotNull (ex.Message, "#C4");
+ Assert.IsNotNull (ex.ParamName, "#C5");
+ Assert.AreEqual ("s", ex.ParamName, "#C6");
+ }
+ }
+
+ [Test]
+ public void TestParseExact3 ()
+ {
+ DateTime t1 = DateTime.ParseExact ("2002-02-25 04:25:13Z", "u", null);
+ Assert.AreEqual (2002, t1.Year, "#1");
+ Assert.AreEqual (02, t1.Month, "#2");
+ Assert.AreEqual (25, t1.Day, "#3");
+ Assert.AreEqual (04, t1.Hour, "#4");
+ Assert.AreEqual (25, t1.Minute, "#5");
+ Assert.AreEqual (13, t1.Second, "#6");
+ }
+
+ [Test]
+#if NET_4_0
+ [ExpectedException (typeof (FormatException))]
+ [Category ("NotWorking")]
+#endif
+ public void TestParseExact4 ()
+ {
+ // bug #60912, modified hour as 13:00 -> This now fails on .NET 4.0. (With no details "String was not recognized as a valid DateTime.", sigh.)
+ string s = "6/28/2004 13:00:00 AM";
+ string f = "M/d/yyyy HH':'mm':'ss tt";
+ DateTime.ParseExact (s, f, CultureInfo.InvariantCulture);
+ }
+
+ [Test]
+ public void TestParseExact4_2 ()
+ {
+ // bug #63137
+ DateTime.ParseExact ("Wed, 12 May 2004 20:51:09 +0200",
+ @"ddd, d MMM yyyy H:m:s zzz",
+ CultureInfo.CreateSpecificCulture("en-us"),
+ DateTimeStyles.AllowInnerWhite);
+ }
+
+ [Test]
+ public void TestParseExact5 ()
+ {
+ DateTime dt = DateTime.ParseExact ("Wed, 12 May 2004 20:51:09 -02:30",
+ @"ddd, d MMM yyyy H:m:s zzz",
+ CultureInfo.CreateSpecificCulture("en-us"),
+ DateTimeStyles.AllowInnerWhite);
+ dt = dt.ToUniversalTime ();
+ Assert.AreEqual (23, dt.Hour, "Hour");
+ Assert.AreEqual (21, dt.Minute, "Minute");
+ }
+
+ [Test]
+ public void TestParseExact ()
+ {
+ // Standard patterns
+ DateTime t1 = DateTime.ParseExact ("02/25/2002", "d", null);
+ Assert.AreEqual (myTicks [0], t1.Ticks, "#A1");
+ t1 = DateTime.ParseExact ("Monday, 25 February 2002", "D", null);
+ Assert.AreEqual (myTicks [0], t1.Ticks, "#A2");
+ t1 = DateTime.ParseExact ("Monday, 25 February 2002 05:25", "f", null);
+ Assert.AreEqual (myTicks [3], t1.Ticks, "#A3");
+ t1 = DateTime.ParseExact ("Monday, 25 February 2002 05:25:13", "F", null);
+ Assert.AreEqual (myTicks [4], t1.Ticks, "#A4");
+ t1 = DateTime.ParseExact ("02/25/2002 05:25", "g", null);
+ Assert.AreEqual (myTicks [3], t1.Ticks, "#A5");
+ t1 = DateTime.ParseExact ("02/25/2002 05:25:13", "G", null);
+ Assert.AreEqual (myTicks [4], t1.Ticks, "#A6");
+ t1 = DateTime.ParseExact ("Monday, 25 February 2002 04:25:13", "U", null);
+ t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1);
+ Assert.AreEqual (2002, t1.Year, "#A7");
+ Assert.AreEqual (02, t1.Month, "#A8");
+ Assert.AreEqual (25, t1.Day, "#A9");
+ Assert.AreEqual (04, t1.Hour, "#A10");
+ Assert.AreEqual (25, t1.Minute, "#A11");
+ Assert.AreEqual (13, t1.Second, "#A12");
+ t1 = DateTime.ParseExact ("Monday, 25 February 2002 04:25:13", "U", null);
+ Assert.AreEqual ("Monday, 25 February 2002 04:25:13", t1.ToString ("U"), "#A13");
+
+ DateTime t2 = new DateTime (DateTime.Today.Year, 2, 25);
+ t1 = DateTime.ParseExact ("February 25", "m", null);
+ Assert.AreEqual (t2.Ticks, t1.Ticks, "#B1");
+
+ t2 = new DateTime (DateTime.Today.Year, 2, 25);
+ t1 = DateTime.ParseExact ("February 25", "M", null);
+ Assert.AreEqual (t2.Ticks, t1.Ticks, "#B2");
+
+ t1 = DateTime.ParseExact ("Mon, 25 Feb 2002 04:25:13 GMT", "r", null);
+ Assert.AreEqual (2002, t1.Year, "#C1");
+ Assert.AreEqual (02, t1.Month, "#C2");
+ Assert.AreEqual (25, t1.Day, "#C3");
+ Assert.AreEqual (04, t1.Hour, "#C4");
+ Assert.AreEqual (25, t1.Minute, "#C5");
+ Assert.AreEqual (13, t1.Second, "#C6");
+
+ t1 = DateTime.ParseExact ("Mon, 25 Feb 2002 04:25:13 GMT", "R", null);
+ Assert.AreEqual (2002, t1.Year, "#D1");
+ Assert.AreEqual (02, t1.Month, "#D2");
+ Assert.AreEqual (25, t1.Day, "#D3");
+ Assert.AreEqual (04, t1.Hour, "#D4");
+ Assert.AreEqual (25, t1.Minute, "#D5");
+ Assert.AreEqual (13, t1.Second, "#D6");
+
+ t1 = DateTime.ParseExact ("2002-02-25T05:25:13", "s", null);
+ Assert.AreEqual (myTicks [4], t1.Ticks, "#E1");
+
+ t2 = DateTime.Today + new TimeSpan (5,25,0);
+ t1 = DateTime.ParseExact ("05:25", "t", null);
+ Assert.AreEqual (t2.Ticks, t1.Ticks, "#E2");
+
+ t2 = DateTime.Today + new TimeSpan (5,25,13);
+ t1 = DateTime.ParseExact ("05:25:13", "T", null);
+ Assert.AreEqual (t2.Ticks, t1.Ticks, "#E3");
+
+ t2 = new DateTime (2002, 2, 1);
+ t1 = DateTime.ParseExact ("2002 February", "y", null);
+ Assert.AreEqual (t2.Ticks, t1.Ticks, "#E4");
+
+ t2 = new DateTime (2002, 2, 1);
+ t1 = DateTime.ParseExact ("2002 February", "Y", null);
+ Assert.AreEqual (t2.Ticks, t1.Ticks, "#E5");
+
+ // Custom patterns
+ t2 = new DateTime (DateTime.Now.Year, 1, 25);
+ t1 = DateTime.ParseExact ("25", "%d", null);
+ Assert.AreEqual (t2.Ticks, t1.Ticks, "#F1");
+ t1 = DateTime.ParseExact ("25", "dd", null);
+ Assert.AreEqual (t2.Ticks, t1.Ticks, "#F2");
+
+ t2 = new DateTime (DateTime.Today.Year, 2, 1);
+ t1 = DateTime.ParseExact ("2", "%M", null);
+ Assert.AreEqual (t2.Ticks, t1.Ticks, "#G1");
+ t1 = DateTime.ParseExact ("02", "MM", null);
+ Assert.AreEqual (t2.Ticks, t1.Ticks, "#G2");
+ t1 = DateTime.ParseExact ("Feb", "MMM", null);
+ Assert.AreEqual (t2.Ticks, t1.Ticks, "#G3");
+ t1 = DateTime.ParseExact ("February", "MMMM", null);
+ Assert.AreEqual (t2.Ticks, t1.Ticks, "#G4");
+
+ t2 = new DateTime (2005, 1, 1);
+ t1 = DateTime.ParseExact ("5", "%y", null);
+ Assert.AreEqual (t2.Ticks, t1.Ticks, "#G5");
+ t1 = DateTime.ParseExact ("05", "yy", null);
+ Assert.AreEqual (t2.Ticks, t1.Ticks, "#G6");
+ t1 = DateTime.ParseExact ("2005", "yyyy", null);
+ Assert.AreEqual (t2.Ticks, t1.Ticks, "#G7");
+
+ t2 = DateTime.Today + new TimeSpan (5, 0, 0);
+ t1 = DateTime.ParseExact ("5A", "ht", null);
+ Assert.AreEqual (t2.Ticks, t1.Ticks, "#G8");
+ t1 = DateTime.ParseExact ("05A", "hht", null);
+ Assert.AreEqual (t2.Ticks, t1.Ticks, "#G9");
+
+ t2 = DateTime.Today + new TimeSpan (15, 0, 0);
+ t1 = DateTime.ParseExact ("3P", "ht", null);
+ Assert.AreEqual (t2.Ticks, t1.Ticks, "#G10");
+ t1 = DateTime.ParseExact ("03P", "hht", null);
+ Assert.AreEqual (t2.Ticks, t1.Ticks, "#G11");
+
+ t2 = DateTime.Today + new TimeSpan (5, 0, 0);
+ t1 = DateTime.ParseExact ("5", "%H", null);
+ Assert.AreEqual (t2.Ticks, t1.Ticks, "#G12");
+
+ t2 = DateTime.Today + new TimeSpan (15, 0, 0);
+ t1 = DateTime.ParseExact ("15", "%H", null);
+ Assert.AreEqual (t2.Ticks, t1.Ticks, "#G13");
+ t1 = DateTime.ParseExact ("15", "HH", null);
+ Assert.AreEqual (t2.Ticks, t1.Ticks, "#G14");
+
+ // Time zones
#if false
- // Fails durring DST for msft and mono\r
- t2 = DateTime.Today + new TimeSpan (17, 18, 0);\r
- t1 = DateTime.ParseExact ("11:18AM -5", "h:mmtt z", null);\r
- t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1);\r
- if (!TimeZone.CurrentTimeZone.IsDaylightSavingTime(t1))\r
- t1 += new TimeSpan(1, 0, 0);\r
- AssertEquals ("F01", t2.Ticks, t1.Ticks);
- \r
- t1 = DateTime.ParseExact ("11:18AM -05:00", "h:mmtt zzz", null);\r
- t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1);\r
- if (!TimeZone.CurrentTimeZone.IsDaylightSavingTime(t1))\r
- t1 += new TimeSpan(1, 0, 0);\r
- AssertEquals ("F02", t2.Ticks, t1.Ticks);\r
-\r
- t1 = DateTime.ParseExact ("7:18PM +03", "h:mmtt zz", null);\r
- t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1);\r
- if (!TimeZone.CurrentTimeZone.IsDaylightSavingTime(t1))\r
- t1 += new TimeSpan(1, 0, 0);\r
- AssertEquals ("F03", t2.Ticks, t1.Ticks);\r
-\r
- t1 = DateTime.ParseExact ("7:48PM +03:30", "h:mmtt zzz", null);\r
- t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1);\r
- if (!TimeZone.CurrentTimeZone.IsDaylightSavingTime(t1))\r
- t1 += new TimeSpan(1, 0, 0);\r
- AssertEquals ("F04", t2.Ticks, t1.Ticks);\r
+ // Fails durring DST for msft and mono
+ t2 = DateTime.Today + new TimeSpan (17, 18, 0);
+ t1 = DateTime.ParseExact ("11:18AM -5", "h:mmtt z", null);
+ t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1);
+ if (!TimeZone.CurrentTimeZone.IsDaylightSavingTime(t1))
+ t1 += new TimeSpan(1, 0, 0);
+ Assert.AreEqual (t2.Ticks, t1.Ticks, "#H1");
+
+ t1 = DateTime.ParseExact ("11:18AM -05:00", "h:mmtt zzz", null);
+ t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1);
+ if (!TimeZone.CurrentTimeZone.IsDaylightSavingTime(t1))
+ t1 += new TimeSpan(1, 0, 0);
+ Assert.AreEqual (t2.Ticks, t1.Ticks, "#H2");
+
+ t1 = DateTime.ParseExact ("7:18PM +03", "h:mmtt zz", null);
+ t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1);
+ if (!TimeZone.CurrentTimeZone.IsDaylightSavingTime(t1))
+ t1 += new TimeSpan(1, 0, 0);
+ Assert.AreEqual (t2.Ticks, t1.Ticks, "#H3");
+
+ t1 = DateTime.ParseExact ("7:48PM +03:30", "h:mmtt zzz", null);
+ t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1);
+ if (!TimeZone.CurrentTimeZone.IsDaylightSavingTime(t1))
+ t1 += new TimeSpan(1, 0, 0);
+ Assert.AreEqual (t2.Ticks, t1.Ticks, "#H4");
#endif
- \r
- // Options\r
- t2 = DateTime.Today + new TimeSpan (16, 18, 0);\r
- t1 = DateTime.ParseExact ("11:18AM -5", "h:mmtt z",\r
- null, DateTimeStyles.AdjustToUniversal);\r
- AssertEquals ("G01", t2.Ticks, t1.Ticks);\r
-\r
- t1 = DateTime.ParseExact ("Monday, 25 February 2002 05:25:13", "F",\r
- null, DateTimeStyles.AdjustToUniversal);\r
- AssertEquals ("G02", myTicks[4], t1.Ticks);\r
- t1 = DateTime.ParseExact ("Monday, 25 February 2002 05:25:13",\r
- "dddd, dd MMMM yyyy HH:mm:ss",\r
- null, DateTimeStyles.AdjustToUniversal);\r
- AssertEquals ("G03", myTicks[4], t1.Ticks);\r
-\r
- t1 = DateTime.ParseExact ("02/25/2002", "d", null,\r
- DateTimeStyles.AllowWhiteSpaces);\r
- AssertEquals ("G04", myTicks[0], t1.Ticks);\r
-\r
- t1 = DateTime.ParseExact (" 02/25/2002", "d", null,\r
- DateTimeStyles.AllowLeadingWhite);\r
- AssertEquals ("G05", myTicks[0], t1.Ticks);\r
-\r
- t1 = DateTime.ParseExact ("02/25/2002 ", "d", null,\r
- DateTimeStyles.AllowTrailingWhite);\r
- AssertEquals ("G06", myTicks[0], t1.Ticks);\r
-\r
- t1 = DateTime.ParseExact (" 02 / 25 / 2002 ", "d", null,\r
- DateTimeStyles.AllowWhiteSpaces);\r
- AssertEquals ("G07", myTicks[0], t1.Ticks);\r
-\r
- // Multi Custom Patterns\r
- string rfc1123_date = "r";\r
- string rfc850_date = "dddd, dd'-'MMM'-'yy HH':'mm':'ss 'GMT'";\r
- string asctime_date = "ddd MMM d HH':'mm':'ss yyyy";\r
- string [] formats = new string [] {rfc1123_date, rfc850_date, asctime_date};\r
- CultureInfo enUS = new CultureInfo("en-US", false);\r
- t1 = DateTime.ParseExact ("Sun, 06 Nov 1994 08:49:37 GMT", formats[0], enUS, \r
- DateTimeStyles.AllowWhiteSpaces);\r
- AssertEquals ("M01", myTicks[6], t1.Ticks);\r
- t1 = DateTime.ParseExact ("Sunday, 06-Nov-94 08:49:37 GMT", formats[1], enUS, \r
- DateTimeStyles.AllowWhiteSpaces);\r
- AssertEquals ("M02", myTicks[6], t1.Ticks);\r
- t1 = DateTime.ParseExact ("Sun Nov 6 08:49:37 1994", formats[2], enUS, \r
- DateTimeStyles.AllowWhiteSpaces);\r
- AssertEquals ("M03", myTicks[6], t1.Ticks);\r
- t1 = DateTime.ParseExact ("Sun, 06 Nov 1994 08:49:37 GMT", formats, enUS, \r
- DateTimeStyles.AllowWhiteSpaces);\r
- AssertEquals ("M04", myTicks[6], t1.Ticks);\r
- t1 = DateTime.ParseExact ("Sunday, 06-Nov-94 08:49:37 GMT", formats, enUS, \r
- DateTimeStyles.AllowWhiteSpaces);\r
- AssertEquals ("M05", myTicks[6], t1.Ticks);\r
- t1 = DateTime.ParseExact ("Sun Nov 6 08:49:37 1994", formats, enUS, \r
- DateTimeStyles.AllowWhiteSpaces);\r
- AssertEquals ("M06", myTicks[6], t1.Ticks);\r
- \r
- // Bug 52274\r
- t1 = DateTime.ParseExact ("--12--", "--MM--" , null);\r
- AssertEquals("Dash01", 12, t1.Month);\r
- t1=DateTime.ParseExact ("--12-24", "--MM-dd" , null);\r
- AssertEquals("Dash02", 24, t1.Day);\r
- AssertEquals("Dash03", 12, t1.Month);\r
- t1=DateTime.ParseExact ("---24", "---dd" , null);\r
- AssertEquals("Dash04", 24, t1.Day);\r
-\r
- // Bug 63376\r
- t1 = DateTime.ParseExact ("18Aug2004 12:33:00", "ddMMMyyyy hh:mm:ss", new CultureInfo ("en-US"));\r
- AssertEquals ("hh allows 12, though it's useless", 0, t1.Hour);\r
- }\r
-\r
- [Ignore ("need to fix tests that run on different timezones")]\r
- public void TestParse2 ()\r
- {\r
- DateTime t1 = DateTime.Parse ("Mon, 25 Feb 2002 04:25:13 GMT");\r
- t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1);\r
- AssertEquals ("H10d", 04 - TimeZone.CurrentTimeZone.GetUtcOffset(t1).Hours, t1.Hour);\r
-\r
- }\r
- \r
- public void TestParse ()\r
- {\r
- // Standard patterns\r
- DateTime t1 = DateTime.Parse ("02/25/2002");\r
- AssertEquals ("H00", myTicks[0], t1.Ticks);\r
- try {\r
- t1 = DateTime.Parse ("02-25-2002");\r
- }\r
- catch (Exception e) {\r
- Fail ("Unexpected exception. e=" + e);\r
- }\r
- try {\r
- t1 = DateTime.Parse ("2002-02-25");\r
- }\r
- catch (Exception e) {\r
- Fail ("Unexpected exception. e=" + e);\r
- }\r
- AssertEquals ("H01", myTicks[0], t1.Ticks);\r
- t1 = DateTime.Parse ("Monday, 25 February 2002");\r
- AssertEquals ("H02", myTicks[0], t1.Ticks);\r
- t1 = DateTime.Parse ("Monday, 25 February 2002 05:25");\r
- AssertEquals ("H03", myTicks[3], t1.Ticks);\r
- t1 = DateTime.Parse ("Monday, 25 February 2002 05:25:13");\r
- AssertEquals ("H04", myTicks[4], t1.Ticks);\r
- t1 = DateTime.Parse ("02/25/2002 05:25");\r
- AssertEquals ("H05", myTicks[3], t1.Ticks);\r
- t1 = DateTime.Parse ("02/25/2002 05:25:13");\r
- AssertEquals ("H06", myTicks[4], t1.Ticks);\r
- t1 = DateTime.Parse ("2002-02-25 04:25:13Z");\r
- t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1);\r
- AssertEquals ("H07a", 2002, t1.Year);\r
- AssertEquals ("H07b", 02, t1.Month);\r
- AssertEquals ("H07c", 25, t1.Day);\r
- AssertEquals ("H07d", 04, t1.Hour);\r
- AssertEquals ("H07e", 25, t1.Minute);\r
- AssertEquals ("H07f", 13, t1.Second);\r
-\r
- DateTime t2 = new DateTime (DateTime.Today.Year, 2, 25);\r
- t1 = DateTime.Parse ("February 25");\r
- AssertEquals ("H08", t2.Ticks, t1.Ticks);\r
-\r
- t2 = new DateTime (DateTime.Today.Year, 2, 8);\r
- t1 = DateTime.Parse ("February 08");\r
- AssertEquals ("H09", t2.Ticks, t1.Ticks);\r
-\r
- // parsed as UTC string\r
- t1 = DateTime.Parse ("Mon, 25 Feb 2002 04:25:13 GMT");\r
- t1 = TimeZone.CurrentTimeZone.ToUniversalTime (t1);\r
- AssertEquals ("H10a", 2002, t1.Year);\r
- AssertEquals ("H10b", 02, t1.Month);\r
- AssertEquals ("H10c", 25, t1.Day);\r
- AssertEquals ("H10d", 4, t1.Hour);\r
- AssertEquals ("H10e", 25, t1.Minute);\r
- AssertEquals ("H10f", 13, t1.Second);\r
-\r
- t1 = DateTime.Parse ("2002-02-25T05:25:13");\r
- AssertEquals ("H11", myTicks[4], t1.Ticks);\r
-\r
- t2 = DateTime.Today + new TimeSpan (5,25,0);\r
- t1 = DateTime.Parse ("05:25");\r
- AssertEquals("H12", t2.Ticks, t1.Ticks);\r
-\r
- t2 = DateTime.Today + new TimeSpan (5,25,13);\r
- t1 = DateTime.Parse ("05:25:13");\r
- AssertEquals("H13", t2.Ticks, t1.Ticks);\r
-\r
- t2 = new DateTime (2002, 2, 1);\r
- t1 = DateTime.Parse ("2002 February");\r
- AssertEquals ("H14", t2.Ticks, t1.Ticks);\r
-\r
- t2 = new DateTime (2002, 2, 1);\r
- t1 = DateTime.Parse ("2002 February");\r
- AssertEquals ("H15", t2.Ticks, t1.Ticks);\r
-\r
- t2 = new DateTime (DateTime.Today.Year, 2, 8);\r
- t1 = DateTime.Parse ("February 8");\r
- AssertEquals ("H16", t2.Ticks, t1.Ticks);\r
- }\r
-\r
- public void TestParse3 ()\r
- {\r
- string s = "Wednesday, 09 June 2004";\r
- DateTime.ParseExact (s, "dddd, dd MMMM yyyy", CultureInfo.InvariantCulture);\r
- try {\r
- DateTime.ParseExact (s, "dddd, dd MMMM yyyy", new CultureInfo ("ja-JP"));\r
- Fail ("ja-JP culture does not support format \"dddd, dd MMMM yyyy\"");\r
- } catch (FormatException) {\r
- }\r
-\r
- // Ok, now we can assume ParseExact() works expectedly.\r
-\r
- DateTime.Parse (s, CultureInfo.InvariantCulture, DateTimeStyles.AllowWhiteSpaces);\r
- DateTime.Parse (s, new CultureInfo ("ja-JP"), DateTimeStyles.AllowWhiteSpaces);\r
-// DateTime.Parse (s, null); currently am not sure if it works for _every_ culture.\r
- }\r
-\r
- [Test]\r
- [ExpectedException(typeof (FormatException))]\r
- public void ParseFormatException1 ()\r
- {\r
- // Following string is not a correct French date i.e. dd/mm/yyyy.\r
- String frDateTime = "11/13/2003 11:28:15";\r
- IFormatProvider format = new CultureInfo("fr-FR", true);\r
- DateTime t1 = DateTime.Parse(frDateTime, format);\r
- }\r
-\r
- public void TestOA ()\r
- {\r
- double number=5000.41443;\r
- DateTime d = DateTime.FromOADate(number);\r
- DTAssertEquals ("I01", d, new DateTime(1913, 9, 8, 9, 56, 46, 0), Resolution.Second);\r
- AssertEquals ("I02", d.ToOADate(), number);\r
- }\r
-\r
- [Test]\r
- [Category ("NotWorking")]
- public void ParseAllowsQueerString ()\r
- {\r
- DateTime.Parse ("Sat,,,,,, 01 Oct 1994 03:00:00", CultureInfo.InvariantCulture);\r
- }\r
-\r
- [Test]\r
- public void ParseUtcNonUtc ()\r
- {\r
- Thread.CurrentThread.CurrentCulture = new CultureInfo ("es-ES");\r
-\r
- CultureInfo ci;\r
- string s, s2, s3, d;\r
- DateTime dt;\r
- DateTimeFormatInfo dfi = DateTimeFormatInfo.InvariantInfo;\r
- s = dfi.UniversalSortableDateTimePattern;\r
- s2 = "r";\r
-\r
- s3 = "s";\r
-\r
- long tick1 = 631789220960000000; // 2003-01-23 12:34:56 as is\r
- long tick2 = TimeZone.CurrentTimeZone.ToLocalTime (new DateTime (tick1)).Ticks; // adjusted to local time\r
-\r
- // invariant\r
- ci = CultureInfo.InvariantCulture;\r
-\r
- d = "2003/01/23 12:34:56";\r
- dt = DateTime.Parse (d, ci);\r
- AssertEquals (d, tick1, dt.Ticks);\r
-\r
- d = "2003/01/23 12:34:56 GMT";\r
- dt = DateTime.Parse (d, ci);\r
- AssertEquals (d, tick2, dt.Ticks);\r
-\r
- d = "Thu, 23 Jan 2003 12:34:56 GMT";\r
- dt = DateTime.ParseExact (d, s2, ci);\r
- AssertEquals (d, tick1, dt.Ticks);\r
-\r
- d = "2003-01-23 12:34:56Z";\r
- dt = DateTime.ParseExact (d, s, ci);\r
- AssertEquals (d, tick1, dt.Ticks);\r
-\r
- d = "2003-01-23T12:34:56";\r
- dt = DateTime.ParseExact (d, s3, ci);\r
- AssertEquals (d, tick1, dt.Ticks);\r
-\r
- // ja-JP ... it should be culture independent\r
- ci = new CultureInfo ("ja-JP");\r
-\r
- d = "2003/01/23 12:34:56";\r
- dt = DateTime.Parse (d, ci);\r
- AssertEquals (d, tick1, dt.Ticks);\r
-\r
- d = "2003/01/23 12:34:56 GMT";\r
- dt = DateTime.Parse (d, ci);\r
- AssertEquals (d, tick2, dt.Ticks);\r
-\r
- d = "Thu, 23 Jan 2003 12:34:56 GMT";\r
- dt = DateTime.ParseExact (d, s2, ci);\r
- AssertEquals (d, tick1, dt.Ticks);\r
-\r
- d = "2003-01-23 12:34:56Z";\r
- dt = DateTime.ParseExact (d, s, ci);\r
- AssertEquals (d, tick1, dt.Ticks);\r
-\r
- d = "2003-01-23T12:34:56";\r
- dt = DateTime.ParseExact (d, s3, ci);\r
- AssertEquals (d, tick1, dt.Ticks);\r
- }\r
-\r
- [Test]\r
- public void TimeZoneAdjustment ()\r
- {\r
- CultureInfo ci = Thread.CurrentThread.CurrentCulture;\r
- try {\r
- Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US");\r
- DateTime d1 = DateTime.ParseExact ("2004/06/30", "yyyy/MM/dd", null);\r
- DateTime d2 = DateTime.ParseExact ("2004/06/30Z", "yyyy/MM/dd'Z'", null);\r
- DateTime d3 = DateTime.ParseExact ("Wed, 30 Jun 2004 00:00:00 GMT", "ddd, dd MMM yyyy HH':'mm':'ss 'GMT'", null);\r
- DateTime d4 = DateTime.ParseExact ("2004-06-30 00:00:00Z", "yyyy'-'MM'-'dd HH':'mm':'ss'Z'", null);\r
- StringWriter sw = new StringWriter ();\r
- sw.Write ("{0} {1}", d1.Ticks, d1);\r
- AssertEquals ("#1", "632241504000000000 6/30/2004 12:00:00 AM", sw.ToString ());\r
- sw.GetStringBuilder ().Length = 0;\r
- sw.Write ("{0} {1}", d2.Ticks, d2);\r
- AssertEquals ("#2", "632241504000000000 6/30/2004 12:00:00 AM", sw.ToString ());\r
- sw.GetStringBuilder ().Length = 0;\r
- sw.Write ("{0} {1}", d3.Ticks, d3);\r
- AssertEquals ("#3", "632241504000000000 6/30/2004 12:00:00 AM", sw.ToString ());\r
- sw.GetStringBuilder ().Length = 0;\r
- sw.Write ("{0} {1}", d4.Ticks, d4);\r
- AssertEquals ("#4", "632241504000000000 6/30/2004 12:00:00 AM", sw.ToString ());\r
- } finally {\r
- Thread.CurrentThread.CurrentCulture = ci;\r
- }\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (ArgumentException))]\r
- public void FromOADate_Min () \r
- {\r
- // minimum documented value isn't inclusive\r
- DateTime.FromOADate (-657435.0d);\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (ArgumentException))]\r
- public void FromOADate_Max () \r
- {\r
- // maximum documented value isn't inclusive\r
- DateTime.FromOADate (2958466.0d);\r
- }\r
-\r
- [Test]\r
- public void FromOADate ()\r
- {\r
- // Note: OA (OLE Automation) dates aren't timezone sensitive\r
- AssertEquals ("Ticks-Zero", 599264352000000000, DateTime.FromOADate (0.0d).Ticks);\r
- AssertEquals ("Ticks-Min", 31242239136000000, DateTime.FromOADate (-657434.999d).Ticks);\r
- AssertEquals ("Ticks-Max", 3155378975136000000, DateTime.FromOADate (2958465.999d).Ticks);\r
- }\r
-\r
- [Test]\r
- public void ToOADate ()\r
- {\r
- // Note: OA (OLE Automation) dates aren't timezone sensitive\r
- DateTime d = new DateTime (0);\r
- AssertEquals ("Unititialized", 0.0d, d.ToOADate ());\r
- d = new DateTime (599264352000000000);\r
- AssertEquals ("Ticks-Zero", 0.0d, d.ToOADate ());\r
- d = new DateTime (31242239136000000);\r
- AssertEquals ("Ticks-Min", -657434.999d, d.ToOADate ());\r
- d = new DateTime (3155378975136000000);\r
- AssertEquals ("Ticks-Max", 2958465.999d, d.ToOADate ());\r
- }\r
-\r
- [Test]\r
- public void ToOADate_OverMax ()\r
- {\r
- DateTime d = new DateTime (3155378975136000001);\r
- AssertEquals ("Over-Max", 2958465.999d, d.ToOADate ());\r
- }\r
-\r
- [Test]\r
- public void ToOADate_MaxValue ()\r
- {\r
- AssertEquals ("MaxValue", 2958465.99999999d, DateTime.MaxValue.ToOADate ());\r
- }\r
-\r
- [Test]\r
- public void ToOADate_UnderMin ()\r
- {\r
- DateTime d = new DateTime (31242239135999999);\r
- AssertEquals ("Under-Min", -657434.999d, d.ToOADate ());\r
- }\r
-\r
- [Test]\r
- public void ToOADate_MinValue ()\r
- {\r
- AssertEquals ("MinValue", 0, DateTime.MinValue.ToOADate ());\r
- }\r
-\r
- [Test]\r
- public void MaxValueYear () // bug52075\r
- {\r
- AssertEquals ("#01", "9999", DateTime.MaxValue.Year.ToString ());\r
- }\r
-\r
- [Test]\r
- public void X509Certificate () \r
- {\r
- // if this test fails then *ALL* or *MOST* X509Certificate tests will also fails\r
- AssertEquals ("yyyyMMddHHmmssZ", "03/12/1996 18:38:47", DateTime.ParseExact ("19960312183847Z", "yyyyMMddHHmmssZ", null).ToUniversalTime ().ToString ());\r
- // technically this is invalid (PKIX) because of the missing seconds but it exists so...\r
- AssertEquals ("yyMMddHHmmZ", "02/23/1996 19:15:00", DateTime.ParseExact ("9602231915Z", "yyMMddHHmmZ", null).ToUniversalTime ().ToString ());\r
-\r
- // However, "Z" and "'Z'" are different.\r
- AssertEquals ("Z timezone handling",\r
- DateTime.ParseExact ("19960312183847Z", "yyyyMMddHHmmss'Z'", null).ToLocalTime (),\r
- DateTime.ParseExact ("19960312183847Z", "yyyyMMddHHmmssZ", null));\r
- }\r
-\r
- [Test]\r
- public void QuotedFormat () // bug 56436\r
- {\r
- string date = "28/Mar/2004:19:12:37 +0200";\r
- string [] expectedFormats = {"dd\"/\"MMM\"/\"yyyy:HH:mm:ss zz\"00\""};\r
- DateTime mydate = DateTime.ParseExact (date, expectedFormats, null, DateTimeStyles.AllowWhiteSpaces);\r
- }\r
-\r
- [Test]\r
- public void CultureIndependentTests ()\r
- {\r
- // Here I aggregated some tests mainly because of test \r
- // performance (iterating all the culture is heavy process).\r
- \r
- for (int i = 0; i < 32768; i++) {\r
- CultureInfo ci = null;\r
- string stage = "init";\r
- try {\r
- try {\r
- ci = new CultureInfo (i);\r
- // In fact InvatiantCulture is not neutral.\r
- // See bug #59716.\r
- if (ci.IsNeutralCulture && ci != CultureInfo.InvariantCulture)\r
- continue;\r
- } catch (Exception) {\r
- continue;\r
- }\r
- Thread.CurrentThread.CurrentCulture = ci;\r
- DateTime dt;\r
-\r
- // Common patterns\r
- // X509Certificate pattern is _always_ accepted.\r
- stage = "1";\r
- dt = DateTime.ParseExact ("19960312183847Z", "yyyyMMddHHmmssZ", null);\r
-#if NET_1_1\r
- stage = "2";\r
- // culture 1025 ar-SA fails\r
-// if (i != 127)\r
-// dt = DateTime.Parse ("19960312183847Z");\r
-#endif\r
- stage = "3";\r
- dt = DateTime.Parse ("2004-05-26T03:29:01.1234567");\r
- stage = "4";\r
- dt = DateTime.Parse ("2004-05-26T03:29:01.1234567-07:00");\r
-\r
- // memo: the least LCID is 127, and then 1025(ar-SA)\r
-\r
- // "th-TH" locale rejects them since in\r
- // ThaiBuddhistCalendar the week of a day is different.\r
- // (and also for years).\r
- if (ci.LCID != 1054) {\r
- try {\r
- stage = "5";\r
- dt = DateTime.Parse ("Sat, 29 Oct 1994 12:00:00 GMT", ci);\r
- } catch (FormatException ex) {\r
- Fail (String.Format ("stage 5.1 RFC1123: culture {0} {1} failed: {2}", i, ci, ex.Message));\r
- }\r
-/* comment out until we fix RFC1123\r
- // bug #47720\r
- if (dt != TimeZone.CurrentTimeZone.ToUniversalTime (dt))\r
- Assert (String.Format ("bug #47720 on culture {0} {1}", ci.LCID, ci), 12 != dt.Hour);\r
-*/\r
- // variant of RFC1123\r
- try {\r
- stage = "6";\r
- dt = DateTime.Parse ("Sat, 1 Oct 1994 03:00:00", ci);\r
- } catch (FormatException ex) {\r
- Fail (String.Format ("stage 6.1 RFC1123 variant: culture {0} {1} failed: {2}", i, ci, ex.Message));\r
- }\r
- stage = "7";\r
- AssertEquals (String.Format ("stage 7.1 RFC1123 variant on culture {0} {1}", ci.LCID, ci), 3, dt.Hour);\r
- }\r
-\r
- switch (ci.LCID) {\r
- case 1025: // ar-SA\r
- case 1054: // th-TH\r
- case 1125: // div-MV\r
- break;\r
- default:\r
- stage = "8";\r
- // 02/25/2002 04:25:13 as is\r
- long tick1 = 631502079130000000;\r
- long tick2 = TimeZone.CurrentTimeZone.ToLocalTime (new DateTime (tick1)).Ticks; // adjusted to local time\r
- dt = DateTime.Parse ("Mon, 25 Feb 2002 04:25:13 GMT", ci);\r
- AssertEquals (String.Format ("GMT variant. culture={0} {1}", i, ci), tick2, dt.Ticks);\r
- break;\r
- }\r
-\r
-#if NET_1_1\r
- // ka-GE rejects these formats under MS.NET. \r
- // I wonder why. Also, those tests fail under .NET 1.0.\r
- if (ci.LCID != 1079) {\r
- stage = "9";\r
- dt = DateTime.Parse ("2002-02-25");\r
- stage = "10";\r
- dt = DateTime.Parse ("2002-02-25Z");\r
- stage = "11";\r
- dt = DateTime.Parse ("2002-02-25T19:20:00+09:00");\r
- switch (ci.LCID) {\r
- case 1038: // FIXME: MS passes this culture.\r
- case 1062: // FIXME: MS passes this culture.\r
- case 1078: // MS does not pass this culture. Dunno why.\r
- break;\r
- default:\r
- // bug #58938\r
- stage = "12";\r
- dt = DateTime.Parse ("2002#02#25 19:20:00");\r
- stage = "13";\r
- AssertEquals (String.Format ("bug #58938 on culture {0} {1}", ci.LCID, ci), 19, dt.Hour);\r
- break;\r
- }\r
- stage = "14";\r
- dt = DateTime.Parse ("2002-02-25 12:01:03");\r
- stage = "15";\r
- dt = DateTime.Parse ("2002#02#25 12:01:03");\r
- stage = "16";\r
- dt = DateTime.Parse ("2002%02%25 12:01:03");\r
- stage = "17";\r
- if (ci.DateTimeFormat.TimeSeparator != ".")\r
- dt = DateTime.Parse ("2002.02.25 12:01:03");\r
- stage = "18";\r
- dt = DateTime.Parse ("2003/01/23 01:34:56 GMT");\r
- dt = TimeZone.CurrentTimeZone.ToUniversalTime (dt);\r
- AssertEquals (String.Format ("stage 18.1 RFC1123 UTC {0} {1}", i, ci), 1, dt.Hour);\r
- stage = "19";\r
- // This test was fixed from 12:34:56 to\r
- // 01:34:56 since 1078 af-ZA failed\r
- // because of hour interpretation\r
- // difference (af-ZA expects 0).\r
- // (IMHO it is MS BUG though.)\r
- dt = DateTime.Parse ("2003/01/23 12:34:56 GMT");\r
- dt = TimeZone.CurrentTimeZone.ToUniversalTime (dt);\r
- if (i != 1078)\r
- AssertEquals (String.Format ("stage 18.1 RFC1123 UTC {0} {1}", i, ci), 12, dt.Hour);\r
- }\r
-#endif\r
- } catch (FormatException ex) {\r
- Fail (String.Format ("stage {3}: Culture {0} {1} failed: {2}", i, ci, ex.Message, stage));\r
- }\r
- }\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (ArgumentOutOfRangeException))]\r
- public void ToFileTime_MinValue () \r
- {\r
- DateTime.FromFileTime (Int64.MinValue);\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (ArgumentOutOfRangeException))]\r
- public void ToFileTime_Negative () \r
- {\r
- DateTime.FromFileTime (-1);\r
- }\r
-\r
- [Test]\r
- public void ToFileTime () \r
- {\r
- long u = DateTime.FromFileTimeUtc (0).Ticks;\r
- AssertEquals ("Utc-0", 504911232000000000, u);\r
- long max = DateTime.MaxValue.Ticks - 504911232000000000; // w32file_epoch\r
- AssertEquals ("Utc-MaxValue", 3155378975999999999, DateTime.FromFileTimeUtc (max).Ticks);\r
-\r
- long t = DateTime.FromFileTime (0).Ticks;\r
- Assert ("ToFileTime>", t > (u - TimeSpan.TicksPerDay));\r
- Assert ("ToFileTime<", t < (u + TimeSpan.TicksPerDay));\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (ArgumentOutOfRangeException))]\r
- public void ToFileTimeUtc_MinValue () \r
- {\r
- DateTime.FromFileTimeUtc (Int64.MinValue);\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (ArgumentOutOfRangeException))]\r
- public void ToFileTimeUtc_Negative () \r
- {\r
- DateTime.FromFileTimeUtc (-1);\r
- }\r
-\r
- [Test]\r
- public void Milliseconds ()\r
- {\r
- DateTime dt = DateTime.Parse ("2004-05-26T03:29:01.1234567-07:00");\r
- dt = TimeZone.CurrentTimeZone.ToUniversalTime (dt);\r
- AssertEquals ("DateTime with milliseconds", 632211641411234567, dt.Ticks);\r
- }\r
-\r
- [Test]\r
- [Category ("NotWorking")]
- public void ParseNotExact ()\r
- {
- // The error reported is:
- // String was not recognized as valid DateTime
- DateTime dt = DateTime.Parse ("2004-05-26T03:29:01-07:00 foo");\r
- dt = TimeZone.CurrentTimeZone.ToUniversalTime (dt);\r
- AssertEquals ("DateTime.Parse not exact", 632211641410000000, dt.Ticks);\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (FormatException))]\r
- public void ParseExactIsExact()\r
- {\r
- DateTime.ParseExact ("2004-05-26T03:29:01-07:00 foo", "yyyy-MM-ddTHH:mm:sszzz", null);\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (FormatException))]\r
- public void ParseExactDoesNotEatZ ()\r
- {\r
- DateTime.ParseExact ("2004-05-26T03:29:01", "yyyy-MM-ddTHH:mm:ssZ", null);\r
- }\r
-\r
- [Test]\r
- public void ParseExactMilliseconds ()\r
- {\r
- DateTime dt = DateTime.ParseExact ("2004-05-26T03:29:01.1234567-07:00", "yyyy-MM-ddTHH:mm:ss.fffffffzzz", null);\r
- dt = TimeZone.CurrentTimeZone.ToUniversalTime (dt);\r
- AssertEquals ("DateTime.ParseExact with milliseconds", 632211641411234567, dt.Ticks);\r
- }\r
-\r
- [Test]\r
- public void NoColonTimeZone ()\r
- {\r
- AssertEquals ("DateTime with colon-less timezone", true, DateTime.Parse ("2004-05-26T03:29:01-0700").Ticks != DateTime.Parse ("2004-05-26T03:29:01-0800").Ticks);\r
- }\r
-\r
- [Test]\r
- public void WithColonTimeZone ()\r
- {\r
- AssertEquals ("DateTime with colon tiemzone", true, DateTime.Parse ("2004-05-26T03:29:01-07:00").Ticks != DateTime.Parse ("2004-05-26T03:29:01-08:00").Ticks);\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (InvalidCastException))]\r
- public void IConvertible_ToType_Boolean () \r
- {\r
- ((IConvertible)DateTime.Now).ToType (typeof (bool), null);\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (InvalidCastException))]\r
- public void IConvertible_ToType_Byte () \r
- {\r
- ((IConvertible)DateTime.Now).ToType (typeof (byte), null);\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (InvalidCastException))]\r
- public void IConvertible_ToType_Char () \r
- {\r
- ((IConvertible)DateTime.Now).ToType (typeof (char), null);\r
- }\r
-\r
- [Test]\r
- public void IConvertible_ToType_DateTime () \r
- {\r
- DateTime dt = DateTime.Now;\r
- DateTime dt2 = (DateTime) ((IConvertible)dt).ToType (typeof (DateTime), null);\r
- Assert ("Object", dt.Equals (dt2));\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (InvalidCastException))]\r
- public void IConvertible_ToType_DBNull () \r
- {\r
- ((IConvertible)DateTime.Now).ToType (typeof (DBNull), null);\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (InvalidCastException))]\r
- public void IConvertible_ToType_Decimal () \r
- {\r
- ((IConvertible)DateTime.Now).ToType (typeof (decimal), null);\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (InvalidCastException))]\r
- public void IConvertible_ToType_Double () \r
- {\r
- ((IConvertible)DateTime.Now).ToType (typeof (double), null);\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (ArgumentNullException))]\r
- public void IConvertible_ToType_Empty () \r
- {\r
- ((IConvertible)DateTime.Now).ToType (null, null);\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (InvalidCastException))]\r
- public void IConvertible_ToType_Int16 () \r
- {\r
- ((IConvertible)DateTime.Now).ToType (typeof (short), null);\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (InvalidCastException))]\r
- public void IConvertible_ToType_Int32 () \r
- {\r
- ((IConvertible)DateTime.Now).ToType (typeof (int), null);\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (InvalidCastException))]\r
- public void IConvertible_ToType_Int64 () \r
- {\r
- ((IConvertible)DateTime.Now).ToType (typeof (long), null);\r
- }\r
-\r
- [Test]\r
- public void IConvertible_ToType_Object () \r
- {\r
- DateTime dt = DateTime.Now;\r
- object o = ((IConvertible)dt).ToType (typeof (object), null);\r
- Assert ("Object", dt.Equals (o));\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (InvalidCastException))]\r
- public void IConvertible_ToType_SByte () \r
- {\r
- ((IConvertible)DateTime.Now).ToType (typeof (sbyte), null);\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (InvalidCastException))]\r
- public void IConvertible_ToType_Single () \r
- {\r
- ((IConvertible)DateTime.Now).ToType (typeof (float), null);\r
- }\r
-\r
- [Test]\r
- public void IConvertible_ToType_String () \r
- {\r
- DateTime dt = DateTime.Now;\r
- string s = (string) ((IConvertible)dt).ToType (typeof (string), null);\r
- AssertEquals ("String", dt.ToString (), s);\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (InvalidCastException))]\r
- public void IConvertible_ToType_UInt16 () \r
- {\r
- ((IConvertible)DateTime.Now).ToType (typeof (ushort), null);\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (InvalidCastException))]\r
- public void IConvertible_ToType_UInt32 () \r
- {\r
- ((IConvertible)DateTime.Now).ToType (typeof (uint), null);\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (InvalidCastException))]\r
- public void IConvertible_ToType_UInt64 () \r
- {\r
- ((IConvertible)DateTime.Now).ToType (typeof (ulong), null);\r
- }\r
-}\r
-\r
-}\r
+
+ // Options
+ t2 = DateTime.Today + new TimeSpan (16, 18, 0);
+ t1 = DateTime.ParseExact ("11:18AM -5", "h:mmtt z",
+ null, DateTimeStyles.AdjustToUniversal);
+ Assert.AreEqual (t2.Ticks, t1.Ticks, "#I1");
+
+ t1 = DateTime.ParseExact ("Monday, 25 February 2002 05:25:13", "F",
+ null, DateTimeStyles.AdjustToUniversal);
+ Assert.AreEqual (myTicks [4], t1.Ticks, "#I2");
+ t1 = DateTime.ParseExact ("Monday, 25 February 2002 05:25:13",
+ "dddd, dd MMMM yyyy HH:mm:ss",
+ null, DateTimeStyles.AdjustToUniversal);
+ Assert.AreEqual (myTicks [4], t1.Ticks, "#I3");
+
+ t1 = DateTime.ParseExact ("02/25/2002", "d", null,
+ DateTimeStyles.AllowWhiteSpaces);
+ Assert.AreEqual (myTicks [0], t1.Ticks, "#I4");
+
+ t1 = DateTime.ParseExact (" 02/25/2002", "d", null,
+ DateTimeStyles.AllowLeadingWhite);
+ Assert.AreEqual (myTicks [0], t1.Ticks, "#I5");
+
+ t1 = DateTime.ParseExact ("02/25/2002 ", "d", null,
+ DateTimeStyles.AllowTrailingWhite);
+ Assert.AreEqual (myTicks [0], t1.Ticks, "#I6");
+
+ t1 = DateTime.ParseExact (" 02 / 25 / 2002 ", "d", null,
+ DateTimeStyles.AllowWhiteSpaces);
+ Assert.AreEqual (myTicks [0], t1.Ticks, "#I7");
+
+ // Multi Custom Patterns
+ string rfc1123_date = "r";
+ string rfc850_date = "dddd, dd'-'MMM'-'yy HH':'mm':'ss 'GMT'";
+ string asctime_date = "ddd MMM d HH':'mm':'ss yyyy";
+ string [] formats = new string [] {rfc1123_date, rfc850_date, asctime_date};
+ CultureInfo enUS = new CultureInfo("en-US", false);
+ t1 = DateTime.ParseExact ("Sun, 06 Nov 1994 08:49:37 GMT", formats[0], enUS,
+ DateTimeStyles.AllowWhiteSpaces);
+ Assert.AreEqual (myTicks [6], t1.Ticks, "#J1");
+ t1 = DateTime.ParseExact ("Sunday, 06-Nov-94 08:49:37 GMT", formats[1], enUS,
+ DateTimeStyles.AllowWhiteSpaces);
+ Assert.AreEqual (myTicks [6], t1.Ticks, "#J2");
+ t1 = DateTime.ParseExact ("Sun Nov 6 08:49:37 1994", formats[2], enUS,
+ DateTimeStyles.AllowWhiteSpaces);
+ Assert.AreEqual (myTicks [6], t1.Ticks, "#J3");
+ t1 = DateTime.ParseExact ("Sun, 06 Nov 1994 08:49:37 GMT", formats, enUS,
+ DateTimeStyles.AllowWhiteSpaces);
+ Assert.AreEqual (myTicks [6], t1.Ticks, "#J4");
+ t1 = DateTime.ParseExact ("Sunday, 06-Nov-94 08:49:37 GMT", formats, enUS,
+ DateTimeStyles.AllowWhiteSpaces);
+ Assert.AreEqual (myTicks [6], t1.Ticks, "#J5");
+ t1 = DateTime.ParseExact ("Sun Nov 6 08:49:37 1994", formats, enUS,
+ DateTimeStyles.AllowWhiteSpaces);
+ Assert.AreEqual (myTicks [6], t1.Ticks, "#J6");
+ t1 = DateTime.ParseExact ("Monday, 25 February 2002 05:25:13",
+ "ddddddd, dd MMMMMMM yyyy HHHHH:mmmmm:sssss",
+ null, DateTimeStyles.AdjustToUniversal);
+ Assert.AreEqual (myTicks[4], t1.Ticks, "#J7");
+
+ // Bug 52274
+ t1 = DateTime.ParseExact ("--12--", "--MM--" , null);
+ Assert.AreEqual (12, t1.Month, "#K1");
+ t1=DateTime.ParseExact ("--12-24", "--MM-dd" , null);
+ Assert.AreEqual (24, t1.Day, "#K2");
+ Assert.AreEqual (12, t1.Month, "#K3");
+ t1=DateTime.ParseExact ("---24", "---dd" , null);
+ Assert.AreEqual (24, t1.Day, "#K4");
+
+ // Bug 63376
+ t1 = DateTime.ParseExact ("18Aug2004 12:33:00", "ddMMMyyyy hh:mm:ss", new CultureInfo ("en-US"));
+ Assert.AreEqual (0, t1.Hour, "hh allows 12, though it's useless");
+
+ // Bug 74775
+ DateTime.ParseExact ("Tue, 12 Apr 2005 10:10:04 +0100",
+ "Tue, 12 Apr 2005 10:10:04 +0100", enUS);
+ try {
+ DateTime.ParseExact ("Tue, 12 Apr 2005 10:10:04 +00000",
+ "ddd, dd MMM yyyy HH':'mm':'ss zzz", enUS);
+ Assert.Fail ("#L1");
+ } catch (FormatException) {
+ }
+
+ // Bug #75213 : literal escaping.
+ t1 = DateTime.ParseExact ("20050707132527Z",
+ "yyyyMMddHHmmss\\Z", CultureInfo.InvariantCulture);
+ Assert.AreEqual (632563395270000000, t1.Ticks, "#L2");
+
+ // XAttributeTest.CastDateTimeOffsets():#6b
+ // It is said broken, probably due to timezone difference.
+ //t1 = DateTime.ParseExact ("2039-10-31T12:34:56.7552+00:00", "yyyy-MM-ddTHH:mm:ss.FFFFFFFzzz",
+ // CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal);
+ //Assert.AreEqual (643393064967552000, t1.Ticks, "#M");
+ }
+
+ [Test]
+ [Ignore ("need to fix tests that run on different timezones")]
+ public void TestParse2 ()
+ {
+ DateTime t1 = DateTime.Parse ("Mon, 25 Feb 2002 04:25:13 GMT");
+ t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1);
+ Assert.AreEqual (04 - TimeZone.CurrentTimeZone.GetUtcOffset (t1).Hours, t1.Hour);
+ }
+
+ [Test]
+ public void TestParseDateFirst ()
+ {
+ // Standard patterns
+ CultureInfo USCultureInfo = new CultureInfo("en-US");
+ DateTime t1 = DateTime.Parse ("02/25/2002", USCultureInfo);
+ Assert.AreEqual (myTicks [0], t1.Ticks, "#A1");
+ t1 = DateTime.Parse ("2002-02-25", USCultureInfo);
+ Assert.AreEqual (myTicks [0], t1.Ticks, "#A2");
+ t1 = DateTime.Parse ("Monday, 25 February 2002");
+ Assert.AreEqual (myTicks [0], t1.Ticks, "#A3");
+ t1 = DateTime.Parse ("Monday, 25 February 2002 05:25");
+ Assert.AreEqual (myTicks [3], t1.Ticks, "#A4");
+ t1 = DateTime.Parse ("Monday, 25 February 2002 05:25:13");
+ Assert.AreEqual (myTicks [4], t1.Ticks, "#A5");
+ t1 = DateTime.Parse ("02/25/2002 05:25", USCultureInfo);
+ Assert.AreEqual (myTicks [3], t1.Ticks, "#A6");
+ t1 = DateTime.Parse ("02/25/2002 05:25:13", USCultureInfo);
+ Assert.AreEqual (myTicks [4], t1.Ticks, "#A7");
+ t1 = DateTime.Parse ("2002-02-25 04:25:13Z");
+ t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1);
+ Assert.AreEqual (2002, t1.Year, "#A8");
+ Assert.AreEqual (02, t1.Month, "#A9");
+ Assert.AreEqual (25, t1.Day, "#A10");
+ Assert.AreEqual (04, t1.Hour, "#A11");
+ Assert.AreEqual (25, t1.Minute, "#A12");
+ Assert.AreEqual (13, t1.Second, "#A13");
+ t1 = DateTime.Parse ("Mon,02/25/2002", USCultureInfo);
+ Assert.AreEqual (myTicks [0], t1.Ticks, "#A14");
+ DateTime t2 = new DateTime (1999, 1, 2, 0, 3, 4);
+ t1 = DateTime.Parse (t2.ToLongTimeString ());
+ Assert.AreEqual (0, t1.Hour, "#A14");
+
+ // parsed as UTC string
+ t1 = DateTime.Parse ("Mon, 25 Feb 2002 04:25:13 GMT");
+ t1 = TimeZone.CurrentTimeZone.ToUniversalTime (t1);
+ Assert.AreEqual (2002, t1.Year, "#C1");
+ Assert.AreEqual (02, t1.Month, "#C2");
+ Assert.AreEqual (25, t1.Day, "#C3");
+ Assert.AreEqual (4, t1.Hour, "#C4");
+ Assert.AreEqual (25, t1.Minute, "#C5");
+ Assert.AreEqual (13, t1.Second, "#C6");
+
+ // Some date 'T' time formats
+#if NET_2_0 // Net_1_1 requires hh:mm:ss
+ t1 = DateTime.Parse ("2002-02-25T05:25");
+ Assert.AreEqual (myTicks [3], t1.Ticks, "#D1");
+#endif
+ t1 = DateTime.Parse ("2002-02-25T05:25:13");
+ Assert.AreEqual (myTicks [4], t1.Ticks, "#D1");
+ t1 = DateTime.Parse ("2002-02-25T05:25:13.008");
+ Assert.AreEqual (myTicks [2], t1.Ticks, "#D1");
+ t1 = DateTime.Parse ("02-2002-25T05:25:13");
+ Assert.AreEqual (myTicks [4], t1.Ticks, "#D1");
+
+ // Day month
+ t2 = new DateTime (DateTime.Today.Year, 2, 25);
+ t1 = DateTime.Parse ("February 25", USCultureInfo);
+ Assert.AreEqual (t2.Ticks, t1.Ticks, "#B1");
+
+ t2 = new DateTime (DateTime.Today.Year, 2, 8);
+ t1 = DateTime.Parse ("February 08", USCultureInfo);
+ Assert.AreEqual (t2.Ticks, t1.Ticks, "#B2");
+
+ t2 = new DateTime (DateTime.Today.Year, 2, 8);
+ t1 = DateTime.Parse ("February 8", USCultureInfo);
+ Assert.AreEqual (t2.Ticks, t1.Ticks, "#D6");
+
+ // Month year
+ t2 = new DateTime (2002, 2, 1);
+ t1 = DateTime.Parse ("2002 February");
+ Assert.AreEqual (t2.Ticks, t1.Ticks, "#D4");
+
+ t2 = new DateTime (2002, 2, 1);
+ t1 = DateTime.Parse ("2002 February", new CultureInfo ("ja-JP"));
+ Assert.AreEqual (t2.Ticks, t1.Ticks, "#D5");
+
+ // bug #72132
+ t2 = new DateTime (2002, 2, 25, 5, 25, 22);
+ t1 = DateTime.Parse ("Monday, 25 February 2002 05:25:22",
+ new CultureInfo ("hi-IN"));
+ Assert.AreEqual (t2.Ticks, t1.Ticks, "#D7");
+ t2 = new DateTime (2002, 2, 25, 5, 25, 0);
+ t1 = DateTime.Parse ("Monday, 25 February 2002 05:25",
+ new CultureInfo ("hi-IN"));
+ Assert.AreEqual (t2.Ticks, t1.Ticks, "#D8");
+
+ // MM-yyyy-dd + different time formats
+ t1 = DateTime.Parse ("02-2002-25 05:25", USCultureInfo);
+ Assert.AreEqual (myTicks[3], t1.Ticks, "#E1");
+ t1 = DateTime.Parse ("02-2002-25 05:25:13", USCultureInfo);
+ Assert.AreEqual (myTicks[4], t1.Ticks, "#E1");
+ t1 = DateTime.Parse ("02-2002-25 05:25:13 Mon", USCultureInfo);
+ Assert.AreEqual (myTicks[4], t1.Ticks, "#E2");
+ t1 = DateTime.Parse ("02-2002-25 05:25:13 Monday", USCultureInfo);
+ Assert.AreEqual (myTicks[4], t1.Ticks, "#E3");
+ t1 = DateTime.Parse ("02-2002-25 05:25:13.008", USCultureInfo);
+ Assert.AreEqual (myTicks[2], t1.Ticks, "#E4");
+
+ // Formats with timezone
+ long offset = TimeZone.CurrentTimeZone.GetUtcOffset(t1).Ticks;
+ long hourTicks = 36000000000L;
+ long halfHourTicks = hourTicks / 2;
+ t1 = DateTime.Parse ("02-2002-25 05:25+01", USCultureInfo);
+ Assert.AreEqual (myTicks[3], t1.Ticks + hourTicks - offset, "#F1");
+ t1 = DateTime.Parse ("02-2002-25 05:25-01", USCultureInfo);
+ Assert.AreEqual (myTicks[3], t1.Ticks - hourTicks - offset, "#F2");
+ t1 = DateTime.Parse ("02-2002-25 05:25+00:30", USCultureInfo);
+ Assert.AreEqual (myTicks[3], t1.Ticks + hourTicks/2 - offset, "#F3");
+ t1 = DateTime.Parse ("02-2002-25 05:25:13+02", USCultureInfo);
+ Assert.AreEqual (myTicks[4], t1.Ticks + 2*hourTicks - offset, "#F4");
+#if NET_2_0
+ // NET 1.0 doesn't accept second fractions and time zone.
+ t1 = DateTime.Parse ("2002-02-25 05:25:13.008-02");
+ Assert.AreEqual (myTicks[2], t1.Ticks - 2*hourTicks - offset, "#F5");
+ // NET 1.0 doesn't parse well time zone with AM afterwards.
+ t1 = DateTime.Parse ("02-25-2002 05:25:13-02 AM", USCultureInfo);
+ Assert.AreEqual (myTicks[4], t1.Ticks - 2*hourTicks - offset, "#F6");
+ t1 = DateTime.Parse ("25 Feb 2002 05:25:13-02 AM", USCultureInfo);
+ Assert.AreEqual (myTicks[4], t1.Ticks - 2*hourTicks - offset, "#F6");
+#endif
+ }
+
+ [Test]
+ public void TestParseTimeFirst ()
+ {
+ CultureInfo USCultureInfo = new CultureInfo("en-US");
+
+ // Hour only patterns
+ DateTime t2 = DateTime.Today + new TimeSpan (5,25,0);
+ DateTime t1 = DateTime.Parse ("05:25");
+ Assert.AreEqual (t2.Ticks, t1.Ticks, "#C1");
+ t2 = DateTime.Today + new TimeSpan (5,25,13);
+ t1 = DateTime.Parse ("05:25:13");
+ Assert.AreEqual (t2.Ticks, t1.Ticks, "#B2");
+
+ // Test with different date formats
+ t1 = DateTime.Parse ("05:25 02/25/2002", USCultureInfo);
+ Assert.AreEqual (myTicks[3], t1.Ticks, "#B1");
+ t1 = DateTime.Parse ("05:25:13 2002-02-25");
+ Assert.AreEqual (myTicks[4], t1.Ticks, "#B2");
+ t1 = DateTime.Parse ("05:25:13.008 02-2002-25");
+ Assert.AreEqual (myTicks[2], t1.Ticks, "#B3");
+ t1 = DateTime.Parse ("05:25:13.008 Feb 25 2002");
+ Assert.AreEqual (myTicks[2], t1.Ticks, "#B4");
+ t1 = DateTime.Parse ("05:25:13.008 25 Feb 2002");
+ Assert.AreEqual (myTicks[2], t1.Ticks, "#B5");
+
+ // Add AM and day of the week
+ t1 = DateTime.Parse ("AM 05:25:13 2002-02-25");
+ Assert.AreEqual (myTicks[4], t1.Ticks, "#C1");
+ t1 = DateTime.Parse ("Monday05:25 02/25/2002", USCultureInfo);
+ Assert.AreEqual (myTicks[3], t1.Ticks, "#C2");
+ t1 = DateTime.Parse ("Mon 05:25 AM 02/25/2002", USCultureInfo);
+ Assert.AreEqual (myTicks[3], t1.Ticks, "#C3");
+ t1 = DateTime.Parse ("AM 05:25 Monday, 02/25/2002", USCultureInfo);
+ Assert.AreEqual (myTicks[3], t1.Ticks, "#C4");
+ t1 = DateTime.Parse ("05:25 02/25/2002 Monday", USCultureInfo);
+ Assert.AreEqual (myTicks[3], t1.Ticks, "#C5");
+ t1 = DateTime.Parse ("PM 03:25:13.008 02-2002-25");
+ Assert.AreEqual (myTicks[1], t1.Ticks, "#C6");
+
+ // ASP.NET QuickStarts
+ t2 = new DateTime (2002, 10, 7, 15, 6, 0);
+ t1 = DateTime.Parse ("3:06 PM 10/7/2002", USCultureInfo);
+ Assert.AreEqual (t2.Ticks, t1.Ticks, "#D1");
+ t2 = new DateTime (2002, 10, 7, 15, 6, 0);
+ t1 = DateTime.Parse ("3:06 pm 10/7/2002", USCultureInfo);
+ Assert.AreEqual (t2.Ticks, t1.Ticks, "#D2");
+ t2 = new DateTime (2002, 10, 7, 3, 6, 0);
+ t1 = DateTime.Parse ("3:06 AM 10/7/2002", USCultureInfo);
+ Assert.AreEqual (t2.Ticks, t1.Ticks, "#D3");
+ t2 = new DateTime (2002, 10, 7, 3, 6, 0);
+ t1 = DateTime.Parse ("3:06 am 10/7/2002", USCultureInfo);
+ Assert.AreEqual (t2.Ticks, t1.Ticks, "#D4");
+ }
+
+ [Test]
+ public void TestParseWithDifferentShortDatePatterns ()
+ {
+ CultureInfo cultureInfo = new CultureInfo("en-US");
+ DateTimeFormatInfo dateFormatInfo = cultureInfo.DateTimeFormat;
+ DateTime t1 = DateTime.Parse ("02/01/2003", cultureInfo);
+ Assert.AreEqual (myTicks[7], t1.Ticks, "#A1");
+
+ // Day, month year behaviour
+ dateFormatInfo.ShortDatePattern = "dd/MM/yyyy";
+ t1 = DateTime.Parse ("01/02/03", cultureInfo);
+ Assert.AreEqual (myTicks[7], t1.Ticks, "#B1");
+ t1 = DateTime.Parse ("01/02/2003", cultureInfo);
+ Assert.AreEqual (myTicks[7], t1.Ticks, "#B2");
+ t1 = DateTime.Parse ("2003/02/01", cultureInfo);
+ Assert.AreEqual (myTicks[7], t1.Ticks, "#B3");
+ t1 = DateTime.Parse ("01/Feb/03", cultureInfo);
+ Assert.AreEqual (myTicks[7], t1.Ticks, "#B4");
+ t1 = DateTime.Parse ("Feb/01/03", cultureInfo);
+ Assert.AreEqual (myTicks[7], t1.Ticks, "#B5");
+
+ // Month, day year behaviour
+ dateFormatInfo.ShortDatePattern = "MM/dd/yyyy";
+ t1 = DateTime.Parse ("02/01/03", cultureInfo);
+ Assert.AreEqual (myTicks[7], t1.Ticks, "#C1");
+ t1 = DateTime.Parse ("02/01/2003", cultureInfo);
+ Assert.AreEqual (myTicks[7], t1.Ticks, "#C2");
+ t1 = DateTime.Parse ("2003/02/01", cultureInfo);
+ Assert.AreEqual (myTicks[7], t1.Ticks, "#C3");
+ t1 = DateTime.Parse ("01/Feb/03", cultureInfo);
+ Assert.AreEqual (myTicks[7], t1.Ticks, "#C4");
+ t1 = DateTime.Parse ("Feb/01/03", cultureInfo);
+ Assert.AreEqual (myTicks[7], t1.Ticks, "#C5");
+
+ // Year, month day behaviour
+ dateFormatInfo.ShortDatePattern = "yyyy/MM/dd";
+ t1 = DateTime.Parse ("03/02/01", cultureInfo);
+ Assert.AreEqual (myTicks[7], t1.Ticks, "#D1");
+ t1 = DateTime.Parse ("02/01/2003", cultureInfo);
+ Assert.AreEqual (myTicks[7], t1.Ticks, "#D2");
+ t1 = DateTime.Parse ("2003/02/01", cultureInfo);
+ Assert.AreEqual (myTicks[7], t1.Ticks, "#D3");
+ t1 = DateTime.Parse ("03/Feb/01", cultureInfo);
+ Assert.AreEqual (myTicks[7], t1.Ticks, "#D4");
+ t1 = DateTime.Parse ("Feb/03/01", cultureInfo);
+ Assert.AreEqual (myTicks[7], t1.Ticks, "#D5");
+
+ // Year, day month behaviour
+ // Note that no culture I am aware of has this pattern, and indeed
+ dateFormatInfo.ShortDatePattern = "yyyy/dd/MM";
+ t1 = DateTime.Parse ("03/01/02", cultureInfo);
+ Assert.AreEqual (myTicks[7], t1.Ticks, "#E1");
+ t1 = DateTime.Parse ("01/02/2003", cultureInfo);
+ Assert.AreEqual (myTicks[7], t1.Ticks, "#E2");
+#if NET_2_0
+ t1 = DateTime.Parse ("2003/01/02", cultureInfo);
+ Assert.AreEqual (myTicks[7], t1.Ticks, "#E3");
+#else
+ t1 = DateTime.Parse ("2003/02/01", cultureInfo);
+ Assert.AreEqual (myTicks[7], t1.Ticks, "#E3");
+#endif
+ // For some reason the following throws an exception on .Net
+ // t1 = DateTime.Parse ("03/Feb/01", cultureInfo);
+ // Assert.AreEqual (myTicks[7], t1.Ticks, "#E4");
+ // t1 = DateTime.Parse ("03/01/Feb", cultureInfo);
+ // Assert.AreEqual (myTicks[7], t1.Ticks, "#E5");
+ // t1 = DateTime.Parse ("Feb/01/03", cultureInfo);
+ // Assert.AreEqual (myTicks[7], t1.Ticks, "#E6");
+ }
+
+ [Test]
+ public void TestParseWithDifferentMonthDayPatterns ()
+ {
+ CultureInfo cultureInfo = new CultureInfo("en-US");
+ DateTimeFormatInfo dateFormatInfo = cultureInfo.DateTimeFormat;
+ DateTime t1 = DateTime.Parse ("Feb 03", cultureInfo);
+ Assert.AreEqual (2, t1.Month, "#A1");
+ Assert.AreEqual (3, t1.Day, "#A2");
+
+ // Day month behaviour
+ dateFormatInfo.MonthDayPattern = "dd/MM";
+#if NET_2_0
+ t1 = DateTime.Parse ("Feb 03", cultureInfo);
+ Assert.AreEqual (2, t1.Month, "#B1");
+ Assert.AreEqual (1, t1.Day, "#B2");
+ Assert.AreEqual (2003, t1.Year, "#B3");
+#else // In .Net 1.0 "Feb 03" is always Feb 3rd (and not Feb 2003).
+ t1 = DateTime.Parse ("Feb 03", cultureInfo);
+ Assert.AreEqual (2, t1.Month, "#B4");
+ Assert.AreEqual (3, t1.Day, "#B5");
+#endif
+ t1 = DateTime.Parse ("03/02", cultureInfo);
+ Assert.AreEqual (2, t1.Month, "#B6");
+ Assert.AreEqual (3, t1.Day, "#B7");
+ t1 = DateTime.Parse ("03 Feb", cultureInfo);
+ Assert.AreEqual (2, t1.Month, "#B8");
+ Assert.AreEqual (3, t1.Day, "#B9");
+
+ // Month day behaviour
+ dateFormatInfo.MonthDayPattern = "MM/dd";
+ t1 = DateTime.Parse ("Feb 03", cultureInfo);
+ Assert.AreEqual (2, t1.Month, "#C1");
+ Assert.AreEqual (3, t1.Day, "#C2");
+ t1 = DateTime.Parse ("02/03", cultureInfo);
+ Assert.AreEqual (2, t1.Month, "#C3");
+ Assert.AreEqual (3, t1.Day, "#C4");
+ t1 = DateTime.Parse ("03 Feb", cultureInfo);
+ Assert.AreEqual (2, t1.Month, "#C5");
+ Assert.AreEqual (3, t1.Day, "#C6");
+ }
+
+ [Test]
+ public void TestParse3 ()
+ {
+ string s = "Wednesday, 09 June 2004";
+ DateTime.ParseExact (s, "dddd, dd MMMM yyyy", CultureInfo.InvariantCulture);
+ try {
+ DateTime.ParseExact (s, "dddd, dd MMMM yyyy", new CultureInfo ("ja-JP"));
+ Assert.Fail ("ja-JP culture does not support format \"dddd, dd MMMM yyyy\"");
+ } catch (FormatException) {
+ }
+
+ // Ok, now we can assume ParseExact() works expectedly.
+
+ DateTime.Parse (s, CultureInfo.InvariantCulture, DateTimeStyles.AllowWhiteSpaces);
+ DateTime.Parse (s, new CultureInfo ("ja-JP"), DateTimeStyles.AllowWhiteSpaces);
+ //DateTime.Parse (s, null); currently am not sure if it works for _every_ culture.
+ }
+
+
+ [Test] // bug #74936
+ public void TestParse4 ()
+ {
+ try {
+ DateTime.Parse("1");
+ Assert.Fail ("#1");
+ } catch (FormatException) {
+ }
+
+ try {
+ DateTime.Parse("1000");
+ Assert.Fail ("#2");
+ } catch (FormatException) {
+ }
+
+ try {
+ DateTime.Parse("8:");
+ Assert.Fail ("#3");
+ } catch (FormatException) {
+ }
+ }
+
+ [Test] // bug #71289
+ public void Parse_Bug71289a ()
+ {
+ DateTime.Parse ("Sat,,,,,, 01 Oct 1994 03:00:00", CultureInfo.InvariantCulture);
+ }
+
+ [Test]
+ public void Parse_Bug71289b ()
+ {
+ // more example...
+ DateTime.Parse ("Sat,,, 01,,, Oct,,, ,,,1994 03:00:00", CultureInfo.InvariantCulture);
+ }
+
+#if NET_2_0
+ [Test]
+ [ExpectedException (typeof (FormatException))]
+ public void Parse_CommaAfterHours ()
+ {
+ // ',' after 03 is not allowed.
+ DateTime.Parse ("Sat,,, 01,,, Oct,,, ,,,1994 03,:00:00", CultureInfo.InvariantCulture);
+ }
+#endif
+
+ [Test] // bug #72788
+ public void Parse_Bug72788 ()
+ {
+ DateTime dt = DateTime.Parse ("21/02/05", new CultureInfo ("fr-FR"));
+ Assert.AreEqual (2005, dt.Year, "#1");
+ Assert.AreEqual (02, dt.Month, "#2");
+ Assert.AreEqual (21, dt.Day, "#3");
+ }
+
+ [Test] // bug #322510
+ public void Parse_HourDesignator ()
+ {
+ DateTime dt;
+ DateTime now = DateTime.Now;
+
+ dt = DateTime.Parse ("12:00:00 AM", new CultureInfo ("en-US"));
+ Assert.AreEqual (now.Year, dt.Year, "#A1");
+ Assert.AreEqual (now.Month, dt.Month, "#A2");
+ Assert.AreEqual (now.Day, dt.Day, "#A3");
+ Assert.AreEqual (0, dt.Hour, "#A4");
+ Assert.AreEqual (0, dt.Minute, "#A5");
+ Assert.AreEqual (0, dt.Second, "#A6");
+ Assert.AreEqual (0, dt.Millisecond, "#A7");
+
+ dt = DateTime.Parse ("12:00:00 PM", new CultureInfo ("en-US"));
+ Assert.AreEqual (now.Year, dt.Year, "#B1");
+ Assert.AreEqual (now.Month, dt.Month, "#B2");
+ Assert.AreEqual (now.Day, dt.Day, "#B3");
+ Assert.AreEqual (12, dt.Hour, "#B4");
+ Assert.AreEqual (0, dt.Minute, "#B5");
+ Assert.AreEqual (0, dt.Second, "#B6");
+ Assert.AreEqual (0, dt.Millisecond, "#B7");
+ }
+
+ [Test]
+#if NET_4_0
+ [Ignore ("Current-culture dependent test, which is not valid in 4.0 anymore")]
+#else
+ // FIXME: This test doesn't work on cultures like es-DO which have patterns
+ // for both dd/MM/yyyy & MM/dd/yyyy
+ [Category ("NotWorking")]
+#endif
+ public void Parse_Bug53023a ()
+ {
+ foreach (CultureInfo ci in CultureInfo.GetCultures (CultureTypes.SpecificCultures)) {
+ FormatException e = null;
+ try {
+ // this fails for MOST culture under MS 1.1 SP1
+ DateTime.Parse ("8/16/2005", ci);
+ }
+ catch (FormatException fe) {
+ e = fe;
+ }
+ string c = ci.ToString ();
+ switch (c) {
+ case "af-ZA":
+ case "en-CB":
+ case "en-PH":
+ case "en-US":
+ case "en-ZA":
+ case "en-ZW":
+ case "es-PA":
+ case "eu-ES":
+ case "fa-IR":
+ case "fr-CA":
+ case "hu-HU":
+ case "ja-JP":
+ case "ko-KR":
+ case "lv-LV":
+ case "lt-LT":
+ case "mn-MN":
+ case "pl-PL":
+ case "sq-AL":
+ case "sv-SE":
+ case "sw-KE":
+ case "zh-CN":
+ case "zh-TW":
+#if NET_2_0
+ case "bo-CN": // new in 3.5?
+ case "en-029": // new in 3.5...WTF is it?
+ case "es-US": // new in 3.5?
+ case "fil-PH": // new in 3.5?
+ case "ii-CN": // new in 3.5?
+ case "km-KH": // new in 3.5?
+ case "mn-Mong-CN": // new in 3.5?
+ case "moh-CA": // new in 3.5?
+ case "ne-NP": // new in 3.5?
+ case "ns-ZA":
+ case "nso-ZA":
+ case "rw-RW": // new in 3.5?
+ case "sah-RU": // new in 3.5?
+ case "se-SE":
+ case "si-LK": // new in 3.5?
+ case "sma-SE":
+ case "smj-SE":
+ case "tn-ZA":
+ case "ug-CN": // new in 3.5?
+ case "xh-ZA":
+ case "zu-ZA":
+#endif
+ Assert.IsNull (e, c);
+ break;
+ default:
+ Assert.IsNotNull (e, c);
+ break;
+ }
+ }
+ }
+
+ [Test]
+ public void Parse_Bug53023b ()
+ {
+ foreach (CultureInfo ci in CultureInfo.GetCultures (CultureTypes.SpecificCultures)) {
+ DateTime.Parse ("01-Sep-05", ci);
+ DateTime.Parse ("4:35:35 AM", ci);
+ }
+ }
+
+ [Test]
+ [ExpectedException (typeof (FormatException))]
+ [Category ("NotWorking")]
+ public void Parse_RequireSpaceSeparator ()
+ {
+ DateTime.Parse ("05:25:132002-02-25", CultureInfo.InvariantCulture);
+ }
+
+ [Test]
+ [ExpectedException (typeof (FormatException))]
+ public void Parse_DontAccept2DigitsYears ()
+ {
+ // don't allow 2 digit years where we require 4.
+ DateTime.ParseExact ("05", "yyyy", CultureInfo.InvariantCulture);
+ }
+
+ [Test]
+ [ExpectedException (typeof (FormatException))]
+ public void Parse_DontAcceptEmptyHours ()
+ {
+ DateTime.ParseExact (":05", "H:m", CultureInfo.InvariantCulture);
+ }
+
+ [Test]
+ [ExpectedException (typeof (FormatException))]
+ public void Parse_DontAcceptEmptyMinutes ()
+ {
+ DateTime.ParseExact ("0::0", "H:m:s", CultureInfo.InvariantCulture);
+ }
+
+ [Test]
+ public void ParseCOMDependentFormat ()
+ {
+ // Japanese format.
+ DateTime.Parse (String.Format (
+ "{0}\u5E74{1}\u6708{2}\u65E5 {3}\u6642{4}\u5206{5}\u79D2",
+ 2006, 3, 1, 15, 32, 42), new CultureInfo (""));
+
+ try {
+ // incorrect year mark.
+ DateTime.Parse (String.Format (
+ "{0}\u4E00{1}\u6708{2}\u65E5 {3}\u6642{4}\u5206{5}\u79D2",
+ 2006, 3, 1, 15, 32, 42), new CultureInfo (""));
+ Assert.Fail ();
+ } catch (FormatException) {
+ }
+ }
+
+ [Test]
+ [ExpectedException(typeof (FormatException))]
+ public void ParseFormatException1 ()
+ {
+ // Following string is not a correct French date i.e.
+ // MM/dd/yyyy HH:mm:ss since it expects d/M/yyyy HH:mm:ss
+ // instead (however fr-FR accepts both MM/dd/yyyy and
+ // dd/MM/yyyy, which means that we can't just throw exceptions
+ // on overflow).
+ String frDateTime = "11/13/2003 11:28:15";
+ IFormatProvider format = new CultureInfo("fr-FR", true);
+ DateTime t1 = DateTime.Parse(frDateTime, format);
+ }
+
+ [Test]
+#if NET_2_0
+ [ExpectedException(typeof (FormatException))]
+#else
+ [ExpectedException(typeof (ArgumentOutOfRangeException))]
+#endif
+ public void ParseFormatExceptionForInvalidYear ()
+ {
+ // Bug #77633. In .NET 1..1, the expected exception is ArgumentOutOfRangeException
+ // In .NET 2.0, the expected exception is FormatException
+ // build a string with the year of 5 digits
+ string s = "1/1/10000";
+ DateTime dt = DateTime.Parse (s);
+ }
+
+ [Test]
+ public void TestOA ()
+ {
+ double number=5000.41443;
+ DateTime d = DateTime.FromOADate(number);
+ DTAssertEquals (d, new DateTime(1913, 9, 8, 9, 56, 46, 0), Resolution.Second, "#1");
+ Assert.AreEqual (d.ToOADate(), number, "#2");
+ }
+
+ [Test]
+ public void ParseAllowsQueerString ()
+ {
+ DateTime.Parse ("Sat,,,,,, 01 Oct 1994 03:00:00", CultureInfo.InvariantCulture);
+ }
+
+ [Test]
+ public void ParseUtcNonUtc ()
+ {
+ Thread.CurrentThread.CurrentCulture = new CultureInfo ("es-ES");
+
+ CultureInfo ci;
+ string s, s2, s3, d;
+ DateTime dt;
+ DateTimeFormatInfo dfi = DateTimeFormatInfo.InvariantInfo;
+ s = dfi.UniversalSortableDateTimePattern;
+ s2 = "r";
+
+ s3 = "s";
+
+ long tick1 = 631789220960000000; // 2003-01-23 12:34:56 as is
+ long tick2 = TimeZone.CurrentTimeZone.ToLocalTime (new DateTime (tick1)).Ticks; // adjusted to local time
+
+ // invariant
+ ci = CultureInfo.InvariantCulture;
+
+ d = "2003/01/23 12:34:56";
+ dt = DateTime.Parse (d, ci);
+ Assert.AreEqual (tick1, dt.Ticks, "#1:" + d);
+
+ d = "2003/01/23 12:34:56 GMT";
+ dt = DateTime.Parse (d, ci);
+ Assert.AreEqual (tick2, dt.Ticks, "#2:" + d);
+
+ d = "Thu, 23 Jan 2003 12:34:56 GMT";
+ dt = DateTime.ParseExact (d, s2, ci);
+ Assert.AreEqual (tick1, dt.Ticks, "#3:" + d);
+
+ d = "2003-01-23 12:34:56Z";
+ dt = DateTime.ParseExact (d, s, ci);
+ Assert.AreEqual (tick1, dt.Ticks, "#4:" + d);
+
+ d = "2003-01-23T12:34:56";
+ dt = DateTime.ParseExact (d, s3, ci);
+ Assert.AreEqual (tick1, dt.Ticks, "#5:" + d);
+
+ // ja-JP ... it should be culture independent
+ ci = new CultureInfo ("ja-JP");
+
+ d = "2003/01/23 12:34:56";
+ dt = DateTime.Parse (d, ci);
+ Assert.AreEqual (tick1, dt.Ticks, "#6:" + d);
+
+ d = "2003/01/23 12:34:56 GMT";
+ dt = DateTime.Parse (d, ci);
+ Assert.AreEqual (tick2, dt.Ticks, "#7:" + d);
+
+ d = "Thu, 23 Jan 2003 12:34:56 GMT";
+ dt = DateTime.ParseExact (d, s2, ci);
+ Assert.AreEqual (tick1, dt.Ticks, "#8:" + d);
+
+ d = "2003-01-23 12:34:56Z";
+ dt = DateTime.ParseExact (d, s, ci);
+ Assert.AreEqual (tick1, dt.Ticks, "#9:" + d);
+
+ d = "2003-01-23T12:34:56";
+ dt = DateTime.ParseExact (d, s3, ci);
+ Assert.AreEqual (tick1, dt.Ticks, "#10:" + d);
+ }
+
+ [Test]
+ public void TimeZoneAdjustment ()
+ {
+ CultureInfo ci = Thread.CurrentThread.CurrentCulture;
+ try {
+ Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US");
+ DateTime d1 = DateTime.ParseExact ("2004/06/30", "yyyy/MM/dd", null);
+ DateTime d2 = DateTime.ParseExact ("2004/06/30Z", "yyyy/MM/dd'Z'", null);
+ DateTime d3 = DateTime.ParseExact ("Wed, 30 Jun 2004 00:00:00 GMT", "ddd, dd MMM yyyy HH':'mm':'ss 'GMT'", null);
+ DateTime d4 = DateTime.ParseExact ("2004-06-30 00:00:00Z", "yyyy'-'MM'-'dd HH':'mm':'ss'Z'", null);
+ StringWriter sw = new StringWriter ();
+ sw.Write ("{0} {1}", d1.Ticks, d1);
+ Assert.AreEqual ("632241504000000000 6/30/2004 12:00:00 AM", sw.ToString (), "#1");
+ sw.GetStringBuilder ().Length = 0;
+ sw.Write ("{0} {1}", d2.Ticks, d2);
+ Assert.AreEqual ("632241504000000000 6/30/2004 12:00:00 AM", sw.ToString (), "#2");
+ sw.GetStringBuilder ().Length = 0;
+ sw.Write ("{0} {1}", d3.Ticks, d3);
+ Assert.AreEqual ("632241504000000000 6/30/2004 12:00:00 AM", sw.ToString (), "#3");
+ sw.GetStringBuilder ().Length = 0;
+ sw.Write ("{0} {1}", d4.Ticks, d4);
+ Assert.AreEqual ("632241504000000000 6/30/2004 12:00:00 AM", sw.ToString (), "#4");
+ } finally {
+ Thread.CurrentThread.CurrentCulture = ci;
+ }
+
+ // bug #76082
+ Assert.AreEqual (DateTime.MinValue, DateTime.ParseExact ("00010101T00:00:00",
+ "yyyyMMdd'T'HH':'mm':'ss", DateTimeFormatInfo.InvariantInfo), "#5");
+ }
+
+ [Test]
+ public void DateTimeStylesAdjustToUniversal ()
+ {
+ // bug #75995 : AdjustToUniversal
+ DateTime t1 = DateTime.Parse ("2005-09-05T22:29:00Z",
+ CultureInfo.InvariantCulture,
+ DateTimeStyles.AdjustToUniversal);
+ Assert.AreEqual ("2005-09-05 22:29:00Z", t1.ToString ("u"));
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void FromOADate_Min ()
+ {
+ // minimum documented value isn't inclusive
+ DateTime.FromOADate (-657435.0d);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void FromOADate_Max ()
+ {
+ // maximum documented value isn't inclusive
+ DateTime.FromOADate (2958466.0d);
+ }
+
+ [Test]
+ public void FromOADate ()
+ {
+ // Note: OA (OLE Automation) dates aren't timezone sensitive
+ Assert.AreEqual (599264352000000000, DateTime.FromOADate (0.0d).Ticks, "#1");
+ Assert.AreEqual (31242239136000000, DateTime.FromOADate (-657434.999d).Ticks, "#2");
+ Assert.AreEqual (3155378975136000000, DateTime.FromOADate (2958465.999d).Ticks, "#3");
+ }
+
+ [Test]
+ public void ToOADate ()
+ {
+ // Note: OA (OLE Automation) dates aren't timezone sensitive
+ DateTime d = new DateTime (0);
+ Assert.AreEqual (0.0d, d.ToOADate (), "#1");
+ d = new DateTime (599264352000000000);
+ Assert.AreEqual (0.0d, d.ToOADate (), "#2");
+ d = new DateTime (31242239136000000);
+ Assert.AreEqual (-657434.999d, d.ToOADate (), "#3");
+ d = new DateTime (3155378975136000000);
+ Assert.AreEqual (2958465.999d, d.ToOADate (), "#4");
+ }
+
+ [Test]
+ public void ToOADate_OverMax ()
+ {
+ DateTime d = new DateTime (3155378975136000001);
+ Assert.AreEqual (2958465.999d, d.ToOADate ());
+ }
+
+ [Test]
+ [Ignore ("This test is probably geo location dependent, at least fails on .NET 4.0 in Japan")]
+ public void ToOADate_MaxValue ()
+ {
+ Assert.AreEqual (2958465.99999999d, DateTime.MaxValue.ToOADate ());
+ }
+
+ [Test]
+ public void ToOADate_UnderMin ()
+ {
+ DateTime d = new DateTime (31242239135999999);
+ Assert.AreEqual (-657434.999d, d.ToOADate ());
+ }
+
+ [Test]
+ public void ToOADate_MinValue ()
+ {
+ Assert.AreEqual (0, DateTime.MinValue.ToOADate ());
+ }
+
+ [Test] // bug52075
+ public void MaxValueYear ()
+ {
+ Assert.AreEqual ("9999", DateTime.MaxValue.Year.ToString ());
+ }
+
+ [Test]
+ public void X509Certificate ()
+ {
+ // if this test fails then *ALL* or *MOST* X509Certificate tests will also fails
+ DateTime dt = DateTime.ParseExact ("19960312183847Z", "yyyyMMddHHmmssZ", null);
+#if NET_2_0
+ Assert.AreEqual (DateTimeKind.Local, dt.Kind, "#1");
+ dt = dt.ToUniversalTime ();
+ Assert.AreEqual (DateTimeKind.Utc, dt.Kind, "#2");
+#else
+ dt = dt.ToUniversalTime ();
+#endif
+ Assert.AreEqual ("03/12/1996 18:38:47", dt.ToString (), "#3");
+
+ // technically this is invalid (PKIX) because of the missing seconds but it exists so...
+ dt = DateTime.ParseExact ("9602231915Z", "yyMMddHHmmZ", null);
+#if NET_2_0
+ Assert.AreEqual (DateTimeKind.Local, dt.Kind, "#4");
+ dt = dt.ToUniversalTime ();
+ Assert.AreEqual (DateTimeKind.Utc, dt.Kind, "#5");
+#else
+ dt = dt.ToUniversalTime ();
+#endif
+ Assert.AreEqual ("02/23/1996 19:15:00", dt.ToString (), "#6");
+
+#if NET_2_0
+ dt = DateTime.ParseExact ("19960312183847Z", "yyyyMMddHHmmssZ", null, DateTimeStyles.AdjustToUniversal);
+ Assert.AreEqual (DateTimeKind.Utc, dt.Kind, "#7");
+#endif
+ }
+
+ [Test]
+ public void ZLiteral ()
+ {
+ // However, "Z" and "'Z'" are different.
+ DateTime dt = DateTime.ParseExact ("19960312183847Z", "yyyyMMddHHmmss'Z'", null);
+ DateTime dtz = DateTime.ParseExact ("19960312183847Z", "yyyyMMddHHmmssZ", null);
+#if NET_2_0
+ Assert.AreEqual (DateTimeKind.Unspecified, dt.Kind, "#1");
+ dt = dt.ToLocalTime ();
+ Assert.AreEqual (DateTimeKind.Local, dt.Kind, "#2");
+ Assert.AreEqual (DateTimeKind.Local, dtz.Kind, "#3");
+#else
+ dt = dt.ToLocalTime ();
+#endif
+ Assert.AreEqual (dt, dtz, "#4");
+ }
+
+ [Test] // bug 56436
+ public void QuotedFormat ()
+ {
+ string date = "28/Mar/2004:19:12:37 +0200";
+ string [] expectedFormats = {"dd\"/\"MMM\"/\"yyyy:HH:mm:ss zz\"00\""};
+ DateTime.ParseExact (date, expectedFormats, null, DateTimeStyles.AllowWhiteSpaces);
+ }
+
+ [Test]
+ public void CultureIndependentTests ()
+ {
+ // Here I aggregated some tests mainly because of test
+ // performance (iterating all the culture is heavy process).
+
+ for (int i = 0; i < 32768; i++) {
+ CultureInfo ci = null;
+ string stage = "init";
+ try {
+ try {
+ ci = new CultureInfo (i);
+ // In fact InvatiantCulture is not neutral.
+ // See bug #59716.
+ if (ci.IsNeutralCulture && ci != CultureInfo.InvariantCulture)
+ continue;
+ } catch (Exception) {
+ continue;
+ }
+ Thread.CurrentThread.CurrentCulture = ci;
+ DateTime dt;
+
+ switch (ci.LCID) {
+ case 1025: // ar-SA
+ case 2559: // qps-plocm
+ continue; // fails too many tests below on .NET.
+ }
+
+ // Common patterns
+ // X509Certificate pattern is _always_ accepted.
+ stage = "1";
+ dt = DateTime.ParseExact ("19960312183847Z", "yyyyMMddHHmmssZ", null);
+#if NET_1_1
+ stage = "2";
+ // fails with many cultures on .NET.
+ // if (i != 127)
+ // dt = DateTime.Parse ("19960312183847Z");
+#endif
+ stage = "3";
+ dt = DateTime.Parse ("2004-05-26T03:29:01.1234567");
+ stage = "4";
+ dt = DateTime.Parse ("2004-05-26T03:29:01.1234567-07:00");
+
+ // memo: the least LCID is 127, and then 1025(ar-SA)
+
+ // "th-TH" locale rejects them since in
+ // ThaiBuddhistCalendar the week of a day is different.
+ // (and also for years).
+ switch (ci.LCID) {
+ case 1054:
+ case 1128: // ha-Latn-NG
+ break;
+ default:
+ try {
+ stage = "5";
+ dt = DateTime.Parse ("Sat, 29 Oct 1994 12:00:00 GMT", ci);
+ } catch (FormatException ex) {
+ Assert.Fail (String.Format ("stage 5.1 RFC1123: culture {0} {1} failed: {2}", i, ci, ex.Message));
+ }
+
+ // bug #47720
+ if (dt != TimeZone.CurrentTimeZone.ToUniversalTime (dt))
+ Assert.IsTrue (12 != dt.Hour, String.Format ("bug #47720 on culture {0} {1}", ci.LCID, ci));
+
+ // variant of RFC1123
+ try {
+ stage = "6";
+ dt = DateTime.Parse ("Sat, 1 Oct 1994 03:00:00", ci);
+ } catch (FormatException ex) {
+ Assert.Fail (String.Format ("stage 6.1 RFC1123 variant: culture {0} {1} failed: {2}", i, ci, ex.Message));
+ }
+ stage = "7";
+ Assert.AreEqual (3, dt.Hour, String.Format ("stage 7.1 RFC1123 variant on culture {0} {1}", ci.LCID, ci));
+ break;
+ }
+
+ switch (ci.LCID) {
+ case 1054: // th-TH
+ case 1123: // ps-AF
+ case 1125: // div-MV
+ case 1164: // prs-AF
+ break;
+ default:
+ stage = "8";
+ // 02/25/2002 04:25:13 as is
+ long tick1 = 631502079130000000;
+ long tick2 = TimeZone.CurrentTimeZone.ToLocalTime (new DateTime (tick1)).Ticks; // adjusted to local time
+ dt = DateTime.Parse ("Mon, 25 Feb 2002 04:25:13 GMT", ci);
+ Assert.AreEqual (tick2, dt.Ticks, String.Format ("GMT variant. culture={0} {1}", i, ci));
+ break;
+ }
+
+#if NET_1_1
+ // ka-GE rejects these formats under MS.NET.
+ // I wonder why. Also, those tests fail under .NET 1.0.
+ if (ci.LCID != 1079) {
+ stage = "9";
+ dt = DateTime.Parse ("2002-02-25");
+ stage = "10";
+ dt = DateTime.Parse ("2002-02-25Z");
+ stage = "11";
+ dt = DateTime.Parse ("2002-02-25T19:20:00+09:00");
+ switch (ci.LCID) {
+ case 1038: // FIXME: MS passes this culture.
+ case 1062: // FIXME: MS passes this culture.
+ case 1078: // MS does not pass this culture. Dunno why.
+ break;
+ default:
+#if ONLY_1_1
+ // bug #58938
+ stage = "12";
+ dt = DateTime.Parse ("2002#02#25 19:20:00");
+ // this stage fails under MS 2.0
+ stage = "13";
+ Assert.AreEqual (19, dt.Hour, String.Format ("bug #58938 on culture {0} {1}", ci.LCID, ci));
+#endif
+ break;
+ }
+ stage = "14";
+ dt = DateTime.Parse ("2002-02-25 12:01:03");
+#if ONLY_1_1
+ stage = "15";
+ dt = DateTime.Parse ("2002#02#25 12:01:03");
+ stage = "16";
+ dt = DateTime.Parse ("2002%02%25 12:01:03");
+#endif
+ stage = "17";
+ if (ci.DateTimeFormat.TimeSeparator != ".")
+ dt = DateTime.Parse ("2002.02.25 12:01:03");
+ stage = "18";
+ dt = DateTime.Parse ("2003/01/23 01:34:56 GMT");
+ dt = TimeZone.CurrentTimeZone.ToUniversalTime (dt);
+ Assert.AreEqual (1, dt.Hour, String.Format ("stage 18.1 RFC1123 UTC {0} {1}", i, ci));
+ stage = "19";
+ // This test was fixed from 12:34:56 to
+ // 01:34:56 since 1078 af-ZA failed
+ // because of hour interpretation
+ // difference (af-ZA expects 0).
+ // (IMHO it is MS BUG though.)
+ dt = DateTime.Parse ("2003/01/23 12:34:56 GMT");
+ dt = TimeZone.CurrentTimeZone.ToUniversalTime (dt);
+ if (i != 1078)
+ Assert.AreEqual (12, dt.Hour, String.Format ("stage 18.1 RFC1123 UTC {0} {1}", i, ci));
+ }
+#endif
+ } catch (FormatException ex) {
+ Assert.Fail (String.Format ("stage {3}: Culture {0} {1} failed: {2}", i, ci, ex.Message, stage));
+ }
+ }
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentOutOfRangeException))]
+ public void ToFileTime_MinValue ()
+ {
+ DateTime.FromFileTime (Int64.MinValue);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentOutOfRangeException))]
+ public void ToFileTime_Negative ()
+ {
+ DateTime.FromFileTime (-1);
+ }
+
+ [Test]
+ public void ToFileTime ()
+ {
+ long u = DateTime.FromFileTimeUtc (0).Ticks;
+ Assert.AreEqual (504911232000000000, u, "#A1");
+ long max = DateTime.MaxValue.Ticks - 504911232000000000; // w32file_epoch
+ Assert.AreEqual (3155378975999999999, DateTime.FromFileTimeUtc (max).Ticks, "#A2");
+
+ long t = DateTime.FromFileTime (0).Ticks;
+ Assert.IsTrue (t > (u - TimeSpan.TicksPerDay), "#B1");
+ Assert.IsTrue (t < (u + TimeSpan.TicksPerDay), "#B2");
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentOutOfRangeException))]
+ public void ToFileTimeUtc_MinValue ()
+ {
+ DateTime.FromFileTimeUtc (Int64.MinValue);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentOutOfRangeException))]
+ public void ToFileTimeUtc_Negative ()
+ {
+ DateTime.FromFileTimeUtc (-1);
+ }
+
+ [Test]
+ public void Milliseconds ()
+ {
+ DateTime dt = DateTime.Parse ("2004-05-26T03:29:01.1234567-07:00");
+ dt = TimeZone.CurrentTimeZone.ToUniversalTime (dt);
+ Assert.AreEqual (632211641411234567, dt.Ticks);
+ }
+
+ [Test]
+#if NET_2_0
+ [ExpectedException (typeof (FormatException))]
+#else
+ [Ignore ("Works only under MS 1.x (not Mono or MS 2.0).")]
+#endif
+ public void ParseNotExact ()
+ {
+ // The error reported is:
+ // String was not recognized as valid DateTime
+ DateTime dt = DateTime.Parse ("2004-05-26T03:29:01-07:00 foo");
+ dt = TimeZone.CurrentTimeZone.ToUniversalTime (dt);
+ Assert.AreEqual (632211641410000000, dt.Ticks);
+ }
+
+ [Test]
+ public void ParseExact_Bug80094 ()
+ {
+ // we can safely change the curernt culture, as the original value will
+ // be restored on TearDown
+ Thread.CurrentThread.CurrentCulture = new CultureInfo ("ja-JP");
+ string y = string.Format ("{0}-{1}-{2} {3}", DateTime.Now.Year.ToString (),
+ "11", "29", "06:34");
+ DateTime date = DateTime.ParseExact (y, "yyyy-MMM-dd hh:mm", null);
+ Assert.AreEqual (DateTime.Now.Year, date.Year, "#1");
+ Assert.AreEqual (11, date.Month, "#2");
+ Assert.AreEqual (29, date.Day, "#3");
+ Assert.AreEqual (6, date.Hour, "#4");
+ Assert.AreEqual (34, date.Minute, "#5");
+ Assert.AreEqual (0, date.Second, "#6");
+ Assert.AreEqual (0, date.Millisecond, "#7");
+ }
+
+#if NET_2_0
+ [Test]
+ public void ParseExact_Bug324845 ()
+ {
+ DateTime ctime = new DateTime (2007, 7, 23, 19, 19, 45);
+ ctime = ctime.ToUniversalTime ();
+ string instr = ctime.ToString ("yyyyMMddHHmmss");
+
+ DateTime t = DateTime.ParseExact (instr, "yyyyMMddHHmmss", null, DateTimeStyles.AssumeUniversal);
+ Assert.AreEqual (2007, t.Year);
+ Assert.AreEqual (7, t.Month);
+ Assert.AreEqual (23, t.Day);
+ Assert.AreEqual (19, t.Hour);
+ Assert.AreEqual (19, t.Minute);
+ Assert.AreEqual (45, t.Second);
+
+ }
+#endif
+
+ [Test]
+ [ExpectedException (typeof (FormatException))]
+ public void ParseExactIsExact()
+ {
+ DateTime.ParseExact ("2004-05-26T03:29:01-07:00 foo", "yyyy-MM-ddTHH:mm:sszzz", null);
+ }
+
+ [Test]
+ [ExpectedException (typeof (FormatException))]
+ public void ParseExactDoesNotEatZ ()
+ {
+ DateTime.ParseExact ("2004-05-26T03:29:01", "yyyy-MM-ddTHH:mm:ssZ", null);
+ }
+
+ [Test]
+ public void ParseExactMilliseconds ()
+ {
+ DateTime dt = DateTime.ParseExact ("2004-05-26T03:29:01.1234567-07:00", "yyyy-MM-ddTHH:mm:ss.fffffffzzz", null);
+ dt = TimeZone.CurrentTimeZone.ToUniversalTime (dt);
+ Assert.AreEqual (632211641411234567, dt.Ticks);
+ }
+
+ [Test]
+ public void NoColonTimeZone ()
+ {
+ Assert.IsTrue (DateTime.Parse ("2004-05-26T03:29:01-0700").Ticks
+ != DateTime.Parse ("2004-05-26T03:29:01-0800").Ticks);
+ }
+
+ [Test]
+ public void WithColonTimeZone ()
+ {
+ Assert.IsTrue (DateTime.Parse ("2004-05-26T03:29:01-07:00").Ticks
+ != DateTime.Parse ("2004-05-26T03:29:01-08:00").Ticks);
+ }
+
+ [Test]
+ [ExpectedException (typeof (FormatException))]
+ public void EmptyFormatPattern ()
+ {
+ DateTime.ParseExact (String.Empty, String.Empty, null);
+ }
+
+ [Test]
+ [ExpectedException (typeof (InvalidCastException))]
+ public void IConvertible_ToType_Boolean ()
+ {
+ ((IConvertible)DateTime.Now).ToType (typeof (bool), null);
+ }
+
+ [Test]
+ [ExpectedException (typeof (InvalidCastException))]
+ public void IConvertible_ToType_Byte ()
+ {
+ ((IConvertible)DateTime.Now).ToType (typeof (byte), null);
+ }
+
+ [Test]
+ [ExpectedException (typeof (InvalidCastException))]
+ public void IConvertible_ToType_Char ()
+ {
+ ((IConvertible)DateTime.Now).ToType (typeof (char), null);
+ }
+
+ [Test]
+ public void IConvertible_ToType_DateTime ()
+ {
+ DateTime dt = DateTime.Now;
+ DateTime dt2 = (DateTime) ((IConvertible)dt).ToType (typeof (DateTime), null);
+ Assert.IsTrue (dt.Equals (dt2));
+ }
+
+ [Test]
+ [ExpectedException (typeof (InvalidCastException))]
+ public void IConvertible_ToType_DBNull ()
+ {
+ ((IConvertible)DateTime.Now).ToType (typeof (DBNull), null);
+ }
+
+ [Test]
+ [ExpectedException (typeof (InvalidCastException))]
+ public void IConvertible_ToType_Decimal ()
+ {
+ ((IConvertible)DateTime.Now).ToType (typeof (decimal), null);
+ }
+
+ [Test]
+ [ExpectedException (typeof (InvalidCastException))]
+ public void IConvertible_ToType_Double ()
+ {
+ ((IConvertible)DateTime.Now).ToType (typeof (double), null);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentNullException))]
+ public void IConvertible_ToType_Empty ()
+ {
+ ((IConvertible)DateTime.Now).ToType (null, null);
+ }
+
+ [Test]
+ [ExpectedException (typeof (InvalidCastException))]
+ public void IConvertible_ToType_Int16 ()
+ {
+ ((IConvertible)DateTime.Now).ToType (typeof (short), null);
+ }
+
+ [Test]
+ [ExpectedException (typeof (InvalidCastException))]
+ public void IConvertible_ToType_Int32 ()
+ {
+ ((IConvertible)DateTime.Now).ToType (typeof (int), null);
+ }
+
+ [Test]
+ [ExpectedException (typeof (InvalidCastException))]
+ public void IConvertible_ToType_Int64 ()
+ {
+ ((IConvertible)DateTime.Now).ToType (typeof (long), null);
+ }
+
+ [Test]
+ public void IConvertible_ToType_Object ()
+ {
+ DateTime dt = DateTime.Now;
+ object o = ((IConvertible)dt).ToType (typeof (object), null);
+ Assert.IsTrue (dt.Equals (o));
+ }
+
+ [Test]
+ [ExpectedException (typeof (InvalidCastException))]
+ public void IConvertible_ToType_SByte ()
+ {
+ ((IConvertible)DateTime.Now).ToType (typeof (sbyte), null);
+ }
+
+ [Test]
+ [ExpectedException (typeof (InvalidCastException))]
+ public void IConvertible_ToType_Single ()
+ {
+ ((IConvertible)DateTime.Now).ToType (typeof (float), null);
+ }
+
+ [Test]
+ public void IConvertible_ToType_String ()
+ {
+ DateTime dt = DateTime.Now;
+ string s = (string) ((IConvertible)dt).ToType (typeof (string), null);
+ Assert.AreEqual (s, dt.ToString ());
+ }
+
+ [Test]
+ [ExpectedException (typeof (InvalidCastException))]
+ public void IConvertible_ToType_UInt16 ()
+ {
+ ((IConvertible)DateTime.Now).ToType (typeof (ushort), null);
+ }
+
+ [Test]
+ [ExpectedException (typeof (InvalidCastException))]
+ public void IConvertible_ToType_UInt32 ()
+ {
+ ((IConvertible)DateTime.Now).ToType (typeof (uint), null);
+ }
+
+ [Test]
+ [ExpectedException (typeof (InvalidCastException))]
+ public void IConvertible_ToType_UInt64 ()
+ {
+ ((IConvertible)DateTime.Now).ToType (typeof (ulong), null);
+ }
+
+ [Test]
+ public void Bug352210 ()
+ {
+ DateTime dt = DateTime.ParseExact ("2007-06-15T10:30:10.5", "yyyy-MM-ddTHH:mm:ss.f", null);
+ Assert.AreEqual (633175002105000000, dt.Ticks, "#1");
+#if NET_2_0
+ Assert.AreEqual (DateTimeKind.Unspecified, dt.Kind, "#2");
+#endif
+ }
+
+ [Test]
+ public void Bug352210_New ()
+ {
+ long ticksUTC = 633377759060000000;
+ long ticksLocal = ticksUTC + TimeZone.CurrentTimeZone.GetUtcOffset (new DateTime (ticksUTC)).Ticks;
+ CultureInfo ci = CultureInfo.InvariantCulture;
+ DateTime dt;
+
+ // Should return same time with Unspecified kind
+ dt = DateTime.ParseExact ("2008-02-05 02:38:26", "yyyy-MM-dd HH:mm:ss", ci);
+#if NET_2_0
+ Assert.AreEqual (DateTimeKind.Unspecified, dt.Kind, "A1");
+#endif
+ Assert.AreEqual (ticksUTC, dt.Ticks, "A2");
+
+ // Should return same time with Unspecified kind
+ dt = DateTime.ParseExact ("2008-02-05 02:38:26Z", "u", ci);
+#if NET_2_0
+ Assert.AreEqual (DateTimeKind.Unspecified, dt.Kind, "B1");
+#endif
+ Assert.AreEqual (ticksUTC, dt.Ticks, "B2");
+
+#if NET_2_0
+ // Should adjust to local time with Local kind
+ dt = DateTime.ParseExact ("2008-02-05 00:38:26-02:00", "yyyy-MM-dd HH:mm:ssK", ci);
+ Assert.AreEqual (DateTimeKind.Local, dt.Kind, "C1");
+ Assert.AreEqual (ticksLocal, dt.Ticks, "C2");
+
+ // Should ignore AssumeUniversal since a timezone specifier is in the format string
+ // and return time adjusted to local time with Local kind
+ dt = DateTime.ParseExact ("2008-02-05 00:38:26 -2", "yyyy-MM-dd HH:mm:ss z", ci, DateTimeStyles.AssumeUniversal);
+ Assert.AreEqual (DateTimeKind.Local, dt.Kind, "D1");
+ Assert.AreEqual (ticksLocal, dt.Ticks, "D2");
+#endif
+
+ try {
+ // GMT in format string can be used to specify time zone
+ dt = DateTime.ParseExact ("2008-02-05 02:38:26 GMT", "yyyy-MM-dd HH:mm:ss GMT", ci);
+#if NET_2_0
+ Assert.AreEqual (DateTimeKind.Local, dt.Kind, "E1");
+#endif
+ Assert.AreEqual (ticksLocal, dt.Ticks, "E2");
+ }
+ catch {
+ Assert.Fail ("E3");
+ }
+
+ try {
+ // Same as above even when surrounded with other characters
+ dt = DateTime.ParseExact ("2008-02-05 02:38:26 qqGMTqq", "yyyy-MM-dd HH:mm:ss qqGMTqq", ci);
+#if NET_2_0
+ Assert.AreEqual (DateTimeKind.Local, dt.Kind, "F1");
+#endif
+ Assert.AreEqual (ticksLocal, dt.Ticks, "F2");
+ }
+ catch {
+ Assert.Fail ("F3");
+ }
+
+ try {
+ // But single quoted GMT in format string should not specify time zone
+ dt = DateTime.ParseExact ("2008-02-05 02:38:26 GMT", "yyyy-MM-dd HH:mm:ss 'GMT'", ci);
+#if NET_2_0
+ Assert.AreEqual (DateTimeKind.Unspecified, dt.Kind, "G1");
+#endif
+ Assert.AreEqual (ticksUTC, dt.Ticks, "G2");
+ }
+ catch {
+ Assert.Fail ("G3");
+ }
+
+ try {
+ // GMT in Parse can occur before time in 2.0 but not in 1.0
+ dt = DateTime.Parse ("GMT 2008-02-05 02:38:26", ci);
+#if NET_2_0
+ Assert.AreEqual (DateTimeKind.Local, dt.Kind, "H1");
+ Assert.AreEqual (ticksLocal, dt.Ticks, "H2");
+#else
+ Assert.Fail ("H3");
+#endif
+ }
+ catch {
+#if NET_2_0
+ Assert.Fail ("H4");
+#endif
+ }
+ }
+
+ [Test]
+ public void Bug377042 ()
+ {
+ string [] f = new string [] {
+ "yyyy-MM-ddTHH:mm:ssZ",
+ "yyyy-MM-ddTHH:mm:sszzzz",
+ "yyyy-MM-dd"
+ };
+ DateTimeStyles dts = DateTimeStyles.AdjustToUniversal;
+#if NET_2_0
+ dts |= DateTimeStyles.AssumeUniversal;
+#endif
+ DateTime result = DateTime.ParseExact ("2005-01-01T01:11:11+8:00", f, new DateTimeFormatInfo (), dts);
+ }
+
+ [Test]
+ [ExpectedException (typeof (FormatException))]
+ public void EmptyString ()
+ {
+ DateTime.Parse ("");
+ }
+#if NET_2_0
+ [Test]
+ public void TryEmptyString ()
+ {
+ DateTime date;
+ Assert.IsFalse (DateTime.TryParse ("", out date));
+ }
+
+ [Test]
+ public void Kind ()
+ {
+ if (DateTime.Now == DateTime.UtcNow)
+ return; // This test does not make sense.
+ if (TimeZone.CurrentTimeZone.GetUtcOffset (DateTime.UtcNow)
+ != TimeZone.CurrentTimeZone.GetUtcOffset (DateTime.Now))
+ return; // In this case it does not satisfy the test premises.
+
+ Assert.AreEqual (DateTimeKind.Local, DateTime.Now.Kind, "#A1");
+ Assert.AreEqual (DateTimeKind.Local, DateTime.Today.Kind, "#A2");
+
+ DateTime utc = DateTime.UtcNow;
+ DateTime now = new DateTime (utc.Ticks + TimeZone.
+ CurrentTimeZone.GetUtcOffset (utc).Ticks, DateTimeKind.Local);
+ DateTime utctouniv = utc.ToUniversalTime ();
+ DateTime nowtouniv = now.ToUniversalTime ();
+ DateTime utctoloc = utc.ToLocalTime ();
+ DateTime nowtoloc = now.ToLocalTime ();
+
+ Assert.AreEqual (DateTimeKind.Utc, utc.Kind, "#B1");
+ Assert.AreEqual (DateTimeKind.Local, now.Kind, "#B2");
+ Assert.AreEqual (DateTimeKind.Utc, utctouniv.Kind, "#B3");
+ Assert.AreEqual (DateTimeKind.Utc, nowtouniv.Kind, "#B4");
+ Assert.AreEqual (DateTimeKind.Local, utctoloc.Kind, "#B5");
+ Assert.AreEqual (DateTimeKind.Local, nowtoloc.Kind, "#B6");
+ Assert.AreEqual (utc, utctouniv, "#B7");
+ Assert.AreEqual (utc, nowtouniv, "#B8");
+ Assert.AreEqual (now, nowtoloc, "#B9");
+ Assert.AreEqual (now, utctoloc, "#B10");
+ }
+
+ [Test]
+ public void InstanceMembersAndKind ()
+ {
+ Assert.AreEqual (DateTimeKind.Utc, DateTime.UtcNow.Date.Kind, "#1");
+ Assert.AreEqual (DateTimeKind.Utc, DateTime.UtcNow.Add (TimeSpan.FromMinutes (1)).Kind, "#2");
+ Assert.AreEqual (DateTimeKind.Utc, DateTime.UtcNow.Subtract (TimeSpan.FromMinutes (1)).Kind, "#3");
+ Assert.AreEqual (DateTimeKind.Utc, DateTime.UtcNow.AddDays (1).Kind, "#4");
+ Assert.AreEqual (DateTimeKind.Utc, DateTime.UtcNow.AddTicks (1).Kind, "#5");
+ Assert.AreEqual (DateTimeKind.Utc, DateTime.UtcNow.AddHours (1).Kind, "#6");
+ Assert.AreEqual (DateTimeKind.Utc, DateTime.UtcNow.AddMinutes (1).Kind, "#7");
+ Assert.AreEqual (DateTimeKind.Utc, DateTime.UtcNow.AddSeconds (1).Kind, "#8");
+ Assert.AreEqual (DateTimeKind.Utc, DateTime.UtcNow.AddMilliseconds (1).Kind, "#9");
+ Assert.AreEqual (DateTimeKind.Utc, DateTime.UtcNow.AddMonths (1).Kind, "#10");
+ Assert.AreEqual (DateTimeKind.Utc, DateTime.UtcNow.AddYears (1).Kind, "#11");
+ Assert.AreEqual (DateTimeKind.Utc, (DateTime.UtcNow + TimeSpan.FromMinutes (1)).Kind, "#12");
+ Assert.AreEqual (DateTimeKind.Utc, (DateTime.UtcNow - TimeSpan.FromMinutes (1)).Kind, "#13");
+ }
+
+ [Test]
+ public void CompareTicks ()
+ {
+ // Only ticks are compared, not kind.
+ var d = new DateTime (0, DateTimeKind.Utc);
+ var f = new DateTime (0);
+
+ Assert.AreEqual (d == f, true, "#1");
+ }
+
+ [Test]
+ public void FromBinary ()
+ {
+ DateTime dt_utc = DateTime.FromBinary (0x4000000000000001);
+ Assert.AreEqual (DateTimeKind.Utc, dt_utc.Kind, "#1");
+ Assert.AreEqual (1, dt_utc.Ticks, "#2");
+
+ DateTime dt_local = DateTime.FromBinary (unchecked ((long) 0x8000000000000001));
+ Assert.AreEqual (DateTimeKind.Local, dt_local.Kind, "#3");
+
+ DateTime dt_unspecified = DateTime.FromBinary (0x0000000000000001);
+ Assert.AreEqual (DateTimeKind.Unspecified, dt_unspecified.Kind, "#4");
+ Assert.AreEqual (1, dt_unspecified.Ticks, "#5");
+
+ DateTime dt_local2 = DateTime.FromBinary (unchecked ((long) 0xC000000000000001));
+ Assert.AreEqual (DateTimeKind.Local, dt_local2.Kind, "#6");
+ Assert.AreEqual (dt_local.Ticks, dt_local2.Ticks, "#7");
+ }
+
+ [Test]
+ public void ToBinary ()
+ {
+ DateTime dt_local = new DateTime (1, DateTimeKind.Local);
+ Assert.AreEqual (1, (ulong) dt_local.ToBinary () >> 63, "#1");
+ Assert.AreEqual (1, dt_local.Ticks, "#2");
+
+ DateTime dt_utc = new DateTime (1, DateTimeKind.Utc);
+ Assert.AreEqual (0x4000000000000001, dt_utc.ToBinary (), "#3");
+ Assert.AreEqual (1, dt_utc.Ticks, "#4");
+
+ DateTime dt_unspecified = new DateTime (1, DateTimeKind.Unspecified);
+ Assert.AreEqual (1, dt_unspecified.ToBinary (), "#5");
+ Assert.AreEqual (1, dt_unspecified.Ticks, "#6");
+ }
+
+ [Test]
+ public void RoundtripBinary ()
+ {
+ DateTime dt = DateTime.Now;
+ DateTime dt2 = DateTime.SpecifyKind (dt, DateTimeKind.Utc);
+ DateTime dt3 = DateTime.SpecifyKind (dt, DateTimeKind.Unspecified);
+ Assert.AreEqual (dt, DateTime.FromBinary (dt.ToBinary ()), "#1");
+ Assert.AreEqual (dt2, DateTime.FromBinary (dt2.ToBinary ()), "#2");
+ Assert.AreEqual (dt3, DateTime.FromBinary (dt3.ToBinary ()), "#3");
+ Assert.AreEqual (DateTimeKind.Local, DateTime.FromBinary (dt.ToBinary ()).Kind, "#4");
+ Assert.AreEqual (DateTimeKind.Utc, DateTime.FromBinary (dt2.ToBinary ()).Kind, "#5");
+ Assert.AreEqual (DateTimeKind.Unspecified, DateTime.FromBinary (dt3.ToBinary ()).Kind, "#6");
+
+ Assert.AreEqual (TimeZone.CurrentTimeZone.GetUtcOffset (dt).Ticks, dt3.ToBinary () - (dt.ToBinary () & 0x7FFFFFFFFFFFFFFF), "#7");
+ }
+
+ [Test]
+ public void TestMin ()
+ {
+ // This should never throw.
+ DateTime.MinValue.ToLocalTime ();
+ }
+
+ [Test]
+ public void OmittedSecondsFraction ()
+ {
+ DateTime today = DateTime.Today;
+ Assert.AreEqual ("00:00:00.13579", today.AddTicks (1357900).ToString ("HH:mm:ss.FFFFFFF"), "#1");
+ DateTime dt = DateTime.ParseExact ("00:00:00.13579", "HH:mm:ss.FFFFFFF", CultureInfo.InvariantCulture);
+ Assert.AreEqual (today, dt.AddTicks (-1357900), "#2");
+ // it's more than strange ...
+ Assert.AreEqual (String.Empty, today.ToString (".FFFFFFF"), "#3");
+ Assert.AreEqual ("$", today.ToString ("$FFFFFFF"), "#4");
+ }
+
+ [Test]
+ public void KindInPattern ()
+ {
+ // only 2.0 supports 'K'
+ Assert.AreEqual ("00:00:00", new DateTime (2000, 1, 1).ToString ("HH:mm:ssK"), "#1");
+ Assert.AreEqual ('Z', DateTime.Today.ToUniversalTime ().ToString ("HH:mm:ssK") [8], "#2");
+ Assert.AreEqual ("00:00:00+09:00".Length, DateTime.Today.ToString ("HH:mm:ssK").Length, "#3");
+ }
+
+ [Test]
+ public void RoundtripPattern ()
+ {
+ // only 2.0 supports 'o'
+ Assert.AreEqual ("2000-01-01T00:00:00.0000000", new DateTime (2000, 1, 1).ToString ("o"), "#1");
+ Assert.AreEqual ("2000-01-01T00:00:00.0000000Z", DateTime.SpecifyKind (new DateTime (2000, 1, 1), DateTimeKind.Utc).ToString ("o"), "#2");
+ Assert.AreEqual ("2000-01-01T00:00:00.0000000+09:00".Length, DateTime.SpecifyKind (
+ new DateTime (2000, 1, 1), DateTimeKind.Local).ToString ("o").Length, "#3");
+ }
+
+ [Test]
+ [Category ("NotDotNet")]
+ [Category ("NotWorking")] // wrt bug #352210
+ public void KindPattern ()
+ {
+ // no matter how the format string contains 'K' and the
+ // output string contains kind information, it does not
+ // assure that the string is parsed as roundtrip kind.
+
+ // only 2.0 supports 'K'
+ string format = "yyyy-MM-dd'T'HH:mm:ss.fffK";
+ CultureInfo ci = CultureInfo.CurrentCulture;
+ DateTime dt = DateTime.SpecifyKind (new DateTime (2007, 11, 1, 2, 30, 45), DateTimeKind.Utc);
+ string s = dt.ToString (format);
+ DateTime d1 = DateTime.ParseExact (s, format, ci); // d1 is parsed as a local time.
+ Assert.AreEqual (dt.Ticks, d1.ToUniversalTime ().Ticks, "#1");
+ // .NET expects Local here, while s ends with 'Z' and should be parsed as UTC.
+ Assert.AreEqual (DateTimeKind.Utc, d1.Kind, "#2");
+
+ format = "yyyy-MM-dd'T'HH:mm:ssK";
+ ci = CultureInfo.CurrentCulture;
+ dt = new DateTime (2007, 11, 1, 2, 30, 45);
+ s = dt.ToString (format);
+ d1 = DateTime.ParseExact (s, format, ci);
+ Assert.AreEqual (dt.Ticks, d1.Ticks, "#3");
+ Assert.AreEqual (DateTimeKind.Unspecified, d1.Kind, "#4");
+ }
+
+ [Test]
+ public void TestRoundTrip () {
+ DateTime result;
+ DateTimeStyles roundTripStyle = DateTimeStyles.RoundtripKind;
+ string utcDate = "2008-02-21T11:14:18.2721262Z";
+ string localDate = "2008-02-21T11:14:18.2721262+02:00";
+ string unspec = "2008-02-21T11:14:18.2721262";
+ String [] formats = {"yyyy-MM-ddTHH:mm:ssK", "yyyy-MM-ddTHH:mm:ss.FFFFFFFK"};
+
+ result = DateTime.ParseExact (localDate, formats, CultureInfo.InvariantCulture, roundTripStyle);
+ Assert.AreEqual (result.Kind, DateTimeKind.Local);
+ Assert.AreEqual (result.ToUniversalTime ().Ticks, 633391820582721262);
+
+ result = DateTime.ParseExact (unspec, formats, CultureInfo.InvariantCulture, roundTripStyle);
+ Assert.AreEqual (result.Kind, DateTimeKind.Unspecified);
+ Assert.AreEqual (result.Ticks, 633391892582721262);
+
+ result = DateTime.ParseExact (utcDate, formats, CultureInfo.InvariantCulture, roundTripStyle);
+ Assert.AreEqual (result.Kind, DateTimeKind.Utc);
+ Assert.AreEqual (result.Ticks, 633391892582721262);
+
+ }
+
+ [Test]
+ public void TestRegularStyle () {
+ DateTime result;
+ DateTimeStyles style = DateTimeStyles.AllowLeadingWhite | DateTimeStyles.AllowTrailingWhite;
+ string utcDate = "2008-02-21T11:14:18.2721262Z";
+ string localDate = "2008-02-21T11:14:18.2721262+02:00";
+ string unspec = "2008-02-21T11:14:18.2721262";
+ String [] formats = {"yyyy-MM-ddTHH:mm:ssK", "yyyy-MM-ddTHH:mm:ss.FFFFFFFK"};
+
+ result = DateTime.ParseExact (localDate, formats, CultureInfo.InvariantCulture, style);
+ Assert.AreEqual (result.Kind, DateTimeKind.Local);
+ Assert.AreEqual (result.ToUniversalTime ().Ticks, 633391820582721262);
+
+ result = DateTime.ParseExact (unspec, formats, CultureInfo.InvariantCulture, style);
+ Assert.AreEqual (result.Kind, DateTimeKind.Unspecified);
+ Assert.AreEqual (result.Ticks, 633391892582721262);
+
+ result = DateTime.ParseExact (utcDate, formats, CultureInfo.InvariantCulture, style);
+ Assert.AreEqual (result.Kind, DateTimeKind.Local);
+ Assert.AreEqual (result.ToUniversalTime ().Ticks, 633391892582721262);
+ }
+
+ [Test]
+ public void TestAssumeLocal () {
+ DateTime result;
+ DateTimeStyles assumeLocal = DateTimeStyles.AssumeLocal;
+ string utcDate = "2008-02-21T11:14:18.2721262Z";
+ string localDate = "2008-02-21T11:14:18.2721262+02:00";
+ string unspec = "2008-02-21T11:14:18.2721262";
+ String [] formats = {"yyyy-MM-ddTHH:mm:ssK", "yyyy-MM-ddTHH:mm:ss.FFFFFFFK"};
+
+ result = DateTime.ParseExact (localDate, formats, CultureInfo.InvariantCulture, assumeLocal);
+ Assert.AreEqual (result.Kind, DateTimeKind.Local);
+ Assert.AreEqual (result.ToUniversalTime ().Ticks, 633391820582721262);
+
+ result = DateTime.ParseExact (unspec, formats, CultureInfo.InvariantCulture, assumeLocal);
+ Assert.AreEqual (result.Kind, DateTimeKind.Local);
+ Assert.AreEqual (result.Ticks, 633391892582721262);
+
+ result = DateTime.ParseExact (utcDate, formats, CultureInfo.InvariantCulture, assumeLocal);
+ Assert.AreEqual (result.Kind, DateTimeKind.Local);
+ Assert.AreEqual (result.ToUniversalTime ().Ticks, 633391892582721262);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void IllegalStyleCombination1()
+ {
+ DateTimeStyles illegal = DateTimeStyles.RoundtripKind | DateTimeStyles.AssumeLocal;
+ DateTime.ParseExact ("", "", null, illegal);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void IllegalStyleCombination2()
+ {
+ DateTimeStyles illegal = DateTimeStyles.RoundtripKind | DateTimeStyles.AdjustToUniversal;
+ DateTime.ParseExact ("", "", null, illegal);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void IllegalStyleCombination3()
+ {
+ DateTimeStyles illegal = DateTimeStyles.RoundtripKind | DateTimeStyles.AssumeUniversal;
+ DateTime.ParseExact ("", "", null, illegal);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void IllegalStyleCombination4()
+ {
+ DateTimeStyles illegal = DateTimeStyles.AssumeLocal | DateTimeStyles.AssumeUniversal;
+ DateTime.ParseExact ("", "", null, illegal);
+ }
+
+ [Test]
+ [ExpectedException (typeof (FormatException))]
+ public void TrailingDot ()
+ {
+ DateTime.ParseExact ("12:00:00", "HH:mm:ss.", null);
+ }
+
+ [Test]
+ public void TrailingFlexibleMilliseconds ()
+ {
+ // bug #444103.
+ DateTime.ParseExact ("12:00:00", "HH:mm:ss.FFFFFFF", null);
+ }
+
+ [Test]
+ public void TryParseExact_NullString ()
+ {
+ DateTime dt;
+ DateTime.TryParseExact(null, "yyyy'-'MM'-'dd'T'HH':'mm':'ss'Z'", CultureInfo.InvariantCulture,
+ DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal, out dt);
+ Assert.AreEqual(default(DateTime), dt);
+ }
+
+ [Test]
+ public void MSAndZ ()
+ {
+ CultureInfo cultureInfo = CultureInfo.GetCultureInfo ("en-US");
+ DateTime dt;
+ if (!DateTime.TryParse ("2009.02.24T13:57:07.000 -0800", cultureInfo.DateTimeFormat,
+ DateTimeStyles.None, out dt))
+ Assert.Fail ("Failed");
+ }
+#endif
+
+ [Test]
+ [Ignore ("This test is not international ready, probably only succeeds in the U.S.")]
+ public void Parse_InvalidShortDate ()
+ {
+ DateTime expected = new DateTime (2011, 03, 22, 08, 32, 00);
+ DateTime dt;
+ string [] cultures = new string [] {"es-ES", "en-US", "en-GB", "de-DE", "fr-FR"
+#if NET_4_0
+ ,"es", "en", "de", "fr"
+#endif
+ };
+
+ foreach (string culture in cultures) {
+ CultureInfo ci = new CultureInfo (culture);
+ ci.DateTimeFormat.ShortDatePattern = "d";
+
+ Assert.AreEqual (DateTime.Parse ("2011-03-22 08:32:00+01:00", ci, DateTimeStyles.RoundtripKind), expected, "#a01 - " + culture);
+ Assert.AreEqual (DateTime.Parse ("2011/03/22 08:32:00+01:00", ci, DateTimeStyles.RoundtripKind), expected, "#a02 - " + culture);
+ Assert.AreEqual (DateTime.Parse ("2011-03-22T08:32:00", ci, DateTimeStyles.RoundtripKind), expected, "#a03 - " + culture);
+ Assert.AreEqual (DateTime.Parse ("2011/03/22T08:32:00", ci, DateTimeStyles.RoundtripKind), expected, "#a04 - " + culture);
+ Assert.AreEqual (DateTime.Parse ("03/2011/22T08:32:00", ci, DateTimeStyles.RoundtripKind), expected, "#a05 - " + culture);
+ Assert.AreEqual (DateTime.Parse ("03-2011-22T08:32:00", ci, DateTimeStyles.RoundtripKind), expected, "#a06 - " + culture);
+ Assert.AreEqual (DateTime.Parse ("03/2011/22 08:32:00+01:00", ci, DateTimeStyles.RoundtripKind), expected, "#a07 - " + culture);
+ ci.DateTimeFormat.DateSeparator = "%";
+ Assert.AreEqual (DateTime.Parse ("2011-03-22 08:32:00+01:00", ci, DateTimeStyles.RoundtripKind), expected, "#b01 - " + culture);
+ Assert.AreEqual (DateTime.Parse ("2011/03/22 08:32:00+01:00", ci, DateTimeStyles.RoundtripKind), expected, "#b02 - " + culture);
+ Assert.AreEqual (DateTime.Parse ("2011-03-22T08:32:00", ci, DateTimeStyles.RoundtripKind), expected, "#b03 - " + culture);
+ Assert.AreEqual (DateTime.Parse ("2011/03/22T08:32:00", ci, DateTimeStyles.RoundtripKind), expected, "#b04 - " + culture);
+ Assert.AreEqual (DateTime.Parse ("03/2011/22T08:32:00", ci, DateTimeStyles.RoundtripKind), expected, "#b05 - " + culture);
+ Assert.AreEqual (DateTime.Parse ("03-2011-22T08:32:00", ci, DateTimeStyles.RoundtripKind), expected, "#b06 - " + culture);
+ Assert.AreEqual (DateTime.Parse ("03/2011/22 08:32:00+01:00", ci, DateTimeStyles.RoundtripKind), expected, "#b07 - " + culture);
+ }
+ }
+ }
+}