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]
+ 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 ()
{
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);
+ }
+ }
}
}
projects / mono.git / blobdiff