internal void DTAssertEquals (DateTime actual, DateTime expected, Resolution resolution)
{
- DTAssertEquals ("", actual, expected, resolution);
+ DTAssertEquals (actual, expected, resolution, "");
}
- internal void DTAssertEquals (string message, DateTime expected, DateTime actual, Resolution resolution)
+ internal void DTAssertEquals (DateTime expected, DateTime actual, Resolution resolution, string message)
{
if ((resolution & Resolution.Year) != 0)
Assert.AreEqual (expected.Year, actual.Year, message);
}
[Test]
+#if NET_4_0
+ [ExpectedException (typeof (FormatException))]
+ [Category ("NotWorking")]
+#endif
public void TestParseExact4 ()
{
- // bug #60912, modified hour as 13:00
+ // 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",
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 ()
{
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]
}
[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)) {
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
{
double number=5000.41443;
DateTime d = DateTime.FromOADate(number);
- DTAssertEquals ("#1", d, new DateTime(1913, 9, 8, 9, 56, 46, 0), Resolution.Second);
+ DTAssertEquals (d, new DateTime(1913, 9, 8, 9, 56, 46, 0), Resolution.Second, "#1");
Assert.AreEqual (d.ToOADate(), number, "#2");
}
}
[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]
-#if NET_2_0
- [Category ("NotWorking")]
-#endif
public void ZLiteral ()
{
// However, "Z" and "'Z'" are different.
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";
- // culture 1025 ar-SA fails
+ // fails with many cultures on .NET.
// if (i != 127)
// dt = DateTime.Parse ("19960312183847Z");
#endif
// "th-TH" locale rejects them since in
// ThaiBuddhistCalendar the week of a day is different.
// (and also for years).
- if (ci.LCID != 1054) {
+ 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);
}
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 1025: // ar-SA
case 1054: // th-TH
+ case 1123: // ps-AF
case 1125: // div-MV
+ case 1164: // prs-AF
break;
default:
stage = "8";
}
[Test]
- [Category ("NotWorking")]
public void Bug352210 ()
{
DateTime dt = DateTime.ParseExact ("2007-06-15T10:30:10.5", "yyyy-MM-ddTHH:mm:ss.f", null);
#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 ()
{
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 ()
{
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);
+ }
+ }
}
}