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 ToDecimal ()
 199                 {
 200                         Assert.AreEqual (1.987, XmlConvert.ToDecimal ("1.987"));
 201                 }
 202
 203                 [Test]
 204                 public void ToDouble ()
 205                 {
 206                         Assert.AreEqual (1.0d/0.0d, XmlConvert.ToDouble ("INF"));
 207                         Assert.AreEqual (-1.0d/0.0d, XmlConvert.ToDouble ("-INF"));
 208                         Assert.AreEqual (0.0d/0.0d, XmlConvert.ToDouble ("NaN"));
 209                         Assert.AreEqual (789324, XmlConvert.ToDouble ("789324"));
 210                         Assert.AreEqual (42, XmlConvert.ToDouble ("  42  "));
 211                         Assert.AreEqual (double.NaN, XmlConvert.ToDouble ("  NaN  "));
 212                         Assert.AreEqual (double.PositiveInfinity, XmlConvert.ToDouble ("  Infinity  "));
 213                         Assert.AreEqual (double.NegativeInfinity, XmlConvert.ToDouble ("  -Infinity "));
 214                         Assert.AreEqual (double.PositiveInfinity, XmlConvert.ToDouble ("  INF"));
 215                         Assert.AreEqual (double.NegativeInfinity, XmlConvert.ToDouble ("  -INF "));
 216                 }
 217
 218                 [Test]
 219                 public void ToDoubleRoundtrip ()
 220                 {
 221                         // bug #320424
 222                         string s = XmlConvert.ToString (double.MaxValue);
 223                         Assert.AreEqual (double.MaxValue, XmlConvert.ToDouble (s));
 224                 }
 225
 226                 [Test]
 227                 public void ToGuid ()
 228                 {
 229                         Assert.AreEqual (new Guid ("ca761232-ed42-11ce-bacd-00aa0057b223"), XmlConvert.ToGuid ("ca761232-ed42-11ce-bacd-00aa0057b223"));
 230                 }
 231
 232                 [Test]
 233                 public void ToInt16 ()
 234                 {
 235                         Assert.AreEqual (0, XmlConvert.ToInt16 ("0"), "0");
 236                         Assert.AreEqual (-1, XmlConvert.ToInt16 ("-1"), "-1");
 237                         Assert.AreEqual (1, XmlConvert.ToInt16 ("1"), "1");
 238                         Assert.AreEqual (32767, XmlConvert.ToInt16 ("32767"), "32767");
 239                         Assert.AreEqual (-32768, XmlConvert.ToInt16 ("-32768"), "-32768");
 240                         try {
 241                                 XmlConvert.ToInt16 ("32768");
 242                                 Assert.Fail ("32768");
 243                         } catch (OverflowException) {
 244                         }
 245                         try {
 246                                 XmlConvert.ToInt16 ("-32769");
 247                                 Assert.Fail ("-32769");
 248                         } catch (OverflowException) {
 249                         }
 250                         try {
 251                                 XmlConvert.ToInt16 ("0x100");
 252                                 Assert.Fail ("0x100");
 253                         } catch (FormatException) {
 254                         }
 255                 }
 256
 257                 [Test]
 258                 public void ToInt32 ()
 259                 {
 260                         Assert.AreEqual (0, XmlConvert.ToInt32 ("0"), "0");
 261                         Assert.AreEqual (-1, XmlConvert.ToInt32 ("-1"), "-1");
 262                         Assert.AreEqual (1, XmlConvert.ToInt32 ("1"), "1");
 263                         Assert.AreEqual (int.MaxValue, XmlConvert.ToInt32 ("2147483647"), "2147483647");
 264                         Assert.AreEqual (int.MinValue, XmlConvert.ToInt32 ("-2147483648"), "-2147483648");
 265                         try {
 266                                 int.Parse ("2147483648", CultureInfo.CurrentCulture);
 267                                 Assert.Fail ("int.Parse(current culture)");
 268                         } catch (OverflowException) {
 269                         }
 270                         try {
 271                                 int.Parse ("2147483648", CultureInfo.InvariantCulture);
 272                                 Assert.Fail ("int.Parse(invariant culture)");
 273                         } catch (OverflowException) {
 274                         }
 275                         try {
 276                                 XmlConvert.ToInt32 ("2147483648");
 277                                 Assert.Fail ("2147483648");
 278                         } catch (OverflowException) {
 279                         }
 280                         try {
 281                                 XmlConvert.ToInt32 ("-2147483649");
 282                                 Assert.Fail ("-2147483649");
 283                         } catch (OverflowException) {
 284                         }
 285                         try {
 286                                 XmlConvert.ToInt32 ("0x10000");
 287                                 Assert.Fail ("0x10000");
 288                         } catch (FormatException) {
 289                         }
 290                 }
 291
 292                 [Test]
 293                 public void ToInt64 ()
 294                 {
 295                         Assert.AreEqual (0, XmlConvert.ToInt64 ("0"), "0");
 296                         Assert.AreEqual (-1, XmlConvert.ToInt64 ("-1"), "-1");
 297                         Assert.AreEqual (1, XmlConvert.ToInt64 ("1"), "1");
 298                         Assert.AreEqual (long.MaxValue, XmlConvert.ToInt64 ("9223372036854775807"), "9223372036854775807");
 299                         Assert.AreEqual (long.MinValue, XmlConvert.ToInt64 ("-9223372036854775808"), "-9223372036854775808");
 300                         try {
 301                                 XmlConvert.ToInt64 ("9223372036854775808");
 302                                 Assert.Fail ("9223372036854775808");
 303                         } catch (OverflowException) {
 304                         }
 305                         try {
 306                                 XmlConvert.ToInt64 ("-9223372036854775809");
 307                                 Assert.Fail ("-9223372036854775809");
 308                         } catch (OverflowException) {
 309                         }
 310                         try {
 311                                 XmlConvert.ToInt64 ("0x10000");
 312                                 Assert.Fail ("0x10000");
 313                         } catch (FormatException) {
 314                         }
 315                 }
 316
 317                 [Test]
 318                 public void ToSByte ()
 319                 {
 320                         Assert.AreEqual (0, XmlConvert.ToSByte ("0"), "0");
 321                         Assert.AreEqual (-1, XmlConvert.ToSByte ("-1"), "-1");
 322                         Assert.AreEqual (1, XmlConvert.ToSByte ("1"), "1");
 323                         Assert.AreEqual (127, XmlConvert.ToSByte ("127"), "127");
 324                         Assert.AreEqual (-128, XmlConvert.ToSByte ("-128"), "-128");
 325                         try {
 326                                 XmlConvert.ToSByte ("128");
 327                                 Assert.Fail ("128");
 328                         } catch (OverflowException) {
 329                         }
 330                         try {
 331                                 XmlConvert.ToSByte ("-129");
 332                                 Assert.Fail ("-129");
 333                         } catch (OverflowException) {
 334                         }
 335                         try {
 336                                 XmlConvert.ToSByte ("0x80");
 337                                 Assert.Fail ("0x80");
 338                         } catch (FormatException) {
 339                         }
 340                 }
 341
 342                 [Test]
 343                 public void ToSingle ()
 344                 {
 345                         Assert.AreEqual (1.0d/0.0d, XmlConvert.ToSingle ("INF"));
 346                         Assert.AreEqual (-1.0d/0.0d, XmlConvert.ToSingle ("-INF"));
 347                         Assert.AreEqual (0.0d/0.0d, XmlConvert.ToSingle ("NaN"));
 348                         Assert.AreEqual (789324, XmlConvert.ToSingle ("789324"));
 349                         Assert.AreEqual (42, XmlConvert.ToSingle ("  42  "));
 350                         Assert.AreEqual (float.NaN, XmlConvert.ToSingle ("  NaN  "));
 351                         Assert.AreEqual (float.PositiveInfinity, XmlConvert.ToSingle ("  Infinity  "));
 352                         Assert.AreEqual (float.NegativeInfinity, XmlConvert.ToSingle ("  -Infinity "));
 353                         Assert.AreEqual (float.PositiveInfinity, XmlConvert.ToSingle ("  INF"));
 354                         Assert.AreEqual (float.NegativeInfinity, XmlConvert.ToSingle ("  -INF "));
 355                 }
 356
 357                 [Test]
 358                 public void ToStringTest ()//not done
 359                 {
 360                         // Don't include TimeZone value for test value.
 361                         string dateString =
 362                                 XmlConvert.ToString (new DateTime (2003, 5, 5));
 363                         Assert.AreEqual (33, dateString.Length);
 364                         Assert.AreEqual (dateString.Substring (0, 27), "2003-05-05T00:00:00.0000000");
 365
 366                         // Must not throw an exception...
 367                         Assert.IsNotNull ("-P10675199DT2H48M5.4775808S", XmlConvert.ToString (TimeSpan.MinValue));
 368                 }
 369
 370                 [Test]
 371                 public void FromTimeSpan ()
 372                 {
 373                         // bug #77252
 374                         TimeSpan t1 = TimeSpan.FromTicks (
 375                                 TimeSpan.TicksPerSecond + 1);
 376                         Assert.AreEqual ("PT1.0000001S", XmlConvert.ToString (t1), "#1");
 377
 378                         // XAttributeTest.CastTimeSpans():#5d
 379                         t1 = new TimeSpan (2710L);
 380                         Assert.AreEqual ("PT0.000271S", XmlConvert.ToString (t1), "#2");
 381                         t1 = new TimeSpan (27100000L);
 382                         Assert.AreEqual ("PT2.71S", XmlConvert.ToString (t1), "#3");
 383                 }
 384
 385                 [Test]
 386                 public void ToTimeSpan ()
 387                 {
 388                         Assert.AreEqual (new TimeSpan (0, 0, 0, 0, 1), XmlConvert.ToTimeSpan ("PT0.001S"), "#1");
 389                         // bug #76328
 390                         Assert.AreEqual (new TimeSpan (0, 0, 0, 0, 100), XmlConvert.ToTimeSpan ("PT0.1S"), "#2");
 391                         Assert.AreEqual (new TimeSpan (0, 0, 0, 0, 100), XmlConvert.ToTimeSpan ("PT0.100S"), "#3");
 392                         Assert.AreEqual (new TimeSpan (0, 0, 0, 0, 10), XmlConvert.ToTimeSpan ("PT0.010S"), "#4");
 393                         Assert.AreEqual (new TimeSpan (0, 0, 0, 0, 10), XmlConvert.ToTimeSpan ("PT0.01S"), "#5");
 394
 395                         // bug #77252
 396                         Assert.AreEqual (TimeSpan.FromTicks (TimeSpan.TicksPerSecond + 1), XmlConvert.ToTimeSpan ("PT1.0000001S"), "#6");
 397
 398                         Assert.AreEqual (TimeSpan.MinValue, XmlConvert.ToTimeSpan ("-P10675199DT2H48M5.4775808S"), "#7");
 399
 400                         Assert.AreEqual (TimeSpan.MaxValue, XmlConvert.ToTimeSpan ("P10675199DT2H48M5.4775807S"), "#8");
 401
 402                         Assert.AreEqual (TimeSpan.FromDays (2), XmlConvert.ToTimeSpan (" \r\n   \tP2D  "), "#9");
 403                 }
 404
 405                 [Test]
 406                 public void ToUInt16 ()
 407                 {
 408                         Assert.AreEqual (0, XmlConvert.ToUInt16 ("0"), "0");
 409                         Assert.AreEqual (1, XmlConvert.ToUInt16 ("1"), "1");
 410                         Assert.AreEqual (ushort.MaxValue, XmlConvert.ToUInt16 ("65535"), "65535");
 411                         try {
 412                                 ushort.Parse ("65536", CultureInfo.CurrentCulture);
 413                                 Assert.Fail ("ushort.Parse(current culture)");
 414                         } catch (OverflowException) {
 415                         }
 416                         try {
 417                                 ushort.Parse ("65536", CultureInfo.InvariantCulture);
 418                                 Assert.Fail ("ushort.Parse(invariant culture)");
 419                         } catch (OverflowException) {
 420                         }
 421                         try {
 422                                 XmlConvert.ToUInt16 ("65536");
 423                                 Assert.Fail ("65536");
 424                         } catch (OverflowException) {
 425                         }
 426                         try {
 427                                 XmlConvert.ToUInt16 ("0x10000");
 428                                 Assert.Fail ("0x10000");
 429                         } catch (FormatException) {
 430                         }
 431                         // LAMESPEC: it is not fixable as there is no public
 432                         // member of UInt16 that treats this as FormatException
 433                         // while others above as either OverflowException or
 434                         // FormatException respectively.
 435                         // (.NET uses internal member in UInt16 here);
 436                         //try {
 437                         //      XmlConvert.ToUInt16 ("-101");
 438                         //      Assert.Fail ("-101");
 439                         //} catch (FormatException) {
 440                         //}
 441                 }
 442
 443                 [Test]
 444                 public void ToUInt32 ()
 445                 {
 446                         Assert.AreEqual (0, XmlConvert.ToUInt32 ("0"), "0");
 447                         Assert.AreEqual (1, XmlConvert.ToUInt32 ("1"), "1");
 448                         Assert.AreEqual (uint.MaxValue, XmlConvert.ToUInt32 ("4294967295"), "4294967295");
 449                         try {
 450                                 uint.Parse ("4294967296", CultureInfo.CurrentCulture);
 451                                 Assert.Fail ("uint.Parse(current culture)");
 452                         } catch (OverflowException) {
 453                         }
 454                         try {
 455                                 uint.Parse ("4294967296", CultureInfo.InvariantCulture);
 456                                 Assert.Fail ("uint.Parse(invariant culture)");
 457                         } catch (OverflowException) {
 458                         }
 459                         try {
 460                                 XmlConvert.ToUInt32 ("4294967296");
 461                                 Assert.Fail ("4294967296");
 462                         } catch (OverflowException) {
 463                         }
 464                         try {
 465                                 XmlConvert.ToUInt32 ("0x10000");
 466                                 Assert.Fail ("0x10000");
 467                         } catch (FormatException) {
 468                         }
 469                         // LAMESPEC: it is not fixable as there is no public
 470                         // member of UInt32 that treats this as FormatException
 471                         // while others above as either OverflowException or
 472                         // FormatException respectively.
 473                         // (.NET uses internal member in UInt32 here);
 474                         //try {
 475                         //      XmlConvert.ToUInt32 ("-101");
 476                         //      Assert.Fail ("-101");
 477                         //} catch (FormatException) {
 478                         //}
 479                 }
 480
 481                 [Test]
 482                 public void ToUInt64 ()
 483                 {
 484                         Assert.AreEqual (0, XmlConvert.ToUInt64 ("0"), "0");
 485                         Assert.AreEqual (1, XmlConvert.ToUInt64 ("1"), "1");
 486                         Assert.AreEqual (ulong.MaxValue, XmlConvert.ToUInt64 ("18446744073709551615"), "18446744073709551615");
 487                         try {
 488                                 ulong.Parse ("18446744073709551616", CultureInfo.CurrentCulture);
 489                                 Assert.Fail ("ulong.Parse(current culture)");
 490                         } catch (OverflowException) {
 491                         }
 492                         try {
 493                                 ulong.Parse ("18446744073709551616", CultureInfo.InvariantCulture);
 494                                 Assert.Fail ("ulong.Parse(invariant culture)");
 495                         } catch (OverflowException) {
 496                         }
 497                         try {
 498                                 XmlConvert.ToUInt64 ("18446744073709551616");
 499                                 Assert.Fail ("18446744073709551616");
 500                         } catch (OverflowException) {
 501                         }
 502                         try {
 503                                 XmlConvert.ToUInt64 ("0x10000");
 504                                 Assert.Fail ("0x10000");
 505                         } catch (FormatException) {
 506                         }
 507                         // LAMESPEC: it is not fixable as there is no public
 508                         // member of UInt64 that treats this as FormatException
 509                         // while others above as either OverflowException or
 510                         // FormatException respectively.
 511                         // (.NET uses internal member in UInt64 here);
 512                         //try {
 513                         //      XmlConvert.ToUInt64 ("-101");
 514                         //      Assert.Fail ("-101");
 515                         //} catch (FormatException) {
 516                         //}
 517                 }
 518
 519                 [Test]
 520                 public void VerifyName ()
 521                 {
 522                         VerifyNameValid ("a");
 523                         VerifyNameValid ("a1");
 524                         VerifyNameValid ("\u3041");
 525                         VerifyNameValid ("a:b");
 526                         VerifyNameValid ("_");
 527                         VerifyNameValid ("__");
 528                         VerifyNameValid ("_1");
 529                         VerifyNameValid (":");
 530                         VerifyNameValid (":a");
 531                         VerifyNameValid ("a.b");
 532                 }
 533
 534                 [Test]
 535                 public void VerifyNameInvalid ()
 536                 {
 537                         VerifyNameInvalid ("!");
 538                         VerifyNameInvalid ("_a!b");
 539                         VerifyNameInvalid ("?a");
 540                         VerifyNameInvalid (" ");
 541                 }
 542
 543                 [Test]
 544                 [ExpectedException (typeof (ArgumentNullException))]
 545                 public void VerifyNameNull ()
 546                 {
 547                         XmlConvert.VerifyName (null);
 548                 }
 549
 550                 [Test]
 551                 [ExpectedException (typeof (ArgumentNullException))]
 552                 public void VerifyNameEmpty ()
 553                 {
 554                         XmlConvert.VerifyName ("");
 555                 }
 556
 557                 private void VerifyNameValid (string value)
 558                 {
 559                         try {
 560                                 XmlConvert.VerifyName (value);
 561                         } catch (XmlException) {
 562                                 Assert.Fail (String.Format ("'{0}'", value));
 563                         }
 564                 }
 565
 566                 private void VerifyNameInvalid (string value)
 567                 {
 568                         try {
 569                                 XmlConvert.VerifyName (value);
 570                                 Assert.Fail (value);
 571                         } catch (XmlException) {
 572                         }
 573                 }
 574
 575                 [Test]
 576                 public void VerifyNCName ()
 577                 {
 578                         Assert.AreEqual ("foo", XmlConvert.VerifyNCName ("foo"));
 579                         try {
 580                                 XmlConvert.VerifyNCName ("?foo");
 581                                 Assert.Fail ();
 582                         } catch (XmlException) {}
 583                         try {
 584                                 XmlConvert.VerifyNCName (":foo");
 585                                 Assert.Fail ();
 586                         } catch (XmlException) {}
 587                         try {
 588                                 XmlConvert.VerifyNCName ("foo:bar");
 589                                 Assert.Fail ();
 590                         } catch (XmlException) {}
 591                         try {
 592                                 XmlConvert.VerifyNCName ("foo:bar:baz");
 593                                 Assert.Fail ();
 594                         } catch (XmlException) {}
 595                 }
 596
 597                 [Test]
 598                 [ExpectedException (typeof (ArgumentNullException))]
 599                 public void VerifyNCNameNull ()
 600                 {
 601                         XmlConvert.VerifyNCName (null);
 602                 }
 603
 604                 [Test]
 605                 [ExpectedException (typeof (ArgumentNullException))]
 606                 public void VerifyNCNameEmpty ()
 607                 {
 608                         XmlConvert.VerifyNCName ("");
 609                 }
 610
 611                 [Test]
 612                 public void DurationZero () // bug #77350
 613                 {
 614                         Assert.AreEqual ("PT0S", XmlConvert.ToString (TimeSpan.FromSeconds (0)));
 615                 }
 616
 617 #if NET_2_0
 618                 [Test]
 619                 public void VerifyTOKEN ()
 620                 {
 621                         VerifyToken ("", true);
 622                         VerifyToken (" ", false);
 623                         VerifyToken ("A", true);
 624                         VerifyToken ("!", true);
 625                         VerifyToken (" !", false);
 626                         VerifyToken ("! ", false);
 627                         VerifyToken ("! !", true);
 628                         VerifyToken ("!\t!", false);
 629                         VerifyToken ("!\n!", false);
 630                         VerifyToken ("!\r!", false);
 631                         VerifyToken ("###", true);
 632                 }
 633
 634                 private void VerifyToken (string s, bool success)
 635                 {
 636                         try {
 637                                 XmlConvert.VerifyTOKEN (s);
 638                                 if (success)
 639                                         return;
 640                                 Assert.Fail (s + "should fail");
 641                         } catch (XmlException ex) {
 642                                 if (success)
 643                                         Assert.Fail (s + "should not fail");
 644                         }
 645                 }
 646
 647                 [Test]
 648                 public void XmlDateTimeSerializationModeAndMaxValue ()
 649                 {
 650                         Assert.AreEqual ("9999-12-31T23:59:59.9999999", XmlConvert.ToString (DateTime.MaxValue, XmlDateTimeSerializationMode.Unspecified).Substring (0, 27), "#1");
 651                         Assert.AreEqual ("9999-12-31T23:59:59.9999999Z", XmlConvert.ToString (DateTime.MaxValue, XmlDateTimeSerializationMode.Utc), "#2");
 652                         Assert.AreEqual ("9999-12-31T23:59:59.9999999", XmlConvert.ToString (DateTime.MaxValue, XmlDateTimeSerializationMode.RoundtripKind), "#3");
 653                         Assert.AreEqual ("9999-12-31T23:59:59.9999999", XmlConvert.ToString (DateTime.MaxValue, XmlDateTimeSerializationMode.Local).Substring (0, 27), "#4");
 654                         // direct formatting string - no difference
 655                         Assert.AreEqual ("9999-12-31T23:59:59.9999999Z", XmlConvert.ToString (DateTime.MaxValue, "yyyy-MM-ddTHH:mm:ss.FFFFFFFZ"), "#5");
 656                         Assert.AreEqual ("9999-12-31T23:59:59.9999999", XmlConvert.ToString (DateTime.MaxValue, "yyyy-MM-ddTHH:mm:ss.FFFFFFFzzz").Substring (0, 27), "#6");
 657                 }
 658
 659                 [Test]
 660                 public void XmlDateTimeSerializationModeRountripKind ()
 661                 {
 662                         string format = "yyyy-MM-ddTHH:mm:ss.FFFFFFFK";
 663                         string s = XmlConvert.ToString (DateTime.UtcNow, format);
 664                         Assert.AreEqual ('Z', s [s.Length -1], "#1-1");
 665                         // LAMESPEC: .NET has a bug here that 'K' in format string does not reflect 'Z' as Utc Kind.
 666                         // https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=307694
 667                         //Assert.AreEqual (DateTimeKind.Utc, XmlConvert.ToDateTime (s, format).Kind, "#1-2");
 668
 669                         s = XmlConvert.ToString (DateTime.UtcNow, XmlDateTimeSerializationMode.RoundtripKind);
 670                         Assert.AreEqual ('Z', s [s.Length -1], "#2-1");
 671                         Assert.AreEqual (DateTimeKind.Utc, XmlConvert.ToDateTime (s, XmlDateTimeSerializationMode.RoundtripKind).Kind, "#2-2");
 672                 }
 673
 674                 [Test]
 675                 public void XmlDateTimeSerializationModeUnspecified ()
 676                 {
 677                         Assert.AreEqual (27, XmlConvert.ToString (new DateTime (DateTime.MaxValue.Ticks, DateTimeKind.Utc), XmlDateTimeSerializationMode.Unspecified).Length, "#1");
 678                         DateTime dt1 = XmlConvert.ToDateTime ("0001-02-03T10:20:30.0000+02:00", XmlDateTimeSerializationMode.Unspecified);
 679                         DateTime dt2 = XmlConvert.ToDateTime ("0001-02-03T10:20:30.0000", XmlDateTimeSerializationMode.Unspecified);
 680                         Assert.AreEqual (false, dt1 == dt2, "#2");
 681                         XmlConvert.ToDateTime ("2006-05-30T09:48:32.0Z", XmlDateTimeSerializationMode.Unspecified);
 682                         string format = "yyyy-MM-ddTHH:mm:ss.FFFFFFFK";
 683                         XmlConvert.ToDateTime (XmlConvert.ToString (DateTime.UtcNow, format), XmlDateTimeSerializationMode.Unspecified);
 684                 }
 685
 686                 [Test]
 687                 public void XmlDateTimeSerializationModeLocal ()
 688                 {
 689                         XmlConvert.ToDateTime ("2010-11-10", XmlDateTimeSerializationMode.Local); // bug #655089
 690                         XmlConvert.ToDateTime ("2010-11", XmlDateTimeSerializationMode.Local);
 691                 }
 692
 693                 [Test]
 694                 public void XmlDateTimeSerializationModeUtc ()
 695                 {
 696                         Assert.AreEqual (27, XmlConvert.ToString (new DateTime (DateTime.MaxValue.Ticks, DateTimeKind.Utc), XmlDateTimeSerializationMode.Unspecified).Length, "#1");
 697                         DateTime dt1 = XmlConvert.ToDateTime ("0001-02-03T10:20:30.0000+02:00", XmlDateTimeSerializationMode.Utc);
 698                         DateTime dt2 = XmlConvert.ToDateTime ("0001-02-03T10:20:30.0000", XmlDateTimeSerializationMode.Utc);
 699                         Assert.AreEqual (false, dt1 == dt2, "#2");
 700                         XmlConvert.ToDateTime ("2006-05-30T09:48:32.0Z", XmlDateTimeSerializationMode.Utc);
 701                         XmlConvert.ToDateTime ("2006-05-30T09:48:32.0+02:00", XmlDateTimeSerializationMode.Utc);
 702                         XmlConvert.ToDateTime ("2008-06-11T11:09:47.125Z", XmlDateTimeSerializationMode.Utc);
 703                 }
 704
 705                 [Test]
 706                 public void XmlDateTimeSerializationModeSeveralFormats ()
 707                 {
 708                         XmlDateTimeSerializationMode m = XmlDateTimeSerializationMode.RoundtripKind;
 709                         XmlConvert.ToDateTime ("0001", m);
 710                         XmlConvert.ToDateTime ("0001Z", m);
 711                         XmlConvert.ToDateTime ("0001+09:00", m);
 712                         XmlConvert.ToDateTime ("0001-02", m);
 713                         XmlConvert.ToDateTime ("0001-02Z", m);
 714                         XmlConvert.ToDateTime ("0001-02+09:00", m);
 715                         XmlConvert.ToDateTime ("0001-02-03", m);
 716                         XmlConvert.ToDateTime ("0001-02-03Z", m);
 717                         XmlConvert.ToDateTime ("0001-02-03+09:00", m);
 718                         XmlConvert.ToDateTime ("--02-03", m);
 719                         XmlConvert.ToDateTime ("--02-03Z", m);
 720                         XmlConvert.ToDateTime ("--02-03+09:00", m);
 721                         XmlConvert.ToDateTime ("---03", m);
 722                         XmlConvert.ToDateTime ("---03Z", m);
 723                         XmlConvert.ToDateTime ("---03+09:00", m);
 724                         XmlConvert.ToDateTime ("10:20:30", m);
 725                         XmlConvert.ToDateTime ("10:20:30Z", m);
 726                         XmlConvert.ToDateTime ("10:20:30+09:00", m);
 727                         XmlConvert.ToDateTime ("0001-02-03T10:20:30", m);
 728                         XmlConvert.ToDateTime ("0001-02-03T10:20:30Z", m);
 729                         XmlConvert.ToDateTime ("0001-02-03T10:20:30+09:00", m);
 730                         XmlConvert.ToDateTime ("0001-02-03T10:20:30.00", m);
 731                         XmlConvert.ToDateTime ("0001-02-03T10:20:30.00Z", m);
 732                         XmlConvert.ToDateTime ("0001-02-03T10:20:30.00+09:00", m);
 733                         XmlConvert.ToDateTime ("0001-02-03T10:20:30.0000", m);
 734                         XmlConvert.ToDateTime ("0001-02-03T10:20:30.0000Z", m);
 735                         XmlConvert.ToDateTime ("0001-02-03T10:20:30.0000+09:00", m);
 736
 737                         try {
 738                                 XmlConvert.ToDateTime ("0001-02-03T", m);
 739                                 Assert.Fail ("#1");
 740                         } catch (FormatException) {
 741                         }
 742                         try {
 743                                 XmlConvert.ToDateTime ("0001-02-03T10:20", m);
 744                                 Assert.Fail ("#2");
 745                         } catch (FormatException) {
 746                         }
 747                         try {
 748                                 XmlConvert.ToDateTime ("0001-02-03T10:20:30.", m);
 749                                 Assert.Fail ("#3");
 750                         } catch (FormatException) {
 751                         }
 752                 }
 753
 754                 [Test] // see http://smdn.invisiblefulmoon.net/misc/forum/programming/#n10
 755                 public void DateTimeOffsetTimezoneRoundtrip ()
 756                 {
 757                         Assert.AreEqual (new DateTimeOffset (2009, 11, 05, 20, 16, 22, TimeSpan.FromHours (9)),  XmlConvert.ToDateTimeOffset ("2009-11-05T20:16:22+09:00"), "#1");
 758                 }
 759
 760                 [Test]
 761                 public void DateTimeOffsetWithWhitespace ()
 762                 {
 763                         var s = "   2010-01-02T00:00:00Z \t";
 764                         XmlConvert.ToDateTime (s);
 765                 }
 766
 767                 [Test]
 768                 public void ToDateTimeUtc ()
 769                 {
 770                         // bug #661787
 771                         var date = XmlConvert.ToDateTime ("2010-12-29T22:01:15.1619814", XmlDateTimeSerializationMode.Utc);
 772                         Assert.AreEqual (22, date.Hour, "#1");
 773                 }
 774 #endif
 775         }
 776 }
 777