mcs/class/System.XML/Test/System.Xml/XmlConvertTests.cs

   1 //
   2 // System.Xml.XmlConvertTests.cs
   3 //
   4 // Authors: Atsushi Enomoto (ginga@kit.hi-ho.ne.jp), Jon Kessler (jwkpiano1@comcast.net)
   5 //
   6 // (C) 2003 Atsushi Enomoto, Jon Kessler
   7 //
   8
   9 using System;
  10 using System.Globalization;
  11 using System.Xml;
  12 using NUnit.Framework;
  13
  14 namespace MonoTests.System.Xml
  15 {
  16         [TestFixture]
  17         public class XmlConvertTests
  18         {
  19                 private void AssertName (string result, string source)
  20                 {
  21                         Assert.AreEqual (result,
  22                                 XmlConvert.EncodeName (source));
  23                 }
  24
  25                 private void AssertNmToken (string result, string source)
  26                 {
  27                         Assert.AreEqual (result,
  28                                 XmlConvert.EncodeNmToken (source));
  29                 }
  30
  31                 [Test]
  32                 public void DecodeName ()
  33                 {
  34                         Assert.AreEqual (null, XmlConvert.DecodeName (null));
  35                         Assert.AreEqual ("", XmlConvert.DecodeName (""));
  36                         Assert.AreEqual ("Test", XmlConvert.DecodeName ("Test"));
  37                         Assert.AreEqual ("_Test", XmlConvert.DecodeName ("_Test"));
  38                         Assert.AreEqual ("_hello_friends", XmlConvert.DecodeName ("_hello_friends"));
  39                         Assert.AreEqual ("_hello friends", XmlConvert.DecodeName ("_hello friends"));
  40                         Assert.AreEqual (" ", XmlConvert.DecodeName ("_x0020_"));
  41                 }
  42
  43                 [Test]
  44                 public void EncodeLocalName ()
  45                 {
  46                         Assert.IsNull (XmlConvert.EncodeLocalName (null));
  47                         Assert.AreEqual (String.Empty, XmlConvert.EncodeLocalName (String.Empty));
  48                         Assert.AreEqual ("Hello_x003A__x0020_", XmlConvert.EncodeLocalName ("Hello: "));
  49                         Assert.AreEqual ("Hello", XmlConvert.EncodeLocalName ("Hello"));
  50                 }
  51
  52                 [Test]
  53                 public void EncodeName ()
  54                 {
  55                         Assert.IsNull (XmlConvert.EncodeName (null));
  56                         Assert.AreEqual (String.Empty, XmlConvert.EncodeName (String.Empty));
  57                         AssertName ("Test", "Test");
  58                         AssertName ("Hello_x0020_my_x0020_friends.", "Hello my friends.");
  59                         AssertName ("_x0031_23", "123");
  60                         AssertName ("_x005F_x0031_23", "_x0031_23");
  61                 }
  62
  63                 [Test]
  64                 public void EncodeNmToken ()
  65                 {
  66                         Assert.IsNull (XmlConvert.EncodeNmToken (null));
  67                         AssertNmToken ("Test", "Test");
  68                         AssertNmToken ("Hello_x0020_my_x0020_friends.", "Hello my friends.");
  69                         AssertNmToken ("123", "123");
  70                         AssertNmToken ("_x005F_x0031_23", "_x0031_23");
  71                 }
  72
  73                 [Test]
  74                 [ExpectedException (typeof (XmlException))]
  75                 public void EncodeNmTokenError ()
  76                 {
  77                         XmlConvert.EncodeNmToken (String.Empty);
  78                 }
  79
  80                 [Test]
  81                 public void ToBoolean ()
  82                 {
  83                         Assert.AreEqual (true, XmlConvert.ToBoolean ("  1 "));
  84                         Assert.AreEqual (true, XmlConvert.ToBoolean (" true "));
  85                         Assert.AreEqual (false, XmlConvert.ToBoolean (" 0 "));
  86                         Assert.AreEqual (false, XmlConvert.ToBoolean (" false "));
  87                         try
  88                         {
  89                                 Assert.AreEqual (false, XmlConvert.ToBoolean (" invalid "));
  90                         }
  91                         catch (FormatException)
  92                         {
  93                         }
  94                 }
  95
  96                 [Test]
  97                 public void ToByte ()
  98                 {
  99                         Assert.AreEqual (255, XmlConvert.ToByte ("255"));
 100                 }
 101
 102                 [Test]
 103                 public void ToChar ()
 104                 {
 105                         Assert.AreEqual ('x', XmlConvert.ToChar ("x"));
 106                 }
 107
 108                 [Test]
 109                 public void ToDateTime ()
 110                 {
 111                         //dateTime
 112                         Assert.AreEqual (632001798000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00").Ticks);
 113                         Assert.AreEqual (632001798000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.0").Ticks);
 114                         Assert.AreEqual (632001798000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.00").Ticks);
 115                         Assert.AreEqual (632001798000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.000").Ticks);
 116                         Assert.AreEqual (632001798000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.0000").Ticks);
 117                         Assert.AreEqual (632001798000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.00000").Ticks);
 118                         Assert.AreEqual (632001798000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.000000").Ticks);
 119                         Assert.AreEqual (632001798000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.0000000").Ticks);
 120                         /*
 121                         // These tests also failed on MS.NET
 122                         Assert.AreEqual (632001150000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00+13:00").Ticks);
 123                         Assert.AreEqual (632001150000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.0+13:00").Ticks);
 124                         Assert.AreEqual (632001150000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.00+13:00").Ticks);
 125                         Assert.AreEqual (632001150000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.000+13:00").Ticks);
 126                         Assert.AreEqual (632001150000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.0000+13:00").Ticks);
 127                         Assert.AreEqual (632001150000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.00000+13:00").Ticks);
 128                         Assert.AreEqual (632001150000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.000000+13:00").Ticks);
 129                         Assert.AreEqual (632001150000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.0000000+13:00").Ticks);
 130                         Assert.AreEqual (632001618000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00Z").Ticks);
 131                         Assert.AreEqual (632001618000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.0Z").Ticks);
 132                         Assert.AreEqual (632001618000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.00Z").Ticks);
 133                         Assert.AreEqual (632001618000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.000Z").Ticks);
 134                         Assert.AreEqual (632001618000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.0000Z").Ticks);
 135                         Assert.AreEqual (632001618000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.00000Z").Ticks);
 136                         Assert.AreEqual (632001618000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.000000Z").Ticks);
 137                         Assert.AreEqual (632001618000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.0000000Z").Ticks);
 138                         */
 139                         //time
 140                         DateTime t1 = new DateTime (DateTime.Today.Year, 1, 1);
 141                         t1 = DateTime.Today + new TimeSpan (12,0,0);
 142                         Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00").Ticks);
 143                         Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.0").Ticks);
 144                         Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.00").Ticks);
 145                         Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.000").Ticks);
 146                         Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.0000").Ticks);
 147                         Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.00000").Ticks);
 148                         Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.000000").Ticks);
 149                         Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.0000000").Ticks);
 150                         //Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00+13:00").Ticks);//doesn't work on .NET
 151                         //Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.f+13:00").Ticks);//doesn't work on .NET
 152                         //Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.ff+13:00").Ticks);//doesn't work on .NET
 153                         //Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.fff+13:00").Ticks);//doesn't work on .NET
 154                         //Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.ffff+13:00").Ticks);//doesn't work on .NET
 155                         //Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.fffff+13:00").Ticks);//doesn't work on .NET
 156                         //Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.ffffff+13:00").Ticks);//doesn't work on .NET
 157                         //Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.fffffff+13:00").Ticks);//doesn't work on .NET
 158                         //Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00Z").Ticks);//doesn't work on .NET
 159                         //Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.fZ").Ticks);//doesn't work on .NET
 160                         //Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.ffZ").Ticks);//doesn't work on .NET
 161                         //Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.fffZ").Ticks);//doesn't work on .NET
 162                         //Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.ffffZ").Ticks);//doesn't work on .NET
 163                         //Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.fffffZ").Ticks);//doesn't work on .NET
 164                         //Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.ffffffZ").Ticks);//doesn't work on .NET
 165                         //Assert.AreEqual (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.fffffffZ").Ticks);//doesn't work on .NET
 166                         //date
 167                         Assert.AreEqual (632001312000000000L, XmlConvert.ToDateTime ("2003-09-26").Ticks);
 168 //                      Assert.AreEqual (632000664000000000L, XmlConvert.ToDateTime ("2003-09-26+13:00").Ticks);
 169 //                      Assert.AreEqual (632001132000000000L, XmlConvert.ToDateTime ("2003-09-26Z").Ticks);
 170                         //gYearMonth
 171                         Assert.AreEqual (631979712000000000L, XmlConvert.ToDateTime ("2003-09").Ticks);
 172 //                      Assert.AreEqual (631979064000000000L, XmlConvert.ToDateTime ("2003-09+13:00").Ticks);
 173 //                      Assert.AreEqual (631979532000000000L, XmlConvert.ToDateTime ("2003-09Z").Ticks);
 174                         //gYear
 175                         Assert.AreEqual (631769760000000000L, XmlConvert.ToDateTime ("2003").Ticks);
 176 //                      Assert.AreEqual (631769076000000000L, XmlConvert.ToDateTime ("2003+13:00").Ticks);
 177 //                      Assert.AreEqual (631769544000000000L, XmlConvert.ToDateTime ("2003Z").Ticks);
 178                         //gMonthDay
 179 // Don't try locale-dependent test
 180 //                      Assert.AreEqual (632001312000000000L, XmlConvert.ToDateTime ("--09-26").Ticks);//shouldn't have a hardcoded value
 181 //                      Assert.AreEqual (632000664000000000L, XmlConvert.ToDateTime ("--09-26+13:00").Ticks);//shouldn't have a hardcoded value
 182 //                      Assert.AreEqual (632001132000000000L, XmlConvert.ToDateTime ("--09-26Z").Ticks);//shouldn't have a hardcoded value
 183                         //gDay
 184 // Don't try locale-dependent test
 185 //                      Assert.AreEqual (631791360000000000L, XmlConvert.ToDateTime ("---26").Ticks);//shouldn't have a hardcoded value
 186 //                      Assert.AreEqual (631790676000000000L, XmlConvert.ToDateTime ("---26+13:00").Ticks);//shouldn't have a hardcoded value
 187 //                      Assert.AreEqual (631791144000000000L, XmlConvert.ToDateTime ("---26Z").Ticks);//shouldn't have a hardcoded value
 188                         try
 189                         {
 190                                 Assert.AreEqual (45L, XmlConvert.ToDateTime (";ljdfas;kl").Ticks);
 191                         }
 192                         catch (Exception)
 193                         {
 194                         }
 195                 }
 196
 197                 [Test]
 198                 public void ToDateTimeWithSerializationMode ()
 199                 {
 200             //check resulting datetime depending on serialization mode
 201             foreach (XmlDateTimeSerializationMode dateTimeSerializationMode in Enum.GetValues (typeof (XmlDateTimeSerializationMode))) {
 202                 //dateTime local
 203                 Assert.AreEqual (new DateTime(2003, 09, 26, 13, 30, 44, 000).Ticks,
 204                                         XmlConvert.ToDateTime ("2003-09-26T13:30:44", dateTimeSerializationMode).Ticks);
 205                 Assert.AreEqual (new DateTime(2003, 09, 26, 13, 30, 44, 000).Ticks,
 206                                         XmlConvert.ToDateTime ("2003-09-26T13:30:44.0", dateTimeSerializationMode).Ticks);
 207                 Assert.AreEqual (new DateTime(2003, 09, 26, 13, 30, 44, 000).Ticks,
 208                                         XmlConvert.ToDateTime ("2003-09-26T13:30:44.00", dateTimeSerializationMode).Ticks);
 209                 Assert.AreEqual (new DateTime(2003, 09, 26, 13, 30, 44, 000).Ticks,
 210                                         XmlConvert.ToDateTime ("2003-09-26T13:30:44.000", dateTimeSerializationMode).Ticks);
 211                 Assert.AreEqual (new DateTime(2003, 09, 26, 13, 30, 44, 000).Ticks,
 212                                         XmlConvert.ToDateTime ("2003-09-26T13:30:44.0000", dateTimeSerializationMode).Ticks);
 213                 Assert.AreEqual (new DateTime(2003, 09, 26, 13, 30, 44, 000).Ticks,
 214                                         XmlConvert.ToDateTime ("2003-09-26T13:30:44.00000", dateTimeSerializationMode).Ticks);
 215                 Assert.AreEqual (new DateTime(2003, 09, 26, 13, 30, 44, 000).Ticks,
 216                                         XmlConvert.ToDateTime ("2003-09-26T13:30:44.000000", dateTimeSerializationMode).Ticks);
 217                 Assert.AreEqual (new DateTime(2003, 09, 26, 13, 30, 44, 000).Ticks,
 218                                         XmlConvert.ToDateTime ("2003-09-26T13:30:44.0000000", dateTimeSerializationMode).Ticks);
 219                 Assert.AreEqual (new DateTime(2003, 09, 26, 13, 30, 44, 123).Ticks,
 220                                         XmlConvert.ToDateTime ("2003-09-26T13:30:44.123", dateTimeSerializationMode).Ticks);
 221
 222                 //dateTime with zero timezone
 223                 if (dateTimeSerializationMode == XmlDateTimeSerializationMode.Local) {
 224                     Assert.AreEqual (new DateTime(2003, 09, 26, 13, 30, 44, 000, DateTimeKind.Utc).ToLocalTime ().Ticks,
 225                                                 XmlConvert.ToDateTime ("2003-09-26T13:30:44Z", dateTimeSerializationMode).Ticks);
 226                     Assert.AreEqual (new DateTime(2003, 09, 26, 13, 30, 44, 000, DateTimeKind.Utc).ToLocalTime ().Ticks,
 227                                                 XmlConvert.ToDateTime ("2003-09-26T13:30:44.0Z", dateTimeSerializationMode).Ticks);
 228                     Assert.AreEqual (new DateTime(2003, 09, 26, 13, 30, 44, 000, DateTimeKind.Utc).ToLocalTime ().Ticks,
 229                                                 XmlConvert.ToDateTime ("2003-09-26T13:30:44.00Z", dateTimeSerializationMode).Ticks);
 230                     Assert.AreEqual (new DateTime(2003, 09, 26, 13, 30, 44, 000, DateTimeKind.Utc).ToLocalTime ().Ticks,
 231                                                 XmlConvert.ToDateTime ("2003-09-26T13:30:44.000Z", dateTimeSerializationMode).Ticks);
 232                     Assert.AreEqual (new DateTime(2003, 09, 26, 13, 30, 44, 000, DateTimeKind.Utc).ToLocalTime ().Ticks,
 233                                                 XmlConvert.ToDateTime ("2003-09-26T13:30:44.0000Z", dateTimeSerializationMode).Ticks);
 234                     Assert.AreEqual (new DateTime(2003, 09, 26, 13, 30, 44, 000, DateTimeKind.Utc).ToLocalTime ().Ticks,
 235                                                 XmlConvert.ToDateTime ("2003-09-26T13:30:44.00000Z", dateTimeSerializationMode).Ticks);
 236                     Assert.AreEqual (new DateTime(2003, 09, 26, 13, 30, 44, 000, DateTimeKind.Utc).ToLocalTime ().Ticks,
 237                                                 XmlConvert.ToDateTime ("2003-09-26T13:30:44.000000Z", dateTimeSerializationMode).Ticks);
 238                     Assert.AreEqual (new DateTime(2003, 09, 26, 13, 30, 44, 000, DateTimeKind.Utc).ToLocalTime ().Ticks,
 239                                                 XmlConvert.ToDateTime ("2003-09-26T13:30:44.0000000Z", dateTimeSerializationMode).Ticks);
 240                     Assert.AreEqual (new DateTime(2003, 09, 26, 13, 30, 44, 123, DateTimeKind.Utc).ToLocalTime ().Ticks,
 241                                                 XmlConvert.ToDateTime ("2003-09-26T13:30:44.123Z", dateTimeSerializationMode).Ticks);
 242                 } else {
 243                     Assert.AreEqual (new DateTime(2003, 09, 26, 13, 30, 44, 000, DateTimeKind.Local).Ticks,
 244                                                 XmlConvert.ToDateTime ("2003-09-26T13:30:44Z", dateTimeSerializationMode).Ticks);
 245                     Assert.AreEqual (new DateTime(2003, 09, 26, 13, 30, 44, 000, DateTimeKind.Local).Ticks,
 246                                                 XmlConvert.ToDateTime ("2003-09-26T13:30:44.0Z", dateTimeSerializationMode).Ticks);
 247                     Assert.AreEqual (new DateTime(2003, 09, 26, 13, 30, 44, 000, DateTimeKind.Local).Ticks,
 248                                                 XmlConvert.ToDateTime ("2003-09-26T13:30:44.00Z", dateTimeSerializationMode).Ticks);
 249                     Assert.AreEqual (new DateTime(2003, 09, 26, 13, 30, 44, 000, DateTimeKind.Local).Ticks,
 250                                                 XmlConvert.ToDateTime ("2003-09-26T13:30:44.000Z", dateTimeSerializationMode).Ticks);
 251                     Assert.AreEqual (new DateTime(2003, 09, 26, 13, 30, 44, 000, DateTimeKind.Local).Ticks,
 252                                                 XmlConvert.ToDateTime ("2003-09-26T13:30:44.0000Z", dateTimeSerializationMode).Ticks);
 253                     Assert.AreEqual (new DateTime(2003, 09, 26, 13, 30, 44, 000, DateTimeKind.Local).Ticks,
 254                                                 XmlConvert.ToDateTime ("2003-09-26T13:30:44.00000Z", dateTimeSerializationMode).Ticks);
 255                     Assert.AreEqual (new DateTime(2003, 09, 26, 13, 30, 44, 000, DateTimeKind.Local).Ticks,
 256                                                 XmlConvert.ToDateTime ("2003-09-26T13:30:44.000000Z", dateTimeSerializationMode).Ticks);
 257                     Assert.AreEqual (new DateTime(2003, 09, 26, 13, 30, 44, 000, DateTimeKind.Local).Ticks,
 258                                                 XmlConvert.ToDateTime ("2003-09-26T13:30:44.0000000Z", dateTimeSerializationMode).Ticks);
 259                     Assert.AreEqual (new DateTime(2003, 09, 26, 13, 30, 44, 123, DateTimeKind.Local).Ticks,
 260                                                 XmlConvert.ToDateTime ("2003-09-26T13:30:44.123Z", dateTimeSerializationMode).Ticks);
 261                 }
 262
 263                 //dateTime with timezone
 264                 if (dateTimeSerializationMode == XmlDateTimeSerializationMode.Utc) {
 265                     Assert.AreEqual (new DateTimeOffset (2003, 09, 26, 13, 30, 44, 000, new TimeSpan (13, 0, 0)).ToUniversalTime ().Ticks,
 266                                                 XmlConvert.ToDateTime ("2003-09-26T13:30:44+13:00", dateTimeSerializationMode).Ticks);
 267                     Assert.AreEqual (new DateTimeOffset (2003, 09, 26, 13, 30, 44, 000, new TimeSpan (13, 0, 0)).ToUniversalTime ().Ticks,
 268                                                 XmlConvert.ToDateTime ("2003-09-26T13:30:44.0+13:00", dateTimeSerializationMode).Ticks);
 269                     Assert.AreEqual (new DateTimeOffset (2003, 09, 26, 13, 30, 44, 000, new TimeSpan (13, 0, 0)).ToUniversalTime ().Ticks,
 270                                                 XmlConvert.ToDateTime ("2003-09-26T13:30:44.00+13:00", dateTimeSerializationMode).Ticks);
 271                     Assert.AreEqual (new DateTimeOffset (2003, 09, 26, 13, 30, 44, 000, new TimeSpan (13, 0, 0)).ToUniversalTime ().Ticks,
 272                                                 XmlConvert.ToDateTime ("2003-09-26T13:30:44.000+13:00", dateTimeSerializationMode).Ticks);
 273                     Assert.AreEqual (new DateTimeOffset (2003, 09, 26, 13, 30, 44, 000, new TimeSpan (13, 0, 0)).ToUniversalTime ().Ticks,
 274                                                 XmlConvert.ToDateTime ("2003-09-26T13:30:44.0000+13:00", dateTimeSerializationMode).Ticks);
 275                     Assert.AreEqual (new DateTimeOffset (2003, 09, 26, 13, 30, 44, 000, new TimeSpan (13, 0, 0)).ToUniversalTime ().Ticks,
 276                                                 XmlConvert.ToDateTime ("2003-09-26T13:30:44.00000+13:00", dateTimeSerializationMode).Ticks);
 277                     Assert.AreEqual (new DateTimeOffset (2003, 09, 26, 13, 30, 44, 000, new TimeSpan (13, 0, 0)).ToUniversalTime ().Ticks,
 278                                                 XmlConvert.ToDateTime ("2003-09-26T13:30:44.000000+13:00", dateTimeSerializationMode).Ticks);
 279                     Assert.AreEqual (new DateTimeOffset (2003, 09, 26, 13, 30, 44, 000, new TimeSpan (13, 0, 0)).ToUniversalTime ().Ticks,
 280                                                 XmlConvert.ToDateTime ("2003-09-26T13:30:44.0000000+13:00", dateTimeSerializationMode).Ticks);
 281                     Assert.AreEqual (new DateTimeOffset (2003, 09, 26, 13, 30, 44, 123, new TimeSpan (13, 0, 0)).ToUniversalTime ().Ticks,
 282                                                 XmlConvert.ToDateTime ("2003-09-26T13:30:44.123+13:00", dateTimeSerializationMode).Ticks);
 283                 } else {
 284                     Assert.AreEqual (new DateTimeOffset (2003, 09, 26, 13, 30, 44, 000, new TimeSpan (13, 0, 0)).ToLocalTime ().Ticks,
 285                                                 XmlConvert.ToDateTime ("2003-09-26T13:30:44+13:00", dateTimeSerializationMode).Ticks);
 286                     Assert.AreEqual (new DateTimeOffset (2003, 09, 26, 13, 30, 44, 000, new TimeSpan (13, 0, 0)).ToLocalTime ().Ticks,
 287                                                 XmlConvert.ToDateTime ("2003-09-26T13:30:44.0+13:00", dateTimeSerializationMode).Ticks);
 288                     Assert.AreEqual (new DateTimeOffset (2003, 09, 26, 13, 30, 44, 000, new TimeSpan (13, 0, 0)).ToLocalTime ().Ticks,
 289                                                 XmlConvert.ToDateTime ("2003-09-26T13:30:44.00+13:00", dateTimeSerializationMode).Ticks);
 290                     Assert.AreEqual (new DateTimeOffset (2003, 09, 26, 13, 30, 44, 000, new TimeSpan (13, 0, 0)).ToLocalTime ().Ticks,
 291                                                 XmlConvert.ToDateTime ("2003-09-26T13:30:44.000+13:00", dateTimeSerializationMode).Ticks);
 292                     Assert.AreEqual (new DateTimeOffset (2003, 09, 26, 13, 30, 44, 000, new TimeSpan (13, 0, 0)).ToLocalTime ().Ticks,
 293                                                 XmlConvert.ToDateTime ("2003-09-26T13:30:44.0000+13:00", dateTimeSerializationMode).Ticks);
 294                     Assert.AreEqual (new DateTimeOffset (2003, 09, 26, 13, 30, 44, 000, new TimeSpan (13, 0, 0)).ToLocalTime ().Ticks,
 295                                                 XmlConvert.ToDateTime ("2003-09-26T13:30:44.00000+13:00", dateTimeSerializationMode).Ticks);
 296                     Assert.AreEqual (new DateTimeOffset (2003, 09, 26, 13, 30, 44, 000, new TimeSpan (13, 0, 0)).ToLocalTime ().Ticks,
 297                                                 XmlConvert.ToDateTime ("2003-09-26T13:30:44.000000+13:00", dateTimeSerializationMode).Ticks);
 298                     Assert.AreEqual (new DateTimeOffset (2003, 09, 26, 13, 30, 44, 000, new TimeSpan (13, 0, 0)).ToLocalTime ().Ticks,
 299                                                 XmlConvert.ToDateTime ("2003-09-26T13:30:44.0000000+13:00", dateTimeSerializationMode).Ticks);
 300                     Assert.AreEqual (new DateTimeOffset (2003, 09, 26, 13, 30, 44, 123, new TimeSpan (13, 0, 0)).ToLocalTime ().Ticks,
 301                                                 XmlConvert.ToDateTime ("2003-09-26T13:30:44.123+13:00", dateTimeSerializationMode).Ticks);
 302                 }
 303
 304                 //time local
 305                 Assert.AreEqual (new DateTime(DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 13, 30, 44, 000).Ticks,
 306                                         XmlConvert.ToDateTime ("13:30:44", dateTimeSerializationMode).Ticks);
 307                 Assert.AreEqual (new DateTime(DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 13, 30, 44, 000).Ticks,
 308                                         XmlConvert.ToDateTime ("13:30:44.0", dateTimeSerializationMode).Ticks);
 309                 Assert.AreEqual (new DateTime(DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 13, 30, 44, 000).Ticks,
 310                                         XmlConvert.ToDateTime ("13:30:44.00", dateTimeSerializationMode).Ticks);
 311                 Assert.AreEqual (new DateTime(DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 13, 30, 44, 000).Ticks,
 312                                         XmlConvert.ToDateTime ("13:30:44.000", dateTimeSerializationMode).Ticks);
 313                 Assert.AreEqual (new DateTime(DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 13, 30, 44, 000).Ticks,
 314                                         XmlConvert.ToDateTime ("13:30:44.0000", dateTimeSerializationMode).Ticks);
 315                 Assert.AreEqual (new DateTime(DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 13, 30, 44, 000).Ticks,
 316                                         XmlConvert.ToDateTime ("13:30:44.00000", dateTimeSerializationMode).Ticks);
 317                 Assert.AreEqual (new DateTime(DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 13, 30, 44, 000).Ticks,
 318                                         XmlConvert.ToDateTime ("13:30:44.000000", dateTimeSerializationMode).Ticks);
 319                 Assert.AreEqual (new DateTime(DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 13, 30, 44, 000).Ticks,
 320                                         XmlConvert.ToDateTime ("13:30:44.0000000", dateTimeSerializationMode).Ticks);
 321                 Assert.AreEqual (new DateTime(DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 13, 30, 44, 123).Ticks,
 322                                         XmlConvert.ToDateTime ("13:30:44.123", dateTimeSerializationMode).Ticks);
 323
 324                 //time with zero timezone
 325                 if (dateTimeSerializationMode == XmlDateTimeSerializationMode.Local) {
 326                     Assert.AreEqual (new DateTime(DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 13, 30, 44, 000, DateTimeKind.Utc).ToLocalTime ().Ticks,
 327                                                 XmlConvert.ToDateTime ("13:30:44Z", dateTimeSerializationMode).Ticks);
 328                     Assert.AreEqual (new DateTime(DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 13, 30, 44, 000, DateTimeKind.Utc).ToLocalTime ().Ticks,
 329                                                 XmlConvert.ToDateTime ("13:30:44.0Z", dateTimeSerializationMode).Ticks);
 330                     Assert.AreEqual (new DateTime(DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 13, 30, 44, 000, DateTimeKind.Utc).ToLocalTime ().Ticks,
 331                                                 XmlConvert.ToDateTime ("13:30:44.00Z", dateTimeSerializationMode).Ticks);
 332                     Assert.AreEqual (new DateTime(DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 13, 30, 44, 000, DateTimeKind.Utc).ToLocalTime ().Ticks,
 333                                                 XmlConvert.ToDateTime ("13:30:44.000Z", dateTimeSerializationMode).Ticks);
 334                     Assert.AreEqual (new DateTime(DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 13, 30, 44, 000, DateTimeKind.Utc).ToLocalTime ().Ticks,
 335                                                 XmlConvert.ToDateTime ("13:30:44.0000Z", dateTimeSerializationMode).Ticks);
 336                     Assert.AreEqual (new DateTime(DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 13, 30, 44, 000, DateTimeKind.Utc).ToLocalTime ().Ticks,
 337                                                 XmlConvert.ToDateTime ("13:30:44.00000Z", dateTimeSerializationMode).Ticks);
 338                     Assert.AreEqual (new DateTime(DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 13, 30, 44, 000, DateTimeKind.Utc).ToLocalTime ().Ticks,
 339                                                 XmlConvert.ToDateTime ("13:30:44.000000Z", dateTimeSerializationMode).Ticks);
 340                     Assert.AreEqual (new DateTime(DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 13, 30, 44, 000, DateTimeKind.Utc).ToLocalTime ().Ticks,
 341                                                 XmlConvert.ToDateTime ("13:30:44.0000000Z", dateTimeSerializationMode).Ticks);
 342                     Assert.AreEqual (new DateTime(DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 13, 30, 44, 123, DateTimeKind.Utc).ToLocalTime ().Ticks,
 343                                                 XmlConvert.ToDateTime ("13:30:44.123Z", dateTimeSerializationMode).Ticks);
 344                 } else {
 345                     Assert.AreEqual (new DateTime(DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 13, 30, 44, 000, DateTimeKind.Local).Ticks,
 346                                                 XmlConvert.ToDateTime ("13:30:44Z", dateTimeSerializationMode).Ticks);
 347                     Assert.AreEqual (new DateTime(DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 13, 30, 44, 000, DateTimeKind.Local).Ticks,
 348                                                 XmlConvert.ToDateTime ("13:30:44.0Z", dateTimeSerializationMode).Ticks);
 349                     Assert.AreEqual (new DateTime(DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 13, 30, 44, 000, DateTimeKind.Local).Ticks,
 350                                                 XmlConvert.ToDateTime ("13:30:44.00Z", dateTimeSerializationMode).Ticks);
 351                     Assert.AreEqual (new DateTime(DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 13, 30, 44, 000, DateTimeKind.Local).Ticks,
 352                                                 XmlConvert.ToDateTime ("13:30:44.000Z", dateTimeSerializationMode).Ticks);
 353                     Assert.AreEqual (new DateTime(DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 13, 30, 44, 000, DateTimeKind.Local).Ticks,
 354                                                 XmlConvert.ToDateTime ("13:30:44.0000Z", dateTimeSerializationMode).Ticks);
 355                     Assert.AreEqual (new DateTime(DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 13, 30, 44, 000, DateTimeKind.Local).Ticks,
 356                                                 XmlConvert.ToDateTime ("13:30:44.00000Z", dateTimeSerializationMode).Ticks);
 357                     Assert.AreEqual (new DateTime(DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 13, 30, 44, 000, DateTimeKind.Local).Ticks,
 358                                                 XmlConvert.ToDateTime ("13:30:44.000000Z", dateTimeSerializationMode).Ticks);
 359                     Assert.AreEqual (new DateTime(DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 13, 30, 44, 000, DateTimeKind.Local).Ticks,
 360                                                 XmlConvert.ToDateTime ("13:30:44.0000000Z", dateTimeSerializationMode).Ticks);
 361                     Assert.AreEqual (new DateTime(DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 13, 30, 44, 123, DateTimeKind.Local).Ticks,
 362                                                 XmlConvert.ToDateTime ("13:30:44.123Z", dateTimeSerializationMode).Ticks);
 363                 }
 364
 365                 //time with timezone
 366                 if (dateTimeSerializationMode == XmlDateTimeSerializationMode.Utc) {
 367                     Assert.AreEqual (new DateTimeOffset (DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 13, 30, 44, 000, new TimeSpan (13, 0, 0)).ToUniversalTime ().Ticks,
 368                                                 XmlConvert.ToDateTime ("13:30:44+13:00", dateTimeSerializationMode).Ticks);
 369                     Assert.AreEqual (new DateTimeOffset (DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 13, 30, 44, 000, new TimeSpan (13, 0, 0)).ToUniversalTime ().Ticks,
 370                                                 XmlConvert.ToDateTime ("13:30:44.0+13:00", dateTimeSerializationMode).Ticks);
 371                     Assert.AreEqual (new DateTimeOffset (DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 13, 30, 44, 000, new TimeSpan (13, 0, 0)).ToUniversalTime ().Ticks,
 372                                                 XmlConvert.ToDateTime ("13:30:44.00+13:00", dateTimeSerializationMode).Ticks);
 373                     Assert.AreEqual (new DateTimeOffset (DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 13, 30, 44, 000, new TimeSpan (13, 0, 0)).ToUniversalTime ().Ticks,
 374                                                 XmlConvert.ToDateTime ("13:30:44.000+13:00", dateTimeSerializationMode).Ticks);
 375                     Assert.AreEqual (new DateTimeOffset (DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 13, 30, 44, 000, new TimeSpan (13, 0, 0)).ToUniversalTime ().Ticks,
 376                                                 XmlConvert.ToDateTime ("13:30:44.0000+13:00", dateTimeSerializationMode).Ticks);
 377                     Assert.AreEqual (new DateTimeOffset (DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 13, 30, 44, 000, new TimeSpan (13, 0, 0)).ToUniversalTime ().Ticks,
 378                                                 XmlConvert.ToDateTime ("13:30:44.00000+13:00", dateTimeSerializationMode).Ticks);
 379                     Assert.AreEqual (new DateTimeOffset (DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 13, 30, 44, 000, new TimeSpan (13, 0, 0)).ToUniversalTime ().Ticks,
 380                                                 XmlConvert.ToDateTime ("13:30:44.000000+13:00", dateTimeSerializationMode).Ticks);
 381                     Assert.AreEqual (new DateTimeOffset (DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 13, 30, 44, 000, new TimeSpan (13, 0, 0)).ToUniversalTime ().Ticks,
 382                                                 XmlConvert.ToDateTime ("13:30:44.0000000+13:00", dateTimeSerializationMode).Ticks);
 383                     Assert.AreEqual (new DateTimeOffset (DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 13, 30, 44, 123, new TimeSpan (13, 0, 0)).ToUniversalTime ().Ticks,
 384                                                 XmlConvert.ToDateTime ("13:30:44.123+13:00", dateTimeSerializationMode).Ticks);
 385                 } else {
 386                     Assert.AreEqual (new DateTimeOffset (DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 13, 30, 44, 000, new TimeSpan (13, 0, 0)).ToLocalTime ().Ticks,
 387                                                 XmlConvert.ToDateTime ("13:30:44+13:00", dateTimeSerializationMode).Ticks);
 388                     Assert.AreEqual (new DateTimeOffset (DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 13, 30, 44, 000, new TimeSpan (13, 0, 0)).ToLocalTime ().Ticks,
 389                                                 XmlConvert.ToDateTime ("13:30:44.0+13:00", dateTimeSerializationMode).Ticks);
 390                     Assert.AreEqual (new DateTimeOffset (DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 13, 30, 44, 000, new TimeSpan (13, 0, 0)).ToLocalTime ().Ticks,
 391                                                 XmlConvert.ToDateTime ("13:30:44.00+13:00", dateTimeSerializationMode).Ticks);
 392                     Assert.AreEqual (new DateTimeOffset (DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 13, 30, 44, 000, new TimeSpan (13, 0, 0)).ToLocalTime ().Ticks,
 393                                                 XmlConvert.ToDateTime ("13:30:44.000+13:00", dateTimeSerializationMode).Ticks);
 394                     Assert.AreEqual (new DateTimeOffset (DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 13, 30, 44, 000, new TimeSpan (13, 0, 0)).ToLocalTime ().Ticks,
 395                                                 XmlConvert.ToDateTime ("13:30:44.0000+13:00", dateTimeSerializationMode).Ticks);
 396                     Assert.AreEqual (new DateTimeOffset (DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 13, 30, 44, 000, new TimeSpan (13, 0, 0)).ToLocalTime ().Ticks,
 397                                                 XmlConvert.ToDateTime ("13:30:44.00000+13:00", dateTimeSerializationMode).Ticks);
 398                     Assert.AreEqual (new DateTimeOffset (DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 13, 30, 44, 000, new TimeSpan (13, 0, 0)).ToLocalTime ().Ticks,
 399                                                 XmlConvert.ToDateTime ("13:30:44.000000+13:00", dateTimeSerializationMode).Ticks);
 400                     Assert.AreEqual (new DateTimeOffset (DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 13, 30, 44, 000, new TimeSpan (13, 0, 0)).ToLocalTime ().Ticks,
 401                                                 XmlConvert.ToDateTime ("13:30:44.0000000+13:00", dateTimeSerializationMode).Ticks);
 402                     Assert.AreEqual (new DateTimeOffset (DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, 13, 30, 44, 123, new TimeSpan (13, 0, 0)).ToLocalTime ().Ticks,
 403                                                 XmlConvert.ToDateTime ("13:30:44.123+13:00", dateTimeSerializationMode).Ticks);
 404                 }
 405
 406                                 //date
 407                 Assert.AreEqual (new DateTime(2003, 09, 26, 00, 00, 00, 000).Ticks, XmlConvert.ToDateTime ("2003-09-26", dateTimeSerializationMode).Ticks);
 408                 if (dateTimeSerializationMode == XmlDateTimeSerializationMode.Local)
 409                     Assert.AreEqual (new DateTime(2003, 09, 26, 00, 00, 00, 000, DateTimeKind.Utc).ToLocalTime ().Ticks,
 410                                                 XmlConvert.ToDateTime ("2003-09-26Z", dateTimeSerializationMode).Ticks);
 411                 else
 412                     Assert.AreEqual (new DateTime(2003, 09, 26, 00, 00, 00, 000, DateTimeKind.Local).Ticks,
 413                                                 XmlConvert.ToDateTime ("2003-09-26Z", dateTimeSerializationMode).Ticks);
 414                 if (dateTimeSerializationMode == XmlDateTimeSerializationMode.Utc)
 415                     Assert.AreEqual (new DateTimeOffset (2003, 09, 26, 00, 00, 00, 000, new TimeSpan (13, 0, 0)).ToUniversalTime ().Ticks,
 416                                                 XmlConvert.ToDateTime ("2003-09-26+13:00", dateTimeSerializationMode).Ticks);
 417                 else
 418                     Assert.AreEqual (new DateTimeOffset (2003, 09, 26, 00, 00, 00, 000, new TimeSpan (13, 0, 0)).ToLocalTime ().Ticks,
 419                                                 XmlConvert.ToDateTime ("2003-09-26+13:00", dateTimeSerializationMode).Ticks);
 420
 421                 //gYearMonth
 422                 Assert.AreEqual (new DateTime(2003, 09, 01, 00, 00, 00, 000).Ticks, XmlConvert.ToDateTime ("2003-09", dateTimeSerializationMode).Ticks);
 423                 if (dateTimeSerializationMode == XmlDateTimeSerializationMode.Local)
 424                     Assert.AreEqual (new DateTime(2003, 09, 01, 00, 00, 00, 000, DateTimeKind.Utc).ToLocalTime ().Ticks,
 425                                                 XmlConvert.ToDateTime ("2003-09Z", dateTimeSerializationMode).Ticks);
 426                 else
 427                     Assert.AreEqual (new DateTime(2003, 09, 01, 00, 00, 00, 000, DateTimeKind.Local).Ticks,
 428                                                 XmlConvert.ToDateTime ("2003-09Z", dateTimeSerializationMode).Ticks);
 429                 if (dateTimeSerializationMode == XmlDateTimeSerializationMode.Utc)
 430                     Assert.AreEqual (new DateTimeOffset (2003, 09, 01, 00, 00, 00, 000, new TimeSpan (13, 0, 0)).ToUniversalTime ().Ticks,
 431                                                 XmlConvert.ToDateTime ("2003-09+13:00", dateTimeSerializationMode).Ticks);
 432                 else
 433                     Assert.AreEqual (new DateTimeOffset (2003, 09, 01, 00, 00, 00, 000, new TimeSpan (13, 0, 0)).ToLocalTime ().Ticks,
 434                                                 XmlConvert.ToDateTime ("2003-09+13:00", dateTimeSerializationMode).Ticks);
 435
 436                 //gYear
 437                 Assert.AreEqual (new DateTime(2003, 01, 01, 00, 00, 00, 000).Ticks, XmlConvert.ToDateTime ("2003", dateTimeSerializationMode).Ticks);
 438                 if (dateTimeSerializationMode == XmlDateTimeSerializationMode.Local)
 439                     Assert.AreEqual (new DateTime(2003, 01, 01, 00, 00, 00, 000, DateTimeKind.Utc).ToLocalTime ().Ticks,
 440                                                 XmlConvert.ToDateTime ("2003Z", dateTimeSerializationMode).Ticks);
 441                 else
 442                     Assert.AreEqual (new DateTime(2003, 01, 01, 00, 00, 00, 000, DateTimeKind.Local).Ticks,
 443                                                 XmlConvert.ToDateTime ("2003Z", dateTimeSerializationMode).Ticks);
 444                 if (dateTimeSerializationMode == XmlDateTimeSerializationMode.Utc)
 445                     Assert.AreEqual (new DateTimeOffset (2003, 01, 01, 00, 00, 00, 000, new TimeSpan (13, 0, 0)).ToUniversalTime ().Ticks,
 446                                                 XmlConvert.ToDateTime ("2003+13:00", dateTimeSerializationMode).Ticks);
 447                 else
 448                     Assert.AreEqual (new DateTimeOffset (2003, 01, 01, 00, 00, 00, 000, new TimeSpan (13, 0, 0)).ToLocalTime ().Ticks,
 449                                                 XmlConvert.ToDateTime ("2003+13:00", dateTimeSerializationMode).Ticks);
 450
 451                 //gDay
 452                 Assert.AreEqual (new DateTime(DateTime.Now.Year, 01, 26, 00, 00, 00, 000).Ticks, XmlConvert.ToDateTime ("---26", dateTimeSerializationMode).Ticks);
 453                 if (dateTimeSerializationMode == XmlDateTimeSerializationMode.Local)
 454                     Assert.AreEqual (new DateTime(DateTime.Now.Year, 01, 26, 00, 00, 00, 000, DateTimeKind.Utc).ToLocalTime ().Ticks,
 455                                                 XmlConvert.ToDateTime ("---26Z", dateTimeSerializationMode).Ticks);
 456                 else
 457                     Assert.AreEqual (new DateTime(DateTime.Now.Year, 01, 26, 00, 00, 00, 000, DateTimeKind.Local).Ticks,
 458                                                 XmlConvert.ToDateTime ("---26Z", dateTimeSerializationMode).Ticks);
 459                 if (dateTimeSerializationMode == XmlDateTimeSerializationMode.Utc)
 460                     Assert.AreEqual (new DateTimeOffset (DateTime.Now.Year, 01, 26, 00, 00, 00, 000, new TimeSpan (13, 0, 0)).ToUniversalTime ().Ticks,
 461                                                 XmlConvert.ToDateTime ("---26+13:00", dateTimeSerializationMode).Ticks);
 462                 else
 463                     Assert.AreEqual (new DateTimeOffset (DateTime.Now.Year, 01, 26, 00, 00, 00, 000, new TimeSpan (13, 0, 0)).ToLocalTime ().Ticks,
 464                                                 XmlConvert.ToDateTime ("---26+13:00", dateTimeSerializationMode).Ticks);
 465
 466             }
 467
 468             //check resulting date kind
 469             Assert.AreEqual (DateTimeKind.Local, XmlConvert.ToDateTime ("2003-09-26T13:30:44", XmlDateTimeSerializationMode.Local).Kind);
 470             Assert.AreEqual (DateTimeKind.Local, XmlConvert.ToDateTime ("2003-09-26T13:30:44Z", XmlDateTimeSerializationMode.Local).Kind);
 471             Assert.AreEqual (DateTimeKind.Local, XmlConvert.ToDateTime ("2003-09-26T13:30:44+13:00", XmlDateTimeSerializationMode.Local).Kind);
 472             Assert.AreEqual (DateTimeKind.Utc, XmlConvert.ToDateTime ("2003-09-26T13:30:44", XmlDateTimeSerializationMode.Utc).Kind);
 473             Assert.AreEqual (DateTimeKind.Utc, XmlConvert.ToDateTime ("2003-09-26T13:30:44Z", XmlDateTimeSerializationMode.Utc).Kind);
 474             Assert.AreEqual (DateTimeKind.Utc, XmlConvert.ToDateTime ("2003-09-26T13:30:44+13:00", XmlDateTimeSerializationMode.Utc).Kind);
 475             Assert.AreEqual (DateTimeKind.Unspecified, XmlConvert.ToDateTime ("2003-09-26T13:30:44", XmlDateTimeSerializationMode.Unspecified).Kind);
 476             Assert.AreEqual (DateTimeKind.Unspecified, XmlConvert.ToDateTime ("2003-09-26T13:30:44Z", XmlDateTimeSerializationMode.Unspecified).Kind);
 477             Assert.AreEqual (DateTimeKind.Unspecified, XmlConvert.ToDateTime ("2003-09-26T13:30:44+13:00", XmlDateTimeSerializationMode.Unspecified).Kind);
 478             Assert.AreEqual (DateTimeKind.Unspecified, XmlConvert.ToDateTime ("2003-09-26T13:30:44", XmlDateTimeSerializationMode.RoundtripKind).Kind);
 479             Assert.AreEqual (DateTimeKind.Utc, XmlConvert.ToDateTime ("2003-09-26T13:30:44Z", XmlDateTimeSerializationMode.RoundtripKind).Kind);
 480             Assert.AreEqual (DateTimeKind.Local, XmlConvert.ToDateTime ("2003-09-26T13:30:44+13:00", XmlDateTimeSerializationMode.RoundtripKind).Kind);
 481                 }
 482
 483                 [Test]
 484                 public void ToDecimal ()
 485                 {
 486                         Assert.AreEqual (1.987, XmlConvert.ToDecimal ("1.987"));
 487                 }
 488
 489                 [Test]
 490                 public void ToDouble ()
 491                 {
 492                         Assert.AreEqual (1.0d/0.0d, XmlConvert.ToDouble ("INF"));
 493                         Assert.AreEqual (-1.0d/0.0d, XmlConvert.ToDouble ("-INF"));
 494                         Assert.AreEqual (0.0d/0.0d, XmlConvert.ToDouble ("NaN"));
 495                         Assert.AreEqual (789324, XmlConvert.ToDouble ("789324"));
 496                         Assert.AreEqual (42, XmlConvert.ToDouble ("  42  "));
 497                         Assert.AreEqual (double.NaN, XmlConvert.ToDouble ("  NaN  "));
 498                         Assert.AreEqual (double.PositiveInfinity, XmlConvert.ToDouble ("  Infinity  "));
 499                         Assert.AreEqual (double.NegativeInfinity, XmlConvert.ToDouble ("  -Infinity "));
 500                         Assert.AreEqual (double.PositiveInfinity, XmlConvert.ToDouble ("  INF"));
 501                         Assert.AreEqual (double.NegativeInfinity, XmlConvert.ToDouble ("  -INF "));
 502                 }
 503
 504                 [Test]
 505                 public void ToDoubleRoundtrip ()
 506                 {
 507                         // bug #320424
 508                         string s = XmlConvert.ToString (double.MaxValue);
 509                         Assert.AreEqual (double.MaxValue, XmlConvert.ToDouble (s));
 510                 }
 511
 512                 [Test]
 513                 public void ToGuid ()
 514                 {
 515                         Assert.AreEqual (new Guid ("ca761232-ed42-11ce-bacd-00aa0057b223"), XmlConvert.ToGuid ("ca761232-ed42-11ce-bacd-00aa0057b223"));
 516                 }
 517
 518                 [Test]
 519                 public void ToInt16 ()
 520                 {
 521                         Assert.AreEqual (0, XmlConvert.ToInt16 ("0"), "0");
 522                         Assert.AreEqual (-1, XmlConvert.ToInt16 ("-1"), "-1");
 523                         Assert.AreEqual (1, XmlConvert.ToInt16 ("1"), "1");
 524                         Assert.AreEqual (32767, XmlConvert.ToInt16 ("32767"), "32767");
 525                         Assert.AreEqual (-32768, XmlConvert.ToInt16 ("-32768"), "-32768");
 526                         try {
 527                                 XmlConvert.ToInt16 ("32768");
 528                                 Assert.Fail ("32768");
 529                         } catch (OverflowException) {
 530                         }
 531                         try {
 532                                 XmlConvert.ToInt16 ("-32769");
 533                                 Assert.Fail ("-32769");
 534                         } catch (OverflowException) {
 535                         }
 536                         try {
 537                                 XmlConvert.ToInt16 ("0x100");
 538                                 Assert.Fail ("0x100");
 539                         } catch (FormatException) {
 540                         }
 541                 }
 542
 543                 [Test]
 544                 public void ToInt32 ()
 545                 {
 546                         Assert.AreEqual (0, XmlConvert.ToInt32 ("0"), "0");
 547                         Assert.AreEqual (-1, XmlConvert.ToInt32 ("-1"), "-1");
 548                         Assert.AreEqual (1, XmlConvert.ToInt32 ("1"), "1");
 549                         Assert.AreEqual (int.MaxValue, XmlConvert.ToInt32 ("2147483647"), "2147483647");
 550                         Assert.AreEqual (int.MinValue, XmlConvert.ToInt32 ("-2147483648"), "-2147483648");
 551                         try {
 552                                 int.Parse ("2147483648", CultureInfo.CurrentCulture);
 553                                 Assert.Fail ("int.Parse(current culture)");
 554                         } catch (OverflowException) {
 555                         }
 556                         try {
 557                                 int.Parse ("2147483648", CultureInfo.InvariantCulture);
 558                                 Assert.Fail ("int.Parse(invariant culture)");
 559                         } catch (OverflowException) {
 560                         }
 561                         try {
 562                                 XmlConvert.ToInt32 ("2147483648");
 563                                 Assert.Fail ("2147483648");
 564                         } catch (OverflowException) {
 565                         }
 566                         try {
 567                                 XmlConvert.ToInt32 ("-2147483649");
 568                                 Assert.Fail ("-2147483649");
 569                         } catch (OverflowException) {
 570                         }
 571                         try {
 572                                 XmlConvert.ToInt32 ("0x10000");
 573                                 Assert.Fail ("0x10000");
 574                         } catch (FormatException) {
 575                         }
 576                 }
 577
 578                 [Test]
 579                 public void ToInt64 ()
 580                 {
 581                         Assert.AreEqual (0, XmlConvert.ToInt64 ("0"), "0");
 582                         Assert.AreEqual (-1, XmlConvert.ToInt64 ("-1"), "-1");
 583                         Assert.AreEqual (1, XmlConvert.ToInt64 ("1"), "1");
 584                         Assert.AreEqual (long.MaxValue, XmlConvert.ToInt64 ("9223372036854775807"), "9223372036854775807");
 585                         Assert.AreEqual (long.MinValue, XmlConvert.ToInt64 ("-9223372036854775808"), "-9223372036854775808");
 586                         try {
 587                                 XmlConvert.ToInt64 ("9223372036854775808");
 588                                 Assert.Fail ("9223372036854775808");
 589                         } catch (OverflowException) {
 590                         }
 591                         try {
 592                                 XmlConvert.ToInt64 ("-9223372036854775809");
 593                                 Assert.Fail ("-9223372036854775809");
 594                         } catch (OverflowException) {
 595                         }
 596                         try {
 597                                 XmlConvert.ToInt64 ("0x10000");
 598                                 Assert.Fail ("0x10000");
 599                         } catch (FormatException) {
 600                         }
 601                 }
 602
 603                 [Test]
 604                 public void ToSByte ()
 605                 {
 606                         Assert.AreEqual (0, XmlConvert.ToSByte ("0"), "0");
 607                         Assert.AreEqual (-1, XmlConvert.ToSByte ("-1"), "-1");
 608                         Assert.AreEqual (1, XmlConvert.ToSByte ("1"), "1");
 609                         Assert.AreEqual (127, XmlConvert.ToSByte ("127"), "127");
 610                         Assert.AreEqual (-128, XmlConvert.ToSByte ("-128"), "-128");
 611                         try {
 612                                 XmlConvert.ToSByte ("128");
 613                                 Assert.Fail ("128");
 614                         } catch (OverflowException) {
 615                         }
 616                         try {
 617                                 XmlConvert.ToSByte ("-129");
 618                                 Assert.Fail ("-129");
 619                         } catch (OverflowException) {
 620                         }
 621                         try {
 622                                 XmlConvert.ToSByte ("0x80");
 623                                 Assert.Fail ("0x80");
 624                         } catch (FormatException) {
 625                         }
 626                 }
 627
 628                 [Test]
 629                 public void ToSingle ()
 630                 {
 631                         Assert.AreEqual (1.0d/0.0d, XmlConvert.ToSingle ("INF"));
 632                         Assert.AreEqual (-1.0d/0.0d, XmlConvert.ToSingle ("-INF"));
 633                         Assert.AreEqual (0.0d/0.0d, XmlConvert.ToSingle ("NaN"));
 634                         Assert.AreEqual (789324, XmlConvert.ToSingle ("789324"));
 635                         Assert.AreEqual (42, XmlConvert.ToSingle ("  42  "));
 636                         Assert.AreEqual (float.NaN, XmlConvert.ToSingle ("  NaN  "));
 637                         Assert.AreEqual (float.PositiveInfinity, XmlConvert.ToSingle ("  Infinity  "));
 638                         Assert.AreEqual (float.NegativeInfinity, XmlConvert.ToSingle ("  -Infinity "));
 639                         Assert.AreEqual (float.PositiveInfinity, XmlConvert.ToSingle ("  INF"));
 640                         Assert.AreEqual (float.NegativeInfinity, XmlConvert.ToSingle ("  -INF "));
 641                 }
 642
 643                 [Test]
 644                 public void ToStringTest ()//not done
 645                 {
 646                         // Don't include TimeZone value for test value.
 647                         string dateString =
 648                                 XmlConvert.ToString (new DateTime (2003, 5, 5));
 649                         Assert.AreEqual (33, dateString.Length);
 650                         Assert.AreEqual (dateString.Substring (0, 27), "2003-05-05T00:00:00.0000000");
 651
 652                         // Must not throw an exception...
 653                         Assert.IsNotNull ("-P10675199DT2H48M5.4775808S", XmlConvert.ToString (TimeSpan.MinValue));
 654                 }
 655
 656                 [Test]
 657         public void TimeSpanToStringShouldNotHaveTimeSuffixIfTimeIsZero()
 658         {
 659             string s = XmlConvert.ToString(new TimeSpan (345, 0, 0, 0));
 660             Assert.AreEqual("P345D", s);
 661         }
 662
 663                 [Test]
 664                 public void FromTimeSpan ()
 665                 {
 666                         // bug #77252
 667                         TimeSpan t1 = TimeSpan.FromTicks (
 668                                 TimeSpan.TicksPerSecond + 1);
 669                         Assert.AreEqual ("PT1.0000001S", XmlConvert.ToString (t1), "#1");
 670
 671                         // XAttributeTest.CastTimeSpans():#5d
 672                         t1 = new TimeSpan (2710L);
 673                         Assert.AreEqual ("PT0.000271S", XmlConvert.ToString (t1), "#2");
 674                         t1 = new TimeSpan (27100000L);
 675                         Assert.AreEqual ("PT2.71S", XmlConvert.ToString (t1), "#3");
 676                 }
 677
 678                 [Test]
 679                 public void ToTimeSpan ()
 680                 {
 681                         Assert.AreEqual (new TimeSpan (0, 0, 0, 0, 1), XmlConvert.ToTimeSpan ("PT0.001S"), "#1");
 682                         // bug #76328
 683                         Assert.AreEqual (new TimeSpan (0, 0, 0, 0, 100), XmlConvert.ToTimeSpan ("PT0.1S"), "#2");
 684                         Assert.AreEqual (new TimeSpan (0, 0, 0, 0, 100), XmlConvert.ToTimeSpan ("PT0.100S"), "#3");
 685                         Assert.AreEqual (new TimeSpan (0, 0, 0, 0, 10), XmlConvert.ToTimeSpan ("PT0.010S"), "#4");
 686                         Assert.AreEqual (new TimeSpan (0, 0, 0, 0, 10), XmlConvert.ToTimeSpan ("PT0.01S"), "#5");
 687
 688                         // bug #77252
 689                         Assert.AreEqual (TimeSpan.FromTicks (TimeSpan.TicksPerSecond + 1), XmlConvert.ToTimeSpan ("PT1.0000001S"), "#6");
 690
 691                         Assert.AreEqual (TimeSpan.MinValue, XmlConvert.ToTimeSpan ("-P10675199DT2H48M5.4775808S"), "#7");
 692
 693                         Assert.AreEqual (TimeSpan.MaxValue, XmlConvert.ToTimeSpan ("P10675199DT2H48M5.4775807S"), "#8");
 694
 695                         Assert.AreEqual (TimeSpan.FromDays (2), XmlConvert.ToTimeSpan (" \r\n   \tP2D  "), "#9");
 696                 }
 697
 698                 [Test]
 699                 public void ToUInt16 ()
 700                 {
 701                         Assert.AreEqual (0, XmlConvert.ToUInt16 ("0"), "0");
 702                         Assert.AreEqual (1, XmlConvert.ToUInt16 ("1"), "1");
 703                         Assert.AreEqual (ushort.MaxValue, XmlConvert.ToUInt16 ("65535"), "65535");
 704                         try {
 705                                 ushort.Parse ("65536", CultureInfo.CurrentCulture);
 706                                 Assert.Fail ("ushort.Parse(current culture)");
 707                         } catch (OverflowException) {
 708                         }
 709                         try {
 710                                 ushort.Parse ("65536", CultureInfo.InvariantCulture);
 711                                 Assert.Fail ("ushort.Parse(invariant culture)");
 712                         } catch (OverflowException) {
 713                         }
 714                         try {
 715                                 XmlConvert.ToUInt16 ("65536");
 716                                 Assert.Fail ("65536");
 717                         } catch (OverflowException) {
 718                         }
 719                         try {
 720                                 XmlConvert.ToUInt16 ("0x10000");
 721                                 Assert.Fail ("0x10000");
 722                         } catch (FormatException) {
 723                         }
 724                         // LAMESPEC: it is not fixable as there is no public
 725                         // member of UInt16 that treats this as FormatException
 726                         // while others above as either OverflowException or
 727                         // FormatException respectively.
 728                         // (.NET uses internal member in UInt16 here);
 729                         //try {
 730                         //      XmlConvert.ToUInt16 ("-101");
 731                         //      Assert.Fail ("-101");
 732                         //} catch (FormatException) {
 733                         //}
 734                 }
 735
 736                 [Test]
 737                 public void ToUInt32 ()
 738                 {
 739                         Assert.AreEqual (0, XmlConvert.ToUInt32 ("0"), "0");
 740                         Assert.AreEqual (1, XmlConvert.ToUInt32 ("1"), "1");
 741                         Assert.AreEqual (uint.MaxValue, XmlConvert.ToUInt32 ("4294967295"), "4294967295");
 742                         try {
 743                                 uint.Parse ("4294967296", CultureInfo.CurrentCulture);
 744                                 Assert.Fail ("uint.Parse(current culture)");
 745                         } catch (OverflowException) {
 746                         }
 747                         try {
 748                                 uint.Parse ("4294967296", CultureInfo.InvariantCulture);
 749                                 Assert.Fail ("uint.Parse(invariant culture)");
 750                         } catch (OverflowException) {
 751                         }
 752                         try {
 753                                 XmlConvert.ToUInt32 ("4294967296");
 754                                 Assert.Fail ("4294967296");
 755                         } catch (OverflowException) {
 756                         }
 757                         try {
 758                                 XmlConvert.ToUInt32 ("0x10000");
 759                                 Assert.Fail ("0x10000");
 760                         } catch (FormatException) {
 761                         }
 762                         // LAMESPEC: it is not fixable as there is no public
 763                         // member of UInt32 that treats this as FormatException
 764                         // while others above as either OverflowException or
 765                         // FormatException respectively.
 766                         // (.NET uses internal member in UInt32 here);
 767                         //try {
 768                         //      XmlConvert.ToUInt32 ("-101");
 769                         //      Assert.Fail ("-101");
 770                         //} catch (FormatException) {
 771                         //}
 772                 }
 773
 774                 [Test]
 775                 public void ToUInt64 ()
 776                 {
 777                         Assert.AreEqual (0, XmlConvert.ToUInt64 ("0"), "0");
 778                         Assert.AreEqual (1, XmlConvert.ToUInt64 ("1"), "1");
 779                         Assert.AreEqual (ulong.MaxValue, XmlConvert.ToUInt64 ("18446744073709551615"), "18446744073709551615");
 780                         try {
 781                                 ulong.Parse ("18446744073709551616", CultureInfo.CurrentCulture);
 782                                 Assert.Fail ("ulong.Parse(current culture)");
 783                         } catch (OverflowException) {
 784                         }
 785                         try {
 786                                 ulong.Parse ("18446744073709551616", CultureInfo.InvariantCulture);
 787                                 Assert.Fail ("ulong.Parse(invariant culture)");
 788                         } catch (OverflowException) {
 789                         }
 790                         try {
 791                                 XmlConvert.ToUInt64 ("18446744073709551616");
 792                                 Assert.Fail ("18446744073709551616");
 793                         } catch (OverflowException) {
 794                         }
 795                         try {
 796                                 XmlConvert.ToUInt64 ("0x10000");
 797                                 Assert.Fail ("0x10000");
 798                         } catch (FormatException) {
 799                         }
 800                         // LAMESPEC: it is not fixable as there is no public
 801                         // member of UInt64 that treats this as FormatException
 802                         // while others above as either OverflowException or
 803                         // FormatException respectively.
 804                         // (.NET uses internal member in UInt64 here);
 805                         //try {
 806                         //      XmlConvert.ToUInt64 ("-101");
 807                         //      Assert.Fail ("-101");
 808                         //} catch (FormatException) {
 809                         //}
 810                 }
 811
 812                 [Test]
 813                 public void VerifyName ()
 814                 {
 815                         VerifyNameValid ("a");
 816                         VerifyNameValid ("a1");
 817                         VerifyNameValid ("\u3041");
 818                         VerifyNameValid ("a:b");
 819                         VerifyNameValid ("_");
 820                         VerifyNameValid ("__");
 821                         VerifyNameValid ("_1");
 822                         VerifyNameValid (":");
 823                         VerifyNameValid (":a");
 824                         VerifyNameValid ("a.b");
 825                 }
 826
 827                 [Test]
 828                 public void VerifyNameInvalid ()
 829                 {
 830                         VerifyNameInvalid ("!");
 831                         VerifyNameInvalid ("_a!b");
 832                         VerifyNameInvalid ("?a");
 833                         VerifyNameInvalid (" ");
 834                 }
 835
 836                 [Test]
 837                 [ExpectedException (typeof (ArgumentNullException))]
 838                 public void VerifyNameNull ()
 839                 {
 840                         XmlConvert.VerifyName (null);
 841                 }
 842
 843                 [Test]
 844                 [ExpectedException (typeof (ArgumentNullException))]
 845                 public void VerifyNameEmpty ()
 846                 {
 847                         XmlConvert.VerifyName ("");
 848                 }
 849
 850                 private void VerifyNameValid (string value)
 851                 {
 852                         try {
 853                                 XmlConvert.VerifyName (value);
 854                         } catch (XmlException) {
 855                                 Assert.Fail (String.Format ("'{0}'", value));
 856                         }
 857                 }
 858
 859                 private void VerifyNameInvalid (string value)
 860                 {
 861                         try {
 862                                 XmlConvert.VerifyName (value);
 863                                 Assert.Fail (value);
 864                         } catch (XmlException) {
 865                         }
 866                 }
 867
 868                 [Test]
 869                 public void VerifyNCName ()
 870                 {
 871                         Assert.AreEqual ("foo", XmlConvert.VerifyNCName ("foo"));
 872                         try {
 873                                 XmlConvert.VerifyNCName ("?foo");
 874                                 Assert.Fail ();
 875                         } catch (XmlException) {}
 876                         try {
 877                                 XmlConvert.VerifyNCName (":foo");
 878                                 Assert.Fail ();
 879                         } catch (XmlException) {}
 880                         try {
 881                                 XmlConvert.VerifyNCName ("foo:bar");
 882                                 Assert.Fail ();
 883                         } catch (XmlException) {}
 884                         try {
 885                                 XmlConvert.VerifyNCName ("foo:bar:baz");
 886                                 Assert.Fail ();
 887                         } catch (XmlException) {}
 888                 }
 889
 890                 [Test]
 891                 [ExpectedException (typeof (ArgumentNullException))]
 892                 public void VerifyNCNameNull ()
 893                 {
 894                         XmlConvert.VerifyNCName (null);
 895                 }
 896
 897                 [Test]
 898                 [ExpectedException (typeof (ArgumentNullException))]
 899                 public void VerifyNCNameEmpty ()
 900                 {
 901                         XmlConvert.VerifyNCName ("");
 902                 }
 903
 904                 [Test]
 905                 public void DurationZero () // bug #77350
 906                 {
 907                         Assert.AreEqual ("PT0S", XmlConvert.ToString (TimeSpan.FromSeconds (0)));
 908                 }
 909
 910                 [Test]
 911                 public void VerifyTOKEN ()
 912                 {
 913                         VerifyToken ("", true);
 914                         VerifyToken (" ", false);
 915                         VerifyToken ("A", true);
 916                         VerifyToken ("!", true);
 917                         VerifyToken (" !", false);
 918                         VerifyToken ("! ", false);
 919                         VerifyToken ("! !", true);
 920                         VerifyToken ("!\t!", false);
 921                         VerifyToken ("!\n!", false);
 922                         VerifyToken ("!\r!", false);
 923                         VerifyToken ("###", true);
 924                 }
 925
 926                 private void VerifyToken (string s, bool success)
 927                 {
 928                         try {
 929                                 XmlConvert.VerifyTOKEN (s);
 930                                 if (success)
 931                                         return;
 932                                 Assert.Fail (s + "should fail");
 933                         } catch (XmlException ex) {
 934                                 if (success)
 935                                         Assert.Fail (s + "should not fail");
 936                         }
 937                 }
 938
 939                 [Test]
 940                 public void XmlDateTimeSerializationModeAndMaxValue ()
 941                 {
 942                         Assert.AreEqual ("9999-12-31T23:59:59.9999999", XmlConvert.ToString (DateTime.MaxValue, XmlDateTimeSerializationMode.Unspecified).Substring (0, 27), "#1");
 943                         Assert.AreEqual ("9999-12-31T23:59:59.9999999Z", XmlConvert.ToString (DateTime.MaxValue, XmlDateTimeSerializationMode.Utc), "#2");
 944                         Assert.AreEqual ("9999-12-31T23:59:59.9999999", XmlConvert.ToString (DateTime.MaxValue, XmlDateTimeSerializationMode.RoundtripKind), "#3");
 945                         Assert.AreEqual ("9999-12-31T23:59:59.9999999", XmlConvert.ToString (DateTime.MaxValue, XmlDateTimeSerializationMode.Local).Substring (0, 27), "#4");
 946                         // direct formatting string - no difference
 947                         Assert.AreEqual ("9999-12-31T23:59:59.9999999Z", XmlConvert.ToString (DateTime.MaxValue, "yyyy-MM-ddTHH:mm:ss.FFFFFFFZ"), "#5");
 948                         Assert.AreEqual ("9999-12-31T23:59:59.9999999", XmlConvert.ToString (DateTime.MaxValue, "yyyy-MM-ddTHH:mm:ss.FFFFFFFzzz").Substring (0, 27), "#6");
 949                 }
 950
 951                 [Test]
 952                 public void XmlDateTimeSerializationModeRountripKind ()
 953                 {
 954                         string format = "yyyy-MM-ddTHH:mm:ss.FFFFFFFK";
 955                         string s = XmlConvert.ToString (DateTime.UtcNow, format);
 956                         Assert.AreEqual ('Z', s [s.Length -1], "#1-1");
 957                         // LAMESPEC: .NET has a bug here that 'K' in format string does not reflect 'Z' as Utc Kind.
 958                         // https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=307694
 959                         //Assert.AreEqual (DateTimeKind.Utc, XmlConvert.ToDateTime (s, format).Kind, "#1-2");
 960
 961                         s = XmlConvert.ToString (DateTime.UtcNow, XmlDateTimeSerializationMode.RoundtripKind);
 962                         Assert.AreEqual ('Z', s [s.Length -1], "#2-1");
 963                         Assert.AreEqual (DateTimeKind.Utc, XmlConvert.ToDateTime (s, XmlDateTimeSerializationMode.RoundtripKind).Kind, "#2-2");
 964                 }
 965
 966                 [Test]
 967                 public void XmlDateTimeSerializationModeUnspecified ()
 968                 {
 969                         Assert.AreEqual (27, XmlConvert.ToString (new DateTime (DateTime.MaxValue.Ticks, DateTimeKind.Utc), XmlDateTimeSerializationMode.Unspecified).Length, "#1");
 970                         DateTime dt1 = XmlConvert.ToDateTime ("0001-02-03T10:20:30.0000+02:00", XmlDateTimeSerializationMode.Unspecified);
 971                         DateTime dt2 = XmlConvert.ToDateTime ("0001-02-03T10:20:30.0000", XmlDateTimeSerializationMode.Unspecified);
 972                         Assert.AreEqual (false, dt1 == dt2, "#2");
 973                         XmlConvert.ToDateTime ("2006-05-30T09:48:32.0Z", XmlDateTimeSerializationMode.Unspecified);
 974                         string format = "yyyy-MM-ddTHH:mm:ss.FFFFFFFK";
 975                         XmlConvert.ToDateTime (XmlConvert.ToString (DateTime.UtcNow, format), XmlDateTimeSerializationMode.Unspecified);
 976                 }
 977
 978                 [Test]
 979                 public void XmlDateTimeSerializationModeLocal ()
 980                 {
 981                         XmlConvert.ToDateTime ("2010-11-10", XmlDateTimeSerializationMode.Local); // bug #655089
 982                         XmlConvert.ToDateTime ("2010-11", XmlDateTimeSerializationMode.Local);
 983                 }
 984
 985                 [Test]
 986                 public void XmlDateTimeSerializationModeUtc ()
 987                 {
 988                         Assert.AreEqual (27, XmlConvert.ToString (new DateTime (DateTime.MaxValue.Ticks, DateTimeKind.Utc), XmlDateTimeSerializationMode.Unspecified).Length, "#1");
 989                         DateTime dt1 = XmlConvert.ToDateTime ("0001-02-03T10:20:30.0000+02:00", XmlDateTimeSerializationMode.Utc);
 990                         DateTime dt2 = XmlConvert.ToDateTime ("0001-02-03T10:20:30.0000", XmlDateTimeSerializationMode.Utc);
 991                         Assert.AreEqual (false, dt1 == dt2, "#2");
 992                         XmlConvert.ToDateTime ("2006-05-30T09:48:32.0Z", XmlDateTimeSerializationMode.Utc);
 993                         XmlConvert.ToDateTime ("2006-05-30T09:48:32.0+02:00", XmlDateTimeSerializationMode.Utc);
 994                         XmlConvert.ToDateTime ("2008-06-11T11:09:47.125Z", XmlDateTimeSerializationMode.Utc);
 995                 }
 996
 997                 [Test]
 998                 public void XmlDateTimeSerializationModeSeveralFormats ()
 999                 {
1000                         XmlDateTimeSerializationMode m = XmlDateTimeSerializationMode.RoundtripKind;
1001                         XmlConvert.ToDateTime ("0001", m);
1002                         XmlConvert.ToDateTime ("0001Z", m);
1003                         XmlConvert.ToDateTime ("0001+09:00", m);
1004                         XmlConvert.ToDateTime ("0001-02", m);
1005                         XmlConvert.ToDateTime ("0001-02Z", m);
1006                         XmlConvert.ToDateTime ("0001-02+09:00", m);
1007                         XmlConvert.ToDateTime ("0001-02-03", m);
1008                         XmlConvert.ToDateTime ("0001-02-03Z", m);
1009                         XmlConvert.ToDateTime ("0001-02-03+09:00", m);
1010                         XmlConvert.ToDateTime ("--02-03", m);
1011                         XmlConvert.ToDateTime ("--02-03Z", m);
1012                         XmlConvert.ToDateTime ("--02-03+09:00", m);
1013                         XmlConvert.ToDateTime ("---03", m);
1014                         XmlConvert.ToDateTime ("---03Z", m);
1015                         XmlConvert.ToDateTime ("---03+09:00", m);
1016                         XmlConvert.ToDateTime ("10:20:30", m);
1017                         XmlConvert.ToDateTime ("10:20:30Z", m);
1018                         XmlConvert.ToDateTime ("10:20:30+09:00", m);
1019                         XmlConvert.ToDateTime ("0001-02-03T10:20:30", m);
1020                         XmlConvert.ToDateTime ("0001-02-03T10:20:30Z", m);
1021                         XmlConvert.ToDateTime ("0001-02-03T10:20:30+09:00", m);
1022                         XmlConvert.ToDateTime ("0001-02-03T10:20:30.00", m);
1023                         XmlConvert.ToDateTime ("0001-02-03T10:20:30.00Z", m);
1024                         XmlConvert.ToDateTime ("0001-02-03T10:20:30.00+09:00", m);
1025                         XmlConvert.ToDateTime ("0001-02-03T10:20:30.0000", m);
1026                         XmlConvert.ToDateTime ("0001-02-03T10:20:30.0000Z", m);
1027                         XmlConvert.ToDateTime ("0001-02-03T10:20:30.0000+09:00", m);
1028                 }
1029
1030                 [Test]
1031                 [Category("NotWorking")]
1032                 public void XmlDateTimeSerializationModeBadFormats ()
1033                 {
1034                         XmlDateTimeSerializationMode m = XmlDateTimeSerializationMode.RoundtripKind;
1035
1036                         try {
1037                                 XmlConvert.ToDateTime ("0001-02-03T", m);
1038                                 Assert.Fail ("#1");
1039                         } catch (FormatException) {
1040                         }
1041                         try {
1042                                 XmlConvert.ToDateTime ("0001-02-03T10:20", m);
1043                                 Assert.Fail ("#2");
1044                         } catch (FormatException) {
1045                         }
1046                         try {
1047                                 XmlConvert.ToDateTime ("0001-02-03T10:20:30.", m);
1048                                 Assert.Fail ("#3");
1049                         } catch (FormatException) {
1050                         }
1051                 }
1052
1053                 [Test] // see http://smdn.invisiblefulmoon.net/misc/forum/programming/#n10
1054                 public void DateTimeOffsetTimezoneRoundtrip ()
1055                 {
1056                         Assert.AreEqual (new DateTimeOffset (2009, 11, 05, 20, 16, 22, TimeSpan.FromHours (9)),  XmlConvert.ToDateTimeOffset ("2009-11-05T20:16:22+09:00"), "#1");
1057                 }
1058
1059                 [Test]
1060                 public void DateTimeOffsetWithWhitespace ()
1061                 {
1062                         var s = "   2010-01-02T00:00:00Z \t";
1063                         XmlConvert.ToDateTime (s);
1064                 }
1065
1066                 [Test]
1067                 public void ToDateTimeUtc ()
1068                 {
1069                         // bug #661787
1070                         var date = XmlConvert.ToDateTime ("2010-12-29T22:01:15.1619814", XmlDateTimeSerializationMode.Utc);
1071                         Assert.AreEqual (22, date.Hour, "#1");
1072                 }
1073
1074                 [Test]
1075                 public void ToDateTimeZ ()
1076                 {
1077                         // bug 690475
1078                         // looks like *all* XmlDateTimeSerializationMode allows use of Z
1079                         foreach (XmlDateTimeSerializationMode mode in Enum.GetValues (typeof (XmlDateTimeSerializationMode))) {
1080                                 XmlConvert.ToDateTime ("2009-12-15T08:44:05Z", mode);
1081                                 XmlConvert.ToDateTime ("2009-12-15Z", mode);
1082                                 XmlConvert.ToDateTime ("2009-12Z", mode);
1083                                 XmlConvert.ToDateTime ("2009Z", mode);
1084                                 XmlConvert.ToDateTime ("---09Z", mode);
1085                                 XmlConvert.ToDateTime ("10:01:02Z", mode);
1086                                 XmlConvert.ToDateTime ("2009-12-15T08:44:05.2700544Z", mode);
1087                         }
1088                 }
1089         }
1090 }
1091