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 using AssertType = NUnit.Framework.Assert;
  15
  16 namespace MonoTests.System.Xml
  17 {
  18         [TestFixture]
  19         public class XmlConvertTests : Assertion
  20         {
  21                 private void AssertName (string result, string source)
  22                 {
  23                         AssertEquals (result,
  24                                 XmlConvert.EncodeName (source));
  25                 }
  26
  27                 private void AssertNmToken (string result, string source)
  28                 {
  29                         AssertEquals (result,
  30                                 XmlConvert.EncodeNmToken (source));
  31                 }
  32
  33                 [Test]
  34                 public void DecodeName ()
  35                 {
  36                         AssertEquals (null, XmlConvert.DecodeName (null));
  37                         AssertEquals ("", XmlConvert.DecodeName (""));
  38                         AssertEquals ("Test", XmlConvert.DecodeName ("Test"));
  39                         AssertEquals ("_Test", XmlConvert.DecodeName ("_Test"));
  40                         AssertEquals ("_hello_friends", XmlConvert.DecodeName ("_hello_friends"));
  41                         AssertEquals ("_hello friends", XmlConvert.DecodeName ("_hello friends"));
  42                         AssertEquals (" ", XmlConvert.DecodeName ("_x0020_"));
  43                 }
  44
  45                 [Test]
  46                 public void EncodeLocalName ()
  47                 {
  48                         AssertNull (XmlConvert.EncodeLocalName (null));
  49                         AssertEquals (String.Empty, XmlConvert.EncodeLocalName (String.Empty));
  50                         AssertEquals ("Hello_x003A__x0020_", XmlConvert.EncodeLocalName ("Hello: "));
  51                         AssertEquals ("Hello", XmlConvert.EncodeLocalName ("Hello"));
  52                 }
  53
  54                 [Test]
  55                 public void EncodeName ()
  56                 {
  57                         AssertNull (XmlConvert.EncodeName (null));
  58                         AssertEquals (String.Empty, XmlConvert.EncodeName (String.Empty));
  59                         AssertName ("Test", "Test");
  60                         AssertName ("Hello_x0020_my_x0020_friends.", "Hello my friends.");
  61                         AssertName ("_x0031_23", "123");
  62                         AssertName ("_x005F_x0031_23", "_x0031_23");
  63                 }
  64
  65                 [Test]
  66                 public void EncodeNmToken ()
  67                 {
  68                         AssertNull (XmlConvert.EncodeNmToken (null));
  69                         AssertNmToken ("Test", "Test");
  70                         AssertNmToken ("Hello_x0020_my_x0020_friends.", "Hello my friends.");
  71                         AssertNmToken ("123", "123");
  72                         AssertNmToken ("_x005F_x0031_23", "_x0031_23");
  73                 }
  74
  75                 [Test]
  76                 [ExpectedException (typeof (XmlException))]
  77                 public void EncodeNmTokenError ()
  78                 {
  79                         XmlConvert.EncodeNmToken (String.Empty);
  80                 }
  81
  82                 [Test]
  83                 public void ToBoolean ()
  84                 {
  85                         AssertEquals (true, XmlConvert.ToBoolean ("  1 "));
  86                         AssertEquals (true, XmlConvert.ToBoolean (" true "));
  87                         AssertEquals (false, XmlConvert.ToBoolean (" 0 "));
  88                         AssertEquals (false, XmlConvert.ToBoolean (" false "));
  89                         try
  90                         {
  91                                 AssertEquals (false, XmlConvert.ToBoolean (" invalid "));
  92                         }
  93                         catch (FormatException)
  94                         {
  95                         }
  96                 }
  97
  98                 [Test]
  99                 public void ToByte ()
 100                 {
 101                         AssertEquals (255, XmlConvert.ToByte ("255"));
 102                 }
 103
 104                 [Test]
 105                 public void ToChar ()
 106                 {
 107                         AssertEquals ('x', XmlConvert.ToChar ("x"));
 108                 }
 109
 110                 [Test]
 111                 public void ToDateTime ()
 112                 {
 113                         //dateTime
 114                         AssertEquals (632001798000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00").Ticks);
 115                         AssertEquals (632001798000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.0").Ticks);
 116                         AssertEquals (632001798000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.00").Ticks);
 117                         AssertEquals (632001798000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.000").Ticks);
 118                         AssertEquals (632001798000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.0000").Ticks);
 119                         AssertEquals (632001798000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.00000").Ticks);
 120                         AssertEquals (632001798000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.000000").Ticks);
 121                         AssertEquals (632001798000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.0000000").Ticks);
 122                         /*
 123                         // These tests also failed on MS.NET
 124                         AssertEquals (632001150000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00+13:00").Ticks);
 125                         AssertEquals (632001150000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.0+13:00").Ticks);
 126                         AssertEquals (632001150000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.00+13:00").Ticks);
 127                         AssertEquals (632001150000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.000+13:00").Ticks);
 128                         AssertEquals (632001150000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.0000+13:00").Ticks);
 129                         AssertEquals (632001150000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.00000+13:00").Ticks);
 130                         AssertEquals (632001150000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.000000+13:00").Ticks);
 131                         AssertEquals (632001150000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.0000000+13:00").Ticks);
 132                         AssertEquals (632001618000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00Z").Ticks);
 133                         AssertEquals (632001618000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.0Z").Ticks);
 134                         AssertEquals (632001618000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.00Z").Ticks);
 135                         AssertEquals (632001618000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.000Z").Ticks);
 136                         AssertEquals (632001618000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.0000Z").Ticks);
 137                         AssertEquals (632001618000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.00000Z").Ticks);
 138                         AssertEquals (632001618000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.000000Z").Ticks);
 139                         AssertEquals (632001618000000000L, XmlConvert.ToDateTime ("2003-09-26T13:30:00.0000000Z").Ticks);
 140                         */
 141                         //time
 142                         DateTime t1 = new DateTime (DateTime.Today.Year, 1, 1);
 143                         t1 = DateTime.Today + new TimeSpan (12,0,0);
 144                         AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00").Ticks);
 145                         AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.0").Ticks);
 146                         AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.00").Ticks);
 147                         AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.000").Ticks);
 148                         AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.0000").Ticks);
 149                         AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.00000").Ticks);
 150                         AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.000000").Ticks);
 151                         AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.0000000").Ticks);
 152                         //AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00+13:00").Ticks);//doesn't work on .NET
 153                         //AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.f+13:00").Ticks);//doesn't work on .NET
 154                         //AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.ff+13:00").Ticks);//doesn't work on .NET
 155                         //AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.fff+13:00").Ticks);//doesn't work on .NET
 156                         //AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.ffff+13:00").Ticks);//doesn't work on .NET
 157                         //AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.fffff+13:00").Ticks);//doesn't work on .NET
 158                         //AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.ffffff+13:00").Ticks);//doesn't work on .NET
 159                         //AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.fffffff+13:00").Ticks);//doesn't work on .NET
 160                         //AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00Z").Ticks);//doesn't work on .NET
 161                         //AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.fZ").Ticks);//doesn't work on .NET
 162                         //AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.ffZ").Ticks);//doesn't work on .NET
 163                         //AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.fffZ").Ticks);//doesn't work on .NET
 164                         //AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.ffffZ").Ticks);//doesn't work on .NET
 165                         //AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.fffffZ").Ticks);//doesn't work on .NET
 166                         //AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.ffffffZ").Ticks);//doesn't work on .NET
 167                         //AssertEquals (t1.Ticks, XmlConvert.ToDateTime ("12:00:00.fffffffZ").Ticks);//doesn't work on .NET
 168                         //date
 169                         AssertEquals (632001312000000000L, XmlConvert.ToDateTime ("2003-09-26").Ticks);
 170 //                      AssertEquals (632000664000000000L, XmlConvert.ToDateTime ("2003-09-26+13:00").Ticks);
 171 //                      AssertEquals (632001132000000000L, XmlConvert.ToDateTime ("2003-09-26Z").Ticks);
 172                         //gYearMonth
 173                         AssertEquals (631979712000000000L, XmlConvert.ToDateTime ("2003-09").Ticks);
 174 //                      AssertEquals (631979064000000000L, XmlConvert.ToDateTime ("2003-09+13:00").Ticks);
 175 //                      AssertEquals (631979532000000000L, XmlConvert.ToDateTime ("2003-09Z").Ticks);
 176                         //gYear
 177                         AssertEquals (631769760000000000L, XmlConvert.ToDateTime ("2003").Ticks);
 178 //                      AssertEquals (631769076000000000L, XmlConvert.ToDateTime ("2003+13:00").Ticks);
 179 //                      AssertEquals (631769544000000000L, XmlConvert.ToDateTime ("2003Z").Ticks);
 180                         //gMonthDay
 181 // Don't try locale-dependent test
 182 //                      AssertEquals (632001312000000000L, XmlConvert.ToDateTime ("--09-26").Ticks);//shouldn't have a hardcoded value
 183 //                      AssertEquals (632000664000000000L, XmlConvert.ToDateTime ("--09-26+13:00").Ticks);//shouldn't have a hardcoded value
 184 //                      AssertEquals (632001132000000000L, XmlConvert.ToDateTime ("--09-26Z").Ticks);//shouldn't have a hardcoded value
 185                         //gDay
 186 // Don't try locale-dependent test
 187 //                      AssertEquals (631791360000000000L, XmlConvert.ToDateTime ("---26").Ticks);//shouldn't have a hardcoded value
 188 //                      AssertEquals (631790676000000000L, XmlConvert.ToDateTime ("---26+13:00").Ticks);//shouldn't have a hardcoded value
 189 //                      AssertEquals (631791144000000000L, XmlConvert.ToDateTime ("---26Z").Ticks);//shouldn't have a hardcoded value
 190                         try
 191                         {
 192                                 AssertEquals (45L, XmlConvert.ToDateTime (";ljdfas;kl").Ticks);
 193                         }
 194                         catch (Exception)
 195                         {
 196                         }
 197                 }
 198
 199                 [Test]
 200                 public void ToDecimal ()
 201                 {
 202                         AssertEquals (1.987, XmlConvert.ToDecimal ("1.987"));
 203                 }
 204
 205                 [Test]
 206                 public void ToDouble ()
 207                 {
 208                         AssertEquals (1.0d/0.0d, XmlConvert.ToDouble ("INF"));
 209                         AssertEquals (-1.0d/0.0d, XmlConvert.ToDouble ("-INF"));
 210                         AssertEquals (0.0d/0.0d, XmlConvert.ToDouble ("NaN"));
 211                         AssertEquals (789324, XmlConvert.ToDouble ("789324"));
 212                 }
 213
 214                 [Test]
 215                 public void ToDoubleRoundtrip ()
 216                 {
 217                         // bug #320424
 218                         string s = XmlConvert.ToString (double.MaxValue);
 219                         AssertEquals (double.MaxValue, XmlConvert.ToDouble (s));
 220                 }
 221
 222                 [Test]
 223                 public void ToGuid ()
 224                 {
 225                         AssertEquals (new Guid ("ca761232-ed42-11ce-bacd-00aa0057b223"), XmlConvert.ToGuid ("ca761232-ed42-11ce-bacd-00aa0057b223"));
 226                 }
 227
 228                 [Test]
 229                 public void ToInt16 ()
 230                 {
 231                         AssertType.AreEqual (0, XmlConvert.ToInt16 ("0"), "0");
 232                         AssertType.AreEqual (-1, XmlConvert.ToInt16 ("-1"), "-1");
 233                         AssertType.AreEqual (1, XmlConvert.ToInt16 ("1"), "1");
 234                         AssertType.AreEqual (32767, XmlConvert.ToInt16 ("32767"), "32767");
 235                         AssertType.AreEqual (-32768, XmlConvert.ToInt16 ("-32768"), "-32768");
 236                         try {
 237                                 XmlConvert.ToInt16 ("32768");
 238                                 AssertType.Fail ("32768");
 239                         } catch (OverflowException) {
 240                         }
 241                         try {
 242                                 XmlConvert.ToInt16 ("-32769");
 243                                 AssertType.Fail ("-32769");
 244                         } catch (OverflowException) {
 245                         }
 246                         try {
 247                                 XmlConvert.ToInt16 ("0x100");
 248                                 AssertType.Fail ("0x100");
 249                         } catch (FormatException) {
 250                         }
 251                 }
 252
 253                 [Test]
 254                 public void ToInt32 ()
 255                 {
 256                         AssertType.AreEqual (0, XmlConvert.ToInt32 ("0"), "0");
 257                         AssertType.AreEqual (-1, XmlConvert.ToInt32 ("-1"), "-1");
 258                         AssertType.AreEqual (1, XmlConvert.ToInt32 ("1"), "1");
 259                         AssertType.AreEqual (int.MaxValue, XmlConvert.ToInt32 ("2147483647"), "2147483647");
 260                         AssertType.AreEqual (int.MinValue, XmlConvert.ToInt32 ("-2147483648"), "-2147483648");
 261                         try {
 262                                 int.Parse ("2147483648", CultureInfo.CurrentCulture);
 263                                 AssertType.Fail ("int.Parse(current culture)");
 264                         } catch (OverflowException) {
 265                         }
 266                         try {
 267                                 int.Parse ("2147483648", CultureInfo.InvariantCulture);
 268                                 AssertType.Fail ("int.Parse(invariant culture)");
 269                         } catch (OverflowException) {
 270                         }
 271                         try {
 272                                 XmlConvert.ToInt32 ("2147483648");
 273                                 AssertType.Fail ("2147483648");
 274                         } catch (OverflowException) {
 275                         }
 276                         try {
 277                                 XmlConvert.ToInt32 ("-2147483649");
 278                                 AssertType.Fail ("-2147483649");
 279                         } catch (OverflowException) {
 280                         }
 281                         try {
 282                                 XmlConvert.ToInt32 ("0x10000");
 283                                 AssertType.Fail ("0x10000");
 284                         } catch (FormatException) {
 285                         }
 286                 }
 287
 288                 [Test]
 289                 public void ToInt64 ()
 290                 {
 291                         AssertType.AreEqual (0, XmlConvert.ToInt64 ("0"), "0");
 292                         AssertType.AreEqual (-1, XmlConvert.ToInt64 ("-1"), "-1");
 293                         AssertType.AreEqual (1, XmlConvert.ToInt64 ("1"), "1");
 294                         AssertType.AreEqual (long.MaxValue, XmlConvert.ToInt64 ("9223372036854775807"), "9223372036854775807");
 295                         AssertType.AreEqual (long.MinValue, XmlConvert.ToInt64 ("-9223372036854775808"), "-9223372036854775808");
 296                         try {
 297                                 XmlConvert.ToInt64 ("9223372036854775808");
 298                                 AssertType.Fail ("9223372036854775808");
 299                         } catch (OverflowException) {
 300                         }
 301                         try {
 302                                 XmlConvert.ToInt64 ("-9223372036854775809");
 303                                 AssertType.Fail ("-9223372036854775809");
 304                         } catch (OverflowException) {
 305                         }
 306                         try {
 307                                 XmlConvert.ToInt64 ("0x10000");
 308                                 AssertType.Fail ("0x10000");
 309                         } catch (FormatException) {
 310                         }
 311                 }
 312
 313                 [Test]
 314                 public void ToSByte ()
 315                 {
 316                         AssertType.AreEqual (0, XmlConvert.ToSByte ("0"), "0");
 317                         AssertType.AreEqual (-1, XmlConvert.ToSByte ("-1"), "-1");
 318                         AssertType.AreEqual (1, XmlConvert.ToSByte ("1"), "1");
 319                         AssertType.AreEqual (127, XmlConvert.ToSByte ("127"), "127");
 320                         AssertType.AreEqual (-128, XmlConvert.ToSByte ("-128"), "-128");
 321                         try {
 322                                 XmlConvert.ToSByte ("128");
 323                                 AssertType.Fail ("128");
 324                         } catch (OverflowException) {
 325                         }
 326                         try {
 327                                 XmlConvert.ToSByte ("-129");
 328                                 AssertType.Fail ("-129");
 329                         } catch (OverflowException) {
 330                         }
 331                         try {
 332                                 XmlConvert.ToSByte ("0x80");
 333                                 AssertType.Fail ("0x80");
 334                         } catch (FormatException) {
 335                         }
 336                 }
 337
 338                 [Test]
 339                 public void ToSingle ()//not done
 340                 {
 341
 342                 }
 343
 344                 [Test]
 345                 public void ToStringTest ()//not done
 346                 {
 347                         // Don't include TimeZone value for test value.
 348                         string dateString =
 349                                 XmlConvert.ToString (new DateTime (2003, 5, 5));
 350                         AssertEquals (33, dateString.Length);
 351                         AssertEquals ("2003-05-05T00:00:00.0000000", dateString.Substring (0, 27));
 352                 }
 353
 354                 [Test]
 355                 public void FromTimeSpan ()
 356                 {
 357                         // bug #77252
 358                         TimeSpan t1 = TimeSpan.FromTicks (
 359                                 TimeSpan.TicksPerSecond + 1);
 360                         AssertEquals ("PT1.0000001S", XmlConvert.ToString (t1));
 361                 }
 362
 363                 [Test]
 364                 public void ToTimeSpan ()
 365                 {
 366                         AssertEquals ("#1", new TimeSpan (0, 0, 0, 0, 1),
 367                                 XmlConvert.ToTimeSpan ("PT0.001S"));
 368                         // bug #76328
 369                         AssertEquals ("#2", new TimeSpan (0, 0, 0, 0, 100),
 370                                 XmlConvert.ToTimeSpan ("PT0.1S"));
 371                         AssertEquals ("#3", new TimeSpan (0, 0, 0, 0, 100),
 372                                 XmlConvert.ToTimeSpan ("PT0.100S"));
 373                         AssertEquals ("#4", new TimeSpan (0, 0, 0, 0, 10),
 374                                 XmlConvert.ToTimeSpan ("PT0.010S"));
 375                         AssertEquals ("#5", new TimeSpan (0, 0, 0, 0, 10),
 376                                 XmlConvert.ToTimeSpan ("PT0.01S"));
 377
 378                         // bug #77252
 379                         AssertEquals ("#6",
 380                                 TimeSpan.FromTicks (TimeSpan.TicksPerSecond + 1),
 381                                 XmlConvert.ToTimeSpan ("PT1.0000001S"));
 382
 383                         AssertEquals ("#7",
 384                                 TimeSpan.MinValue,
 385                                 XmlConvert.ToTimeSpan ("-P10675199DT2H48M5.4775808S"));
 386
 387                         AssertEquals ("#8",
 388                                 TimeSpan.MaxValue,
 389                                 XmlConvert.ToTimeSpan ("P10675199DT2H48M5.4775807S"));
 390                 }
 391
 392                 [Test]
 393                 public void ToUInt16 ()
 394                 {
 395                         AssertType.AreEqual (0, XmlConvert.ToUInt16 ("0"), "0");
 396                         AssertType.AreEqual (1, XmlConvert.ToUInt16 ("1"), "1");
 397                         AssertType.AreEqual (ushort.MaxValue, XmlConvert.ToUInt16 ("65535"), "65535");
 398                         try {
 399                                 ushort.Parse ("65536", CultureInfo.CurrentCulture);
 400                                 AssertType.Fail ("ushort.Parse(current culture)");
 401                         } catch (OverflowException) {
 402                         }
 403                         try {
 404                                 ushort.Parse ("65536", CultureInfo.InvariantCulture);
 405                                 AssertType.Fail ("ushort.Parse(invariant culture)");
 406                         } catch (OverflowException) {
 407                         }
 408                         try {
 409                                 XmlConvert.ToUInt16 ("65536");
 410                                 AssertType.Fail ("65536");
 411                         } catch (OverflowException) {
 412                         }
 413                         try {
 414                                 XmlConvert.ToUInt16 ("0x10000");
 415                                 AssertType.Fail ("0x10000");
 416                         } catch (FormatException) {
 417                         }
 418                 }
 419
 420                 [Test]
 421                 public void ToUInt32 ()
 422                 {
 423                         AssertType.AreEqual (0, XmlConvert.ToUInt32 ("0"), "0");
 424                         AssertType.AreEqual (1, XmlConvert.ToUInt32 ("1"), "1");
 425                         AssertType.AreEqual (uint.MaxValue, XmlConvert.ToUInt32 ("4294967295"), "4294967295");
 426                         try {
 427                                 uint.Parse ("4294967296", CultureInfo.CurrentCulture);
 428                                 AssertType.Fail ("uint.Parse(current culture)");
 429                         } catch (OverflowException) {
 430                         }
 431                         try {
 432                                 uint.Parse ("4294967296", CultureInfo.InvariantCulture);
 433                                 AssertType.Fail ("uint.Parse(invariant culture)");
 434                         } catch (OverflowException) {
 435                         }
 436                         try {
 437                                 XmlConvert.ToUInt32 ("4294967296");
 438                                 AssertType.Fail ("4294967296");
 439                         } catch (OverflowException) {
 440                         }
 441                         try {
 442                                 XmlConvert.ToUInt32 ("0x10000");
 443                                 AssertType.Fail ("0x10000");
 444                         } catch (FormatException) {
 445                         }
 446                 }
 447
 448                 [Test]
 449                 public void ToUInt64 ()
 450                 {
 451                         AssertType.AreEqual (0, XmlConvert.ToUInt64 ("0"), "0");
 452                         AssertType.AreEqual (1, XmlConvert.ToUInt64 ("1"), "1");
 453                         AssertType.AreEqual (ulong.MaxValue, XmlConvert.ToUInt64 ("18446744073709551615"), "18446744073709551615");
 454                         try {
 455                                 ulong.Parse ("18446744073709551616", CultureInfo.CurrentCulture);
 456                                 AssertType.Fail ("ulong.Parse(current culture)");
 457                         } catch (OverflowException) {
 458                         }
 459                         try {
 460                                 ulong.Parse ("18446744073709551616", CultureInfo.InvariantCulture);
 461                                 AssertType.Fail ("ulong.Parse(invariant culture)");
 462                         } catch (OverflowException) {
 463                         }
 464                         try {
 465                                 XmlConvert.ToUInt64 ("18446744073709551616");
 466                                 AssertType.Fail ("18446744073709551616");
 467                         } catch (OverflowException) {
 468                         }
 469                         try {
 470                                 XmlConvert.ToUInt64 ("0x10000");
 471                                 AssertType.Fail ("0x10000");
 472                         } catch (FormatException) {
 473                         }
 474                 }
 475
 476                 [Test]
 477                 public void VerifyName ()
 478                 {
 479                         VerifyNameValid ("a");
 480                         VerifyNameValid ("a1");
 481                         VerifyNameValid ("\u3041");
 482                         VerifyNameValid ("a:b");
 483                         VerifyNameValid ("_");
 484                         VerifyNameValid ("__");
 485                         VerifyNameValid ("_1");
 486                         VerifyNameValid (":");
 487                         VerifyNameValid (":a");
 488                         VerifyNameValid ("a.b");
 489                 }
 490
 491                 [Test]
 492                 public void VerifyNameInvalid ()
 493                 {
 494                         VerifyNameInvalid ("!");
 495                         VerifyNameInvalid ("_a!b");
 496                         VerifyNameInvalid ("?a");
 497                         VerifyNameInvalid (" ");
 498                 }
 499
 500                 [Test]
 501                 [ExpectedException (typeof (ArgumentNullException))]
 502                 public void VerifyNameNull ()
 503                 {
 504                         XmlConvert.VerifyName (null);
 505                 }
 506
 507                 [Test]
 508                 [ExpectedException (typeof (ArgumentNullException))]
 509                 public void VerifyNameEmpty ()
 510                 {
 511                         XmlConvert.VerifyName ("");
 512                 }
 513
 514                 private void VerifyNameValid (string value)
 515                 {
 516                         try {
 517                                 XmlConvert.VerifyName (value);
 518                         } catch (XmlException) {
 519                                 AssertType.Fail (String.Format ("'{0}'", value));
 520                         }
 521                 }
 522
 523                 private void VerifyNameInvalid (string value)
 524                 {
 525                         try {
 526                                 XmlConvert.VerifyName (value);
 527                                 AssertType.Fail (value);
 528                         } catch (XmlException) {
 529                         }
 530                 }
 531
 532                 [Test]
 533                 public void VerifyNCName ()
 534                 {
 535                         AssertEquals ("foo", XmlConvert.VerifyNCName ("foo"));
 536                         try {
 537                                 XmlConvert.VerifyNCName ("?foo");
 538                                 Fail ();
 539                         } catch (XmlException) {}
 540                         try {
 541                                 XmlConvert.VerifyNCName (":foo");
 542                                 Fail ();
 543                         } catch (XmlException) {}
 544                         try {
 545                                 XmlConvert.VerifyNCName ("foo:bar");
 546                                 Fail ();
 547                         } catch (XmlException) {}
 548                         try {
 549                                 XmlConvert.VerifyNCName ("foo:bar:baz");
 550                                 Fail ();
 551                         } catch (XmlException) {}
 552                 }
 553
 554                 [Test]
 555                 [ExpectedException (typeof (ArgumentNullException))]
 556                 public void VerifyNCNameNull ()
 557                 {
 558                         XmlConvert.VerifyNCName (null);
 559                 }
 560
 561                 [Test]
 562                 [ExpectedException (typeof (ArgumentNullException))]
 563                 public void VerifyNCNameEmpty ()
 564                 {
 565                         XmlConvert.VerifyNCName ("");
 566                 }
 567
 568                 [Test]
 569                 public void DurationZero () // bug #77350
 570                 {
 571                         AssertEquals ("PT0S", XmlConvert.ToString (TimeSpan.FromSeconds (0)));
 572                 }
 573
 574 #if NET_2_0
 575                 [Test]
 576                 public void VerifyTOKEN ()
 577                 {
 578                         VerifyToken ("", true);
 579                         VerifyToken (" ", false);
 580                         VerifyToken ("A", true);
 581                         VerifyToken ("!", true);
 582                         VerifyToken (" !", false);
 583                         VerifyToken ("! ", false);
 584                         VerifyToken ("! !", true);
 585                         VerifyToken ("!\t!", false);
 586                         VerifyToken ("!\n!", false);
 587                         VerifyToken ("!\r!", false);
 588                         VerifyToken ("###", true);
 589                 }
 590
 591                 private void VerifyToken (string s, bool success)
 592                 {
 593                         try {
 594                                 XmlConvert.VerifyTOKEN (s);
 595                                 if (success)
 596                                         return;
 597                                 AssertType.Fail (s + "should fail");
 598                         } catch (XmlException ex) {
 599                                 if (success)
 600                                         AssertType.Fail (s + "should not fail");
 601                         }
 602                 }
 603
 604                 [Test]
 605                 public void XmlDateTimeSerializationModeAndMaxValue ()
 606                 {
 607                         AssertEquals ("#1", "9999-12-31T23:59:59.9999999", XmlConvert.ToString (DateTime.MaxValue, XmlDateTimeSerializationMode.Unspecified).Substring (0, 27));
 608                         AssertEquals ("#2", "9999-12-31T23:59:59.9999999Z", XmlConvert.ToString (DateTime.MaxValue, XmlDateTimeSerializationMode.Utc));
 609                         AssertEquals ("#3", "9999-12-31T23:59:59.9999999", XmlConvert.ToString (DateTime.MaxValue, XmlDateTimeSerializationMode.RoundtripKind));
 610                         AssertEquals ("#4", "9999-12-31T23:59:59.9999999", XmlConvert.ToString (DateTime.MaxValue, XmlDateTimeSerializationMode.Local).Substring (0, 27));
 611                         // direct formatting string - no difference
 612                         AssertEquals ("#5", "9999-12-31T23:59:59.9999999Z", XmlConvert.ToString (DateTime.MaxValue, "yyyy-MM-ddTHH:mm:ss.FFFFFFFZ"));
 613                         AssertEquals ("#6", "9999-12-31T23:59:59.9999999", XmlConvert.ToString (DateTime.MaxValue, "yyyy-MM-ddTHH:mm:ss.FFFFFFFzzz").Substring (0, 27));
 614                 }
 615
 616                 [Test]
 617                 public void XmlDateTimeSerializationModeRountripKind ()
 618                 {
 619                         string format = "yyyy-MM-ddTHH:mm:ss.FFFFFFFK";
 620                         string s = XmlConvert.ToString (DateTime.UtcNow, format);
 621                         AssertType.AreEqual ('Z', s [s.Length -1], "#1-1");
 622                         // LAMESPEC: .NET has a bug here that 'K' in format string does not reflect 'Z' as Utc Kind.
 623                         // https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=307694
 624                         //AssertType.AreEqual (DateTimeKind.Utc, XmlConvert.ToDateTime (s, format).Kind, "#1-2");
 625
 626                         s = XmlConvert.ToString (DateTime.UtcNow, XmlDateTimeSerializationMode.RoundtripKind);
 627                         AssertType.AreEqual ('Z', s [s.Length -1], "#2-1");
 628                         AssertType.AreEqual (DateTimeKind.Utc, XmlConvert.ToDateTime (s, XmlDateTimeSerializationMode.RoundtripKind).Kind, "#2-2");
 629                 }
 630
 631                 [Test]
 632                 public void XmlDateTimeSerializationModeUnspecified ()
 633                 {
 634                         AssertEquals ("#1", 27, XmlConvert.ToString (new DateTime (DateTime.MaxValue.Ticks, DateTimeKind.Utc), XmlDateTimeSerializationMode.Unspecified).Length);
 635                         DateTime dt1 = XmlConvert.ToDateTime ("0001-02-03T10:20:30.0000+02:00", XmlDateTimeSerializationMode.Unspecified);
 636                         DateTime dt2 = XmlConvert.ToDateTime ("0001-02-03T10:20:30.0000", XmlDateTimeSerializationMode.Unspecified);
 637                         AssertEquals ("#2", false, dt1 == dt2);
 638                         XmlConvert.ToDateTime ("2006-05-30T09:48:32.0Z", XmlDateTimeSerializationMode.Unspecified);
 639                         string format = "yyyy-MM-ddTHH:mm:ss.FFFFFFFK";
 640                         XmlConvert.ToDateTime (XmlConvert.ToString (DateTime.UtcNow, format), XmlDateTimeSerializationMode.Unspecified);
 641                 }
 642
 643                 [Test]
 644                 public void XmlDateTimeSerializationModeUtc ()
 645                 {
 646                         AssertEquals ("#1", 27, XmlConvert.ToString (new DateTime (DateTime.MaxValue.Ticks, DateTimeKind.Utc), XmlDateTimeSerializationMode.Unspecified).Length);
 647                         DateTime dt1 = XmlConvert.ToDateTime ("0001-02-03T10:20:30.0000+02:00", XmlDateTimeSerializationMode.Utc);
 648                         DateTime dt2 = XmlConvert.ToDateTime ("0001-02-03T10:20:30.0000", XmlDateTimeSerializationMode.Utc);
 649                         AssertEquals ("#2", false, dt1 == dt2);
 650                         XmlConvert.ToDateTime ("2006-05-30T09:48:32.0Z", XmlDateTimeSerializationMode.Utc);
 651                         XmlConvert.ToDateTime ("2006-05-30T09:48:32.0+02:00", XmlDateTimeSerializationMode.Utc);
 652                         XmlConvert.ToDateTime ("2008-06-11T11:09:47.125Z", XmlDateTimeSerializationMode.Utc);
 653                 }
 654
 655                 [Test]
 656                 public void XmlDateTimeSerializationModeSeveralFormats ()
 657                 {
 658                         XmlDateTimeSerializationMode m = XmlDateTimeSerializationMode.RoundtripKind;
 659                         XmlConvert.ToDateTime ("0001", m);
 660                         XmlConvert.ToDateTime ("0001Z", m);
 661                         XmlConvert.ToDateTime ("0001+09:00", m);
 662                         XmlConvert.ToDateTime ("0001-02", m);
 663                         XmlConvert.ToDateTime ("0001-02Z", m);
 664                         XmlConvert.ToDateTime ("0001-02+09:00", m);
 665                         XmlConvert.ToDateTime ("0001-02-03", m);
 666                         XmlConvert.ToDateTime ("0001-02-03Z", m);
 667                         XmlConvert.ToDateTime ("0001-02-03+09:00", m);
 668                         XmlConvert.ToDateTime ("--02-03", m);
 669                         XmlConvert.ToDateTime ("--02-03Z", m);
 670                         XmlConvert.ToDateTime ("--02-03+09:00", m);
 671                         XmlConvert.ToDateTime ("---03", m);
 672                         XmlConvert.ToDateTime ("---03Z", m);
 673                         XmlConvert.ToDateTime ("---03+09:00", m);
 674                         XmlConvert.ToDateTime ("10:20:30", m);
 675                         XmlConvert.ToDateTime ("10:20:30Z", m);
 676                         XmlConvert.ToDateTime ("10:20:30+09:00", m);
 677                         XmlConvert.ToDateTime ("0001-02-03T10:20:30", m);
 678                         XmlConvert.ToDateTime ("0001-02-03T10:20:30Z", m);
 679                         XmlConvert.ToDateTime ("0001-02-03T10:20:30+09:00", m);
 680                         XmlConvert.ToDateTime ("0001-02-03T10:20:30.00", m);
 681                         XmlConvert.ToDateTime ("0001-02-03T10:20:30.00Z", m);
 682                         XmlConvert.ToDateTime ("0001-02-03T10:20:30.00+09:00", m);
 683                         XmlConvert.ToDateTime ("0001-02-03T10:20:30.0000", m);
 684                         XmlConvert.ToDateTime ("0001-02-03T10:20:30.0000Z", m);
 685                         XmlConvert.ToDateTime ("0001-02-03T10:20:30.0000+09:00", m);
 686
 687                         try {
 688                                 XmlConvert.ToDateTime ("0001-02-03T", m);
 689                                 AssertType.Fail ("#1");
 690                         } catch (FormatException) {
 691                         }
 692                         try {
 693                                 XmlConvert.ToDateTime ("0001-02-03T10:20", m);
 694                                 AssertType.Fail ("#2");
 695                         } catch (FormatException) {
 696                         }
 697                         try {
 698                                 XmlConvert.ToDateTime ("0001-02-03T10:20:30.", m);
 699                                 AssertType.Fail ("#3");
 700                         } catch (FormatException) {
 701                         }
 702                 }
 703 #endif
 704         }
 705 }
 706