[corlib] Allow bool/char to enum conversions

[mono.git] / mcs / class / corlib / Test / System / DateTimeOffsetTest.cs

diff --git a/mcs/class/corlib/Test/System/DateTimeOffsetTest.cs b/mcs/class/corlib/Test/System/DateTimeOffsetTest.cs
index 7c1abdcbdcc616238601a390d541aed6710e64f4..13564426aedd1f1d97233268301b6a3c4217ae98 100644 (file)
--- a/mcs/class/corlib/Test/System/DateTimeOffsetTest.cs
+++ b/mcs/class/corlib/Test/System/DateTimeOffsetTest.cs
@@ -3,8 +3,10 @@
 //
 // Authors:
 //     Stephane Delcroix  (sdelcroix@novell.com)
+//     Marek Safar (marek.safar@gmail.com)
 //
 // Copyright (C) 2007 Novell, Inc (http://www.novell.com)
+// Copyright 2012 Xamarin, Inc (http://www.xamarin.com)
 //
 
 using System.Globalization;
@@ -161,7 +163,7 @@ namespace MonoTests.System {
                        Assert.AreEqual (dto.ToString ("r", new CultureInfo ("en-us")), dto.ToString ("R", new CultureInfo ("en-us")));
                        Assert.AreEqual ("2007-10-31T21:00:00", dto.ToString ("s", new CultureInfo ("en-us")));
                        Assert.AreEqual ("2007-11-01 05:00:00Z", dto.ToString ("u", new CultureInfo ("en-us")));
-                       Assert.AreEqual ("October, 2007", dto.ToString ("Y", new CultureInfo ("en-us")));
+                       Assert.AreEqual ("October 2007", dto.ToString ("Y", new CultureInfo ("en-us")));
                        Assert.AreEqual (dto.ToString ("y", new CultureInfo ("en-us")), dto.ToString ("Y", new CultureInfo ("en-us")));
                }
 
@@ -174,7 +176,7 @@ namespace MonoTests.System {
                                Assert.AreEqual ("Thursday, Nov 01 2007 09:00:00 -07:00", dto.ToString (format, null as DateTimeFormatInfo), "ts1");
                        Assert.AreEqual ("Thursday, Nov 01 2007 09:00:00 -07:00", dto.ToString (format, CultureInfo.InvariantCulture), "ts2");
                        Assert.AreEqual ("jeudi, nov. 01 2007 09:00:00 -07:00", dto.ToString (format, new CultureInfo ("fr-FR")), "ts3");
-                       Assert.AreEqual ("jueves, nov 01 2007 09:00:00 -07:00", dto.ToString (format, new CultureInfo ("es-ES")), "ts4");
+                       Assert.AreEqual ("jueves, Nov. 01 2007 09:00:00 -07:00", dto.ToString (format, new CultureInfo ("es-ES")), "ts4");
                }
 
                [Test]
@@ -188,7 +190,7 @@ namespace MonoTests.System {
                                "M/dd/yyyy",
                                "M/d/y",
                                "M/d/yy",
-                               "M/d/yyy",
+//                             "M/d/yyy", // this fails on .NET 2.0 (3.5) and 4.0
                                "M/d/yyyy",
                                "M/d/yyyyy",
                                "M/d/yyyyyy",
@@ -231,7 +233,10 @@ namespace MonoTests.System {
                                "M/d/yyyy H:m zzz",    "MM/d/yyyy H:m zzz",
                                "M/dd/yy H:m zzz",     "MM/dd/yy H:m zzz",
                                "M/d/yy H:m zzz",      "M/d/yy H:m zzz",
-                               "ddd dd MMM yyyy h:mm tt zzz", 
+                               "ddd dd MMM yyyy h:mm tt zzz",
+                               "o", "O",
+                               "r", "R",
+                               "u",
                        };
 
                        foreach (DateTimeOffset dto in dtos)
@@ -250,7 +255,14 @@ namespace MonoTests.System {
                [Test]
                public void ParseExactWithKFormat ()
                {
-                       DateTimeOffset o = DateTimeOffset.ParseExact ("Wed Mar 17 22:25:08 +0000 2010", "ddd MMM d H:m:ss K yyyy", null);
+                       DateTimeOffset o = DateTimeOffset.ParseExact ("Wed Mar 17 22:25:08 +0000 2010", "ddd MMM d H:m:ss K yyyy", CultureInfo.InvariantCulture);
+               }
+
+               [Test]
+               public void ParseExactCustomFormat ()
+               {
+                       var dt = DateTimeOffset.ParseExact ("Sunday, 06-Nov-94 08:49:37 GMT", "dddd, dd'-'MMM'-'yy HH:mm:ss 'GMT'", CultureInfo.InvariantCulture);
+                       Assert.AreEqual (new DateTimeOffset (1994, 11, 6, 8, 49, 37, TimeZone.CurrentTimeZone.GetUtcOffset (DateTime.Now)), dt);
                }
                
                [Test]
@@ -265,7 +277,7 @@ namespace MonoTests.System {
                        };
 
                        string[] formats = {
-                               "M/d/yyy H:m zzz",
+//                             "M/d/yyy H:m zzz", // fails under .NET 2.0 and 4.0.
                                "M/d/yyyy H:m zzz",
                                "M/d/yyyyy H:m zzz",
                                "M/d/yyyyyy H:m zzz",
@@ -353,6 +365,16 @@ namespace MonoTests.System {
                        DateTimeOffset.ParseExact(date, format, fp);
                }
 
+               [Test]
+               [ExpectedException (typeof (FormatException))]
+               public void ParseExactFormatException5 ()
+               {
+                       CultureInfo fp = CultureInfo.InvariantCulture;
+                       string format = "U";
+                       string date = "Mon 14 Jan 2008 2:56 PM +01: 00";
+                       DateTimeOffset.ParseExact (date, format, fp);
+               }
+
                [Test]
                public void ParseExactWithSeconds ()
                {
@@ -430,14 +452,14 @@ namespace MonoTests.System {
                }
 
                [Test]
-               [ExpectedException (typeof (ArgumentOutOfRangeException))]
+               [ExpectedException (typeof (FormatException))]
                public void ParseUnderflow ()
                {
                        DateTimeOffset.Parse ("01/01/0001 0:0 +09:00", new CultureInfo ("en-US"));
                }
 
                [Test]
-               [ExpectedException (typeof (ArgumentOutOfRangeException))]
+               [ExpectedException (typeof (FormatException))]
                public void ParseOverflow ()
                {
                        DateTimeOffset.Parse ("12/31/9999 23:59 -09:00", new CultureInfo ("en-US"));
@@ -646,6 +668,60 @@ namespace MonoTests.System {
                        Assert.AreEqual (dto.Offset, dto2.Offset);
                        Assert.AreEqual (dt.AddDays (-60), dto2.DateTime);
                }
+
+               [Test]
+               public void TestPartialDateTimeParsing ()
+               {
+                       var now = DateTime.Now;
+                       const DateTimeStyles style = DateTimeStyles.AssumeUniversal;
+
+                       //year
+                       var date = DateTimeOffset.ParseExact ("2003", "yyyy", CultureInfo.InvariantCulture, style);
+                       var expected = "01/01/2003 00:00:00 +00:00";
+                       Assert.AreEqual (expected, date.ToString (CultureInfo.InvariantCulture));
+
+                       //month
+                       date = DateTimeOffset.ParseExact ("12", "MM", CultureInfo.InvariantCulture, style);
+                       expected = string.Format ("12/01/{0} 00:00:00 +00:00", now.Year);
+                       Assert.AreEqual (expected, date.ToString (CultureInfo.InvariantCulture));
+
+                       //day
+                       date = DateTimeOffset.ParseExact ("29", "dd", CultureInfo.InvariantCulture, style);
+                       expected = string.Format ("01/29/{0} 00:00:00 +00:00", now.Year);
+                       Assert.AreEqual (expected, date.ToString (CultureInfo.InvariantCulture));
+
+                       //hours
+                       date = DateTimeOffset.ParseExact ("06", "HH", CultureInfo.InvariantCulture, style);
+                       expected = string.Format ("{0:D2}/{1:D2}/{2} 06:00:00 +00:00", now.Month, now.Day, now.Year);
+                       Assert.AreEqual (expected, date.ToString (CultureInfo.InvariantCulture));
+
+                       //minutes
+                       date = DateTimeOffset.ParseExact ("45", "mm", CultureInfo.InvariantCulture, style);
+                       expected = string.Format ("{0:D2}/{1:D2}/{2} 00:45:00 +00:00", now.Month, now.Day, now.Year);
+                       Assert.AreEqual (expected, date.ToString (CultureInfo.InvariantCulture));
+
+                       //seconds
+                       date = DateTimeOffset.ParseExact ("45", "ss", CultureInfo.InvariantCulture, style);
+                       expected = string.Format ("{0:D2}/{1:D2}/{2} 00:00:45 +00:00", now.Month, now.Day, now.Year);
+                       Assert.AreEqual (expected, date.ToString (CultureInfo.InvariantCulture));
+               }
+
+               [Test]
+               public void TestDateOnlyWithTimeOffset ()
+               {
+                       var fp = CultureInfo.InvariantCulture;
+                       var date = DateTimeOffset.Parse("2013-11-07+11:00", fp, DateTimeStyles.AssumeUniversal);
+                       var expected = string.Format ("{0:D2}/{1:D2}/{2} 00:00:00 +11:00", 11, 7, 2013);
+                       Assert.AreEqual (expected, date.ToString (CultureInfo.InvariantCulture));
+               }
+
+               [Test]
+               public void GMTDateTime ()
+               {
+                       var date = DateTimeOffset.Parse ("Wed, 10 Sep 2014 22:01:40 GMT", CultureInfo.InvariantCulture);
+                       var expected = "09/10/2014 22:01:40 +00:00";
+                       Assert.AreEqual (expected, date.ToString (CultureInfo.InvariantCulture));
+               }
        }
 }