2 // System.Xml.XmlConvertTests.cs
4 // Authors: Atsushi Enomoto (ginga@kit.hi-ho.ne.jp), Jon Kessler (jwkpiano1@comcast.net)
6 // (C) 2003 Atsushi Enomoto, Jon Kessler
10 using System.Globalization;
12 using NUnit.Framework;
14 using AssertType = NUnit.Framework.Assert;
16 namespace MonoTests.System.Xml
19 public class XmlConvertTests : Assertion
21 private void AssertName (string result, string source)
24 XmlConvert.EncodeName (source));
27 private void AssertNmToken (string result, string source)
30 XmlConvert.EncodeNmToken (source));
34 public void DecodeName ()
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_"));
46 public void EncodeLocalName ()
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"));
55 public void EncodeName ()
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");
66 public void EncodeNmToken ()
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");
76 [ExpectedException (typeof (XmlException))]
77 public void EncodeNmTokenError ()
79 XmlConvert.EncodeNmToken (String.Empty);
83 public void ToBoolean ()
85 AssertEquals (true, XmlConvert.ToBoolean (" 1 "));
86 AssertEquals (true, XmlConvert.ToBoolean (" true "));
87 AssertEquals (false, XmlConvert.ToBoolean (" 0 "));
88 AssertEquals (false, XmlConvert.ToBoolean (" false "));
91 AssertEquals (false, XmlConvert.ToBoolean (" invalid "));
93 catch (FormatException)
101 AssertEquals (255, XmlConvert.ToByte ("255"));
105 public void ToChar ()
107 AssertEquals ('x', XmlConvert.ToChar ("x"));
111 public void ToDateTime ()//fails on Mono
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);
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);
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
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);
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);
177 AssertEquals (631769760000000000L, XmlConvert.ToDateTime ("2003").Ticks);
178 // AssertEquals (631769076000000000L, XmlConvert.ToDateTime ("2003+13:00").Ticks);
179 // AssertEquals (631769544000000000L, XmlConvert.ToDateTime ("2003Z").Ticks);
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
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
192 AssertEquals (45L, XmlConvert.ToDateTime (";ljdfas;kl").Ticks);
200 public void ToDecimal ()
202 AssertEquals (1.987, XmlConvert.ToDecimal ("1.987"));
206 public void ToDouble ()
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"));
215 public void ToGuid ()
217 AssertEquals (new Guid ("ca761232-ed42-11ce-bacd-00aa0057b223"), XmlConvert.ToGuid ("ca761232-ed42-11ce-bacd-00aa0057b223"));
221 public void ToInt16 ()
223 AssertType.AreEqual (0, XmlConvert.ToInt16 ("0"), "0");
224 AssertType.AreEqual (-1, XmlConvert.ToInt16 ("-1"), "-1");
225 AssertType.AreEqual (1, XmlConvert.ToInt16 ("1"), "1");
226 AssertType.AreEqual (32767, XmlConvert.ToInt16 ("32767"), "32767");
227 AssertType.AreEqual (-32768, XmlConvert.ToInt16 ("-32768"), "-32768");
229 XmlConvert.ToInt16 ("32768");
230 AssertType.Fail ("32768");
231 } catch (OverflowException) {
234 XmlConvert.ToInt16 ("-32769");
235 AssertType.Fail ("-32769");
236 } catch (OverflowException) {
239 XmlConvert.ToInt16 ("0x100");
240 AssertType.Fail ("0x100");
241 } catch (FormatException) {
246 public void ToInt32 ()
248 AssertType.AreEqual (0, XmlConvert.ToInt32 ("0"), "0");
249 AssertType.AreEqual (-1, XmlConvert.ToInt32 ("-1"), "-1");
250 AssertType.AreEqual (1, XmlConvert.ToInt32 ("1"), "1");
251 AssertType.AreEqual (int.MaxValue, XmlConvert.ToInt32 ("2147483647"), "2147483647");
252 AssertType.AreEqual (int.MinValue, XmlConvert.ToInt32 ("-2147483648"), "-2147483648");
254 int.Parse ("2147483648", CultureInfo.CurrentCulture);
255 AssertType.Fail ("int.Parse(current culture)");
256 } catch (OverflowException) {
259 int.Parse ("2147483648", CultureInfo.InvariantCulture);
260 AssertType.Fail ("int.Parse(invariant culture)");
261 } catch (OverflowException) {
264 XmlConvert.ToInt32 ("2147483648");
265 AssertType.Fail ("2147483648");
266 } catch (OverflowException) {
269 XmlConvert.ToInt32 ("-2147483649");
270 AssertType.Fail ("-2147483649");
271 } catch (OverflowException) {
274 XmlConvert.ToInt32 ("0x10000");
275 AssertType.Fail ("0x10000");
276 } catch (FormatException) {
281 public void ToInt64 ()
283 AssertType.AreEqual (0, XmlConvert.ToInt64 ("0"), "0");
284 AssertType.AreEqual (-1, XmlConvert.ToInt64 ("-1"), "-1");
285 AssertType.AreEqual (1, XmlConvert.ToInt64 ("1"), "1");
286 AssertType.AreEqual (long.MaxValue, XmlConvert.ToInt64 ("9223372036854775807"), "9223372036854775807");
287 AssertType.AreEqual (long.MinValue, XmlConvert.ToInt64 ("-9223372036854775808"), "-9223372036854775808");
289 XmlConvert.ToInt64 ("9223372036854775808");
290 AssertType.Fail ("9223372036854775808");
291 } catch (OverflowException) {
294 XmlConvert.ToInt64 ("-9223372036854775809");
295 AssertType.Fail ("-9223372036854775809");
296 } catch (OverflowException) {
299 XmlConvert.ToInt64 ("0x10000");
300 AssertType.Fail ("0x10000");
301 } catch (FormatException) {
306 public void ToSByte ()
308 AssertType.AreEqual (0, XmlConvert.ToSByte ("0"), "0");
309 AssertType.AreEqual (-1, XmlConvert.ToSByte ("-1"), "-1");
310 AssertType.AreEqual (1, XmlConvert.ToSByte ("1"), "1");
311 AssertType.AreEqual (127, XmlConvert.ToSByte ("127"), "127");
312 AssertType.AreEqual (-128, XmlConvert.ToSByte ("-128"), "-128");
314 XmlConvert.ToSByte ("128");
315 AssertType.Fail ("128");
316 } catch (OverflowException) {
319 XmlConvert.ToSByte ("-129");
320 AssertType.Fail ("-129");
321 } catch (OverflowException) {
324 XmlConvert.ToSByte ("0x80");
325 AssertType.Fail ("0x80");
326 } catch (FormatException) {
331 public void ToSingle ()//not done
337 public void ToStringTest ()//not done
339 // Don't include TimeZone value for test value.
341 XmlConvert.ToString (new DateTime (2003, 5, 5));
342 AssertEquals (33, dateString.Length);
343 AssertEquals ("2003-05-05T00:00:00.0000000", dateString.Substring (0, 27));
347 public void FromTimeSpan ()
350 TimeSpan t1 = TimeSpan.FromTicks (
351 TimeSpan.TicksPerSecond + 1);
352 AssertEquals ("PT1.0000001S", XmlConvert.ToString (t1));
356 public void ToTimeSpan ()//not done
358 AssertEquals ("#1", new TimeSpan (0, 0, 0, 0, 1),
359 XmlConvert.ToTimeSpan ("PT0.001S"));
361 AssertEquals ("#2", new TimeSpan (0, 0, 0, 0, 100),
362 XmlConvert.ToTimeSpan ("PT0.1S"));
363 AssertEquals ("#3", new TimeSpan (0, 0, 0, 0, 100),
364 XmlConvert.ToTimeSpan ("PT0.100S"));
365 AssertEquals ("#4", new TimeSpan (0, 0, 0, 0, 10),
366 XmlConvert.ToTimeSpan ("PT0.010S"));
367 AssertEquals ("#5", new TimeSpan (0, 0, 0, 0, 10),
368 XmlConvert.ToTimeSpan ("PT0.01S"));
372 TimeSpan.FromTicks (TimeSpan.TicksPerSecond + 1),
373 XmlConvert.ToTimeSpan ("PT1.0000001S"));
377 public void ToUInt16 ()
379 AssertType.AreEqual (0, XmlConvert.ToUInt16 ("0"), "0");
380 AssertType.AreEqual (1, XmlConvert.ToUInt16 ("1"), "1");
381 AssertType.AreEqual (ushort.MaxValue, XmlConvert.ToUInt16 ("65535"), "65535");
383 ushort.Parse ("65536", CultureInfo.CurrentCulture);
384 AssertType.Fail ("ushort.Parse(current culture)");
385 } catch (OverflowException) {
388 ushort.Parse ("65536", CultureInfo.InvariantCulture);
389 AssertType.Fail ("ushort.Parse(invariant culture)");
390 } catch (OverflowException) {
393 XmlConvert.ToUInt16 ("65536");
394 AssertType.Fail ("65536");
395 } catch (OverflowException) {
398 XmlConvert.ToUInt16 ("0x10000");
399 AssertType.Fail ("0x10000");
400 } catch (FormatException) {
405 public void ToUInt32 ()
407 AssertType.AreEqual (0, XmlConvert.ToUInt32 ("0"), "0");
408 AssertType.AreEqual (1, XmlConvert.ToUInt32 ("1"), "1");
409 AssertType.AreEqual (uint.MaxValue, XmlConvert.ToUInt32 ("4294967295"), "4294967295");
411 uint.Parse ("4294967296", CultureInfo.CurrentCulture);
412 AssertType.Fail ("uint.Parse(current culture)");
413 } catch (OverflowException) {
416 uint.Parse ("4294967296", CultureInfo.InvariantCulture);
417 AssertType.Fail ("uint.Parse(invariant culture)");
418 } catch (OverflowException) {
421 XmlConvert.ToUInt32 ("4294967296");
422 AssertType.Fail ("4294967296");
423 } catch (OverflowException) {
426 XmlConvert.ToUInt32 ("0x10000");
427 AssertType.Fail ("0x10000");
428 } catch (FormatException) {
433 public void ToUInt64 ()
435 AssertType.AreEqual (0, XmlConvert.ToUInt64 ("0"), "0");
436 AssertType.AreEqual (1, XmlConvert.ToUInt64 ("1"), "1");
437 AssertType.AreEqual (ulong.MaxValue, XmlConvert.ToUInt64 ("18446744073709551615"), "18446744073709551615");
439 ulong.Parse ("18446744073709551616", CultureInfo.CurrentCulture);
440 AssertType.Fail ("ulong.Parse(current culture)");
441 } catch (OverflowException) {
444 ulong.Parse ("18446744073709551616", CultureInfo.InvariantCulture);
445 AssertType.Fail ("ulong.Parse(invariant culture)");
446 } catch (OverflowException) {
449 XmlConvert.ToUInt64 ("18446744073709551616");
450 AssertType.Fail ("18446744073709551616");
451 } catch (OverflowException) {
454 XmlConvert.ToUInt64 ("0x10000");
455 AssertType.Fail ("0x10000");
456 } catch (FormatException) {
461 public void VerifyName ()
463 VerifyNameValid ("a");
464 VerifyNameValid ("a1");
465 VerifyNameValid ("\u3041");
466 VerifyNameValid ("a:b");
467 VerifyNameValid ("_");
468 VerifyNameValid ("__");
469 VerifyNameValid ("_1");
470 VerifyNameValid (":");
471 VerifyNameValid (":a");
472 VerifyNameValid ("a.b");
476 public void VerifyNameInvalid ()
478 VerifyNameInvalid ("!");
479 VerifyNameInvalid ("_a!b");
480 VerifyNameInvalid ("?a");
481 VerifyNameInvalid (" ");
485 [ExpectedException (typeof (ArgumentNullException))]
486 public void VerifyNameNull ()
488 XmlConvert.VerifyName (null);
492 [ExpectedException (typeof (ArgumentNullException))]
493 public void VerifyNameEmpty ()
495 XmlConvert.VerifyName ("");
498 private void VerifyNameValid (string value)
501 XmlConvert.VerifyName (value);
502 } catch (XmlException) {
503 AssertType.Fail (String.Format ("'{0}'", value));
507 private void VerifyNameInvalid (string value)
510 XmlConvert.VerifyName (value);
511 AssertType.Fail (value);
512 } catch (XmlException) {
517 public void VerifyNCName ()
519 AssertEquals ("foo", XmlConvert.VerifyNCName ("foo"));
521 XmlConvert.VerifyNCName ("?foo");
523 } catch (XmlException) {}
525 XmlConvert.VerifyNCName (":foo");
527 } catch (XmlException) {}
529 XmlConvert.VerifyNCName ("foo:bar");
531 } catch (XmlException) {}
533 XmlConvert.VerifyNCName ("foo:bar:baz");
535 } catch (XmlException) {}
539 [ExpectedException (typeof (ArgumentNullException))]
540 public void VerifyNCNameNull ()
542 XmlConvert.VerifyNCName (null);
546 [ExpectedException (typeof (ArgumentNullException))]
547 public void VerifyNCNameEmpty ()
549 XmlConvert.VerifyNCName ("");
553 public void DurationZero () // bug #77350
555 AssertEquals ("PT0S", XmlConvert.ToString (TimeSpan.FromSeconds (0)));
560 public void VerifyTOKEN ()
562 VerifyToken ("", true);
563 VerifyToken (" ", false);
564 VerifyToken ("A", true);
565 VerifyToken ("!", true);
566 VerifyToken (" !", false);
567 VerifyToken ("! ", false);
568 VerifyToken ("! !", true);
569 VerifyToken ("!\t!", false);
570 VerifyToken ("!\n!", false);
571 VerifyToken ("!\r!", false);
572 VerifyToken ("###", true);
575 private void VerifyToken (string s, bool success)
578 XmlConvert.VerifyTOKEN (s);
581 AssertType.Fail (s + "should fail");
582 } catch (XmlException ex) {
584 AssertType.Fail (s + "should not fail");