[TearDown]
public void TearDown ()
{
- Thread.CurrentThread.CurrentCulture = oldcult;
+ Thread.CurrentThread.CurrentCulture = oldcult;
}
-
+
+ [Test]
public void TestCtors ()
{
DateTime t1 = new DateTime (2002,2,25);
[Test]
public void Fields ()
{
- AssertEquals ("J01", 3155378975999999999L, DateTime.MaxValue.Ticks);
+ AssertEquals ("J01", 3155378975999999999L, DateTime.MaxValue.Ticks);
AssertEquals ("J02", 0, DateTime.MinValue.Ticks);
}
AssertEquals ("K05", 25, t1.Day);
AssertEquals ("K06", 15, t1.Hour);
AssertEquals ("K07", 25, t1.Minute);
- AssertEquals ("K08", 13, t1.Second);
+ AssertEquals ("K08", 13, t1.Second);
}
[Test]
AssertEquals ("L01", 28, t1.Day);
AssertEquals ("L02", 15, t1.Hour);
AssertEquals ("L03", 25, t1.Minute);
- AssertEquals ("L04", 13, t1.Second);
+ AssertEquals ("L04", 13, t1.Second);
t1 = t1.AddDays (1.9);
AssertEquals ("L05", 2, t1.Day);
AssertEquals ("L06", 13, t1.Hour);
AssertEquals ("L07", 1, t1.Minute);
- AssertEquals ("L08", 13, t1.Second);
+ AssertEquals ("L08", 13, t1.Second);
t1 = t1.AddDays (0.2);
AssertEquals ("L09", 2, t1.Day);
AssertEquals ("L10", 17, t1.Hour);
AssertEquals ("L11", 49, t1.Minute);
- AssertEquals ("L12", 13, t1.Second);
+ AssertEquals ("L12", 13, t1.Second);
}
[Test]
AssertEquals ("N01", 26, t1.Day);
AssertEquals ("N02", 1, t1.Hour);
AssertEquals ("N03", 25, t1.Minute);
- AssertEquals ("N04", 13, t1.Second);
+ AssertEquals ("N04", 13, t1.Second);
t1 = t1.AddHours (-3.7);
AssertEquals ("N05", 25, t1.Day);
AssertEquals ("N06", 21, t1.Hour);
AssertEquals ("N07", 43, t1.Minute);
- AssertEquals ("N08", 13, t1.Second);
+ AssertEquals ("N08", 13, t1.Second);
t1 = t1.AddHours (3.732);
AssertEquals ("N09", 26, t1.Day);
AssertEquals ("N10", 1, t1.Hour);
AssertEquals ("N11", 27, t1.Minute);
- AssertEquals ("N12", 8, t1.Second);
+ AssertEquals ("N12", 8, t1.Second);
}
[Test]
DateTime t1 = new DateTime (myTicks [1]);
t1.AddHours (-9E100);
}
-
+
[Test]
public void AddMilliseconds ()
{
AssertEquals ("O01", 21, t1.Day);
AssertEquals ("O02", 9, t1.Hour);
AssertEquals ("O03", 11, t1.Minute);
- AssertEquals ("O04", 53, t1.Second);
+ AssertEquals ("O04", 53, t1.Second);
t1 = t1.AddMilliseconds (-19E10);
AssertEquals ("O05", 13, t1.Day);
AssertEquals ("O06", 7, t1.Hour);
AssertEquals ("O07", 25, t1.Minute);
- AssertEquals ("O08", 13, t1.Second);
+ AssertEquals ("O08", 13, t1.Second);
t1 = t1.AddMilliseconds (15.623);
AssertEquals ("O09", 13, t1.Day);
AssertEquals ("O10", 7, t1.Hour);
AssertEquals ("O11", 25, t1.Minute);
- AssertEquals ("O12", 13, t1.Second);
+ AssertEquals ("O12", 13, t1.Second);
}
[Test]
t1.AddMilliseconds (-9E100);
}
-
+ [Test]
public void TestToString ()
{
DateTime t1 = new DateTime (myTicks[2]);
AssertEquals("C24", "AM", t1.ToString ("tt"));
AssertEquals("C25", "PM", t2.ToString ("tt"));
long offset = TimeZone.CurrentTimeZone.GetUtcOffset(t1).Ticks / 36000000000;
- AssertEquals("C26", offset.ToString("+#;-#;0"), t1.ToString ("%z"));
- AssertEquals("C27", offset.ToString("+00;-00;00"), t1.ToString ("zz"));
+ // Must specify '+0' for GMT
+ AssertEquals("C26", offset.ToString("+#;-#;+0"), t1.ToString ("%z"));
+ 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
//AssertEquals("C28", offset.ToString("+00;-00;00") + ":00", t1.ToString ("zzz"));
AssertEquals("C32", " d", t1.ToString (" \\d"));
}
+ [Test]
public void TestParseExact3 ()
{
DateTime t1 = DateTime.ParseExact ("2002-02-25 04:25:13Z", "u", null);
DateTimeStyles.AllowInnerWhite);
}
+ [Test]
public void TestParseExact ()
{
// Standard patterns
AssertEquals ("Literal1.Ticks", 632563395270000000, t1.Ticks);
}
+ [Test]
[Ignore ("need to fix tests that run on different timezones")]
public void TestParse2 ()
{
}
+ [Test]
public void TestParse ()
{
// Standard patterns
AssertEquals ("H18", t2.Ticks, t1.Ticks);
}
+ [Test]
public void TestParse3 ()
{
string s = "Wednesday, 09 June 2004";
}
[Test]
- public void TestParse5 ()
+ public void Parse_Bug71289a ()
{
// bug #71289
- DateTime.Parse ("Sat,,,,,, 01 Oct 1994 03:00:00",
- CultureInfo.InvariantCulture);
+ 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);
+ DateTime.Parse ("Sat,,, 01,,, Oct,,, ,,,1994 03:00:00", CultureInfo.InvariantCulture);
+ }
+
#if NET_2_0
- try {
- // ',' after 03 is not allowed.
- DateTime.Parse ("Sat,,, 01,,, Oct,,, ,,,1994 03,:00:00",
- CultureInfo.InvariantCulture);
- Fail ("Should fail here.");
- } catch (FormatException) {
- }
+ [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]
+ public void Parse_Bug72788 ()
+ {
// bug #72788
DateTime dt = DateTime.Parse ("21/02/05", new CultureInfo ("fr-FR"));
AssertEquals (2005, dt.Year);
AssertEquals (02, dt.Month);
AssertEquals (21, dt.Day);
+ }
+ [Test]
+ [Category ("NotWorking")] // Mono accept this format for ALL cultures
+ 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 "ns-ZA":
+ case "se-SE":
+ case "sma-SE":
+ case "smj-SE":
+ case "tn-ZA":
+ case "xh-ZA":
+ case "zu-ZA":
+#endif
+ Assert (c, (e == null));
+ break;
+ default:
+ Assert (c, (e != null));
+ break;
+ }
+ }
+ }
+
+ [Test]
+ public void Parse_Bug53023b ()
+ {
foreach (CultureInfo ci in CultureInfo.GetCultures (CultureTypes.SpecificCultures)) {
- DateTime.Parse ("8/16/2005", ci); // see also bug #53023
DateTime.Parse ("01-Sep-05", ci);
+ DateTime.Parse ("4:35:35 AM", ci);
}
+ }
+ [Test]
+ [ExpectedException (typeof (FormatException))]
+ public void Parse_DontAccept2DigitsYears ()
+ {
// don't allow 2 digit years where we require 4.
- try {
- DateTime.ParseExact ("05", "yyyy", CultureInfo.InvariantCulture);
- Fail ("Reject 2 digit years for yyyy");
- } catch (FormatException) {
- }
+ DateTime.ParseExact ("05", "yyyy", CultureInfo.InvariantCulture);
}
[Test]
} finally {
Thread.CurrentThread.CurrentCulture = ci;
}
+
+ // bug #76082
+ AssertEquals ("bug #76082", DateTime.MinValue,
+ DateTime.ParseExact ("00010101T00:00:00",
+ "yyyyMMdd'T'HH':'mm':'ss",
+ DateTimeFormatInfo.InvariantInfo));
}
[Test]
public void X509Certificate ()
{
// if this test fails then *ALL* or *MOST* X509Certificate tests will also fails
- AssertEquals ("yyyyMMddHHmmssZ", "03/12/1996 18:38:47", DateTime.ParseExact ("19960312183847Z", "yyyyMMddHHmmssZ", null).ToUniversalTime ().ToString ());
+ DateTime dt = DateTime.ParseExact ("19960312183847Z", "yyyyMMddHHmmssZ", null);
+#if NET_2_0
+ AssertEquals ("Kind-Local-1", DateTimeKind.Local, dt.Kind);
+ dt = dt.ToUniversalTime ();
+ AssertEquals ("Kind-Utc-1", DateTimeKind.Utc, dt.Kind);
+#else
+ dt = dt.ToUniversalTime ();
+#endif
+ AssertEquals ("yyyyMMddHHmmssZ", "03/12/1996 18:38:47", dt.ToString ());
+
// technically this is invalid (PKIX) because of the missing seconds but it exists so...
- AssertEquals ("yyMMddHHmmZ", "02/23/1996 19:15:00", DateTime.ParseExact ("9602231915Z", "yyMMddHHmmZ", null).ToUniversalTime ().ToString ());
+ dt = DateTime.ParseExact ("9602231915Z", "yyMMddHHmmZ", null);
+#if NET_2_0
+ AssertEquals ("Kind-Local-2", DateTimeKind.Local, dt.Kind);
+ dt = dt.ToUniversalTime ();
+ AssertEquals ("Kind-Utc-2", DateTimeKind.Utc, dt.Kind);
+#else
+ dt = dt.ToUniversalTime ();
+#endif
+ AssertEquals ("yyMMddHHmmZ", "02/23/1996 19:15:00", dt.ToString ());
+ }
+ [Test]
+#if NET_2_0
+ [Category ("NotWorking")] // see bug #
+#endif
+ public void ZLiteral ()
+ {
// However, "Z" and "'Z'" are different.
- AssertEquals ("Z timezone handling",
- DateTime.ParseExact ("19960312183847Z", "yyyyMMddHHmmss'Z'", null).ToLocalTime (),
- DateTime.ParseExact ("19960312183847Z", "yyyyMMddHHmmssZ", null));
+ DateTime dt = DateTime.ParseExact ("19960312183847Z", "yyyyMMddHHmmss'Z'", null);
+ DateTime dtz = DateTime.ParseExact ("19960312183847Z", "yyyyMMddHHmmssZ", null);
+#if NET_2_0
+ AssertEquals ("Kind-Unspecified-3", DateTimeKind.Unspecified, dt.Kind);
+ dt = dt.ToLocalTime ();
+ AssertEquals ("Kind-Local-3a", DateTimeKind.Local, dt.Kind);
+ AssertEquals ("Kind-Local-3b", DateTimeKind.Local, dtz.Kind);
+#else
+ dt = dt.ToLocalTime ();
+#endif
+ AssertEquals ("Z timezone handling", dt, dtz);
}
[Test]
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";
AssertEquals (String.Format ("bug #58938 on culture {0} {1}", ci.LCID, ci), 19, dt.Hour);
+#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");
}
[Test]
- [Category ("NotWorking")]
+#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:
AssertEquals ("DateTime.Parse not exact", 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);
+ AssertEquals ("#1", DateTime.Now.Year, date.Year);
+ AssertEquals ("#2", 11, date.Month);
+ AssertEquals ("#3", 29, date.Day);
+ AssertEquals ("#4", 6, date.Hour);
+ AssertEquals ("#5", 34, date.Minute);
+ AssertEquals ("#6", 0, date.Second);
+ AssertEquals ("#7", 0, date.Millisecond);
+ }
+
[Test]
[ExpectedException (typeof (FormatException))]
public void ParseExactIsExact()
{
((IConvertible)DateTime.Now).ToType (typeof (ulong), null);
}
+
+#if NET_2_0
+ [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.
+
+ AssertEquals ("#0", DateTimeKind.Local, DateTime.Now.Kind);
+ AssertEquals ("#0a", DateTimeKind.Local, DateTime.Today.Kind);
+
+ 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 ();
+
+ AssertEquals ("#1", DateTimeKind.Utc, utc.Kind);
+ AssertEquals ("#2", DateTimeKind.Local, now.Kind);
+ AssertEquals ("#3", DateTimeKind.Utc, utctouniv.Kind);
+ AssertEquals ("#4", DateTimeKind.Utc, nowtouniv.Kind);
+ AssertEquals ("#5", DateTimeKind.Local, utctoloc.Kind);
+ AssertEquals ("#6", DateTimeKind.Local, nowtoloc.Kind);
+ AssertEquals ("#7", utc, utctouniv);
+ AssertEquals ("#8", utc, nowtouniv);
+ AssertEquals ("#9", now, nowtoloc);
+ AssertEquals ("#10", now, utctoloc);
+ }
+
+ [Test]
+ public void FromBinary ()
+ {
+ DateTime dt_utc = DateTime.FromBinary (0x4000000000000001);
+ AssertEquals ("Utc", DateTimeKind.Utc, dt_utc.Kind);
+ AssertEquals ("Utc/Ticks", 1, dt_utc.Ticks);
+
+ DateTime dt_local = DateTime.FromBinary (unchecked ((long) 0x8000000000000001));
+ AssertEquals ("Local", DateTimeKind.Local, dt_local.Kind);
+
+ DateTime dt_unspecified = DateTime.FromBinary (0x0000000000000001);
+ AssertEquals ("Unspecified", DateTimeKind.Unspecified, dt_unspecified.Kind);
+ AssertEquals ("Unspecified/Ticks", 1, dt_unspecified.Ticks);
+
+ DateTime dt_local2 = DateTime.FromBinary (unchecked ((long) 0xC000000000000001));
+ AssertEquals ("Local2", DateTimeKind.Local, dt_local2.Kind);
+ AssertEquals ("Local/Ticks", dt_local.Ticks, dt_local2.Ticks);
+ }
+
+ [Test]
+ public void ToBinary ()
+ {
+ DateTime dt_local = new DateTime (1, DateTimeKind.Local);
+ AssertEquals ("Local.ToBinary", 1, (ulong) dt_local.ToBinary () >> 63);
+ AssertEquals ("Local.Ticks", 1, dt_local.Ticks);
+
+ DateTime dt_utc = new DateTime (1, DateTimeKind.Utc);
+ AssertEquals ("Utc.ToBinary", 0x4000000000000001, dt_utc.ToBinary ());
+ AssertEquals ("Utc.Ticks", 1, dt_utc.Ticks);
+
+ DateTime dt_unspecified = new DateTime (1, DateTimeKind.Unspecified);
+ AssertEquals ("Unspecified.ToBinary", 1, dt_unspecified.ToBinary ());
+ AssertEquals ("Unspecified.Ticks", 1, dt_unspecified.Ticks);
+ }
+#endif
}
}
projects / mono.git / blobdiff