[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";
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]
#if NET_2_0
[ExpectedException (typeof (FormatException))]
#else
- [Ignore ("Works only under MS 1.x (i.e. Mono and MS 2.0 fails).")]
+ [Ignore ("Works only under MS 1.x (not Mono or MS 2.0).")]
#endif
public void ParseNotExact ()
{
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