//
using System;
+using System.Globalization;
using System.Xml;
using NUnit.Framework;
+using AssertType = NUnit.Framework.Assert;
+
namespace MonoTests.System.Xml
{
[TestFixture]
}
[Test]
- public void ToInt16 ()//not done
+ public void ToInt16 ()
{
-
+ AssertType.AreEqual (0, XmlConvert.ToInt16 ("0"), "0");
+ AssertType.AreEqual (-1, XmlConvert.ToInt16 ("-1"), "-1");
+ AssertType.AreEqual (1, XmlConvert.ToInt16 ("1"), "1");
+ AssertType.AreEqual (32767, XmlConvert.ToInt16 ("32767"), "32767");
+ AssertType.AreEqual (-32768, XmlConvert.ToInt16 ("-32768"), "-32768");
+ try {
+ XmlConvert.ToInt16 ("32768");
+ AssertType.Fail ("32768");
+ } catch (OverflowException) {
+ }
+ try {
+ XmlConvert.ToInt16 ("-32769");
+ AssertType.Fail ("-32769");
+ } catch (OverflowException) {
+ }
+ try {
+ XmlConvert.ToInt16 ("0x100");
+ AssertType.Fail ("0x100");
+ } catch (FormatException) {
+ }
}
[Test]
- public void ToInt32 ()//not done
+ public void ToInt32 ()
{
-
+ AssertType.AreEqual (0, XmlConvert.ToInt32 ("0"), "0");
+ AssertType.AreEqual (-1, XmlConvert.ToInt32 ("-1"), "-1");
+ AssertType.AreEqual (1, XmlConvert.ToInt32 ("1"), "1");
+ AssertType.AreEqual (int.MaxValue, XmlConvert.ToInt32 ("2147483647"), "2147483647");
+ AssertType.AreEqual (int.MinValue, XmlConvert.ToInt32 ("-2147483648"), "-2147483648");
+ try {
+ int.Parse ("2147483648", CultureInfo.CurrentCulture);
+ AssertType.Fail ("int.Parse(current culture)");
+ } catch (OverflowException) {
+ }
+ try {
+ int.Parse ("2147483648", CultureInfo.InvariantCulture);
+ AssertType.Fail ("int.Parse(invariant culture)");
+ } catch (OverflowException) {
+ }
+ try {
+ XmlConvert.ToInt32 ("2147483648");
+ AssertType.Fail ("2147483648");
+ } catch (OverflowException) {
+ }
+ try {
+ XmlConvert.ToInt32 ("-2147483649");
+ AssertType.Fail ("-2147483649");
+ } catch (OverflowException) {
+ }
+ try {
+ XmlConvert.ToInt32 ("0x10000");
+ AssertType.Fail ("0x10000");
+ } catch (FormatException) {
+ }
}
[Test]
- public void ToInt64 ()//not done
+ public void ToInt64 ()
{
-
+ AssertType.AreEqual (0, XmlConvert.ToInt64 ("0"), "0");
+ AssertType.AreEqual (-1, XmlConvert.ToInt64 ("-1"), "-1");
+ AssertType.AreEqual (1, XmlConvert.ToInt64 ("1"), "1");
+ AssertType.AreEqual (long.MaxValue, XmlConvert.ToInt64 ("9223372036854775807"), "9223372036854775807");
+ AssertType.AreEqual (long.MinValue, XmlConvert.ToInt64 ("-9223372036854775808"), "-9223372036854775808");
+ try {
+ XmlConvert.ToInt64 ("9223372036854775808");
+ AssertType.Fail ("9223372036854775808");
+ } catch (OverflowException) {
+ }
+ try {
+ XmlConvert.ToInt64 ("-9223372036854775809");
+ AssertType.Fail ("-9223372036854775809");
+ } catch (OverflowException) {
+ }
+ try {
+ XmlConvert.ToInt64 ("0x10000");
+ AssertType.Fail ("0x10000");
+ } catch (FormatException) {
+ }
}
[Test]
- public void ToSByte ()//not done
+ public void ToSByte ()
{
+ AssertType.AreEqual (0, XmlConvert.ToSByte ("0"), "0");
+ AssertType.AreEqual (-1, XmlConvert.ToSByte ("-1"), "-1");
+ AssertType.AreEqual (1, XmlConvert.ToSByte ("1"), "1");
+ AssertType.AreEqual (127, XmlConvert.ToSByte ("127"), "127");
+ AssertType.AreEqual (-128, XmlConvert.ToSByte ("-128"), "-128");
+ try {
+ XmlConvert.ToSByte ("128");
+ AssertType.Fail ("128");
+ } catch (OverflowException) {
+ }
+ try {
+ XmlConvert.ToSByte ("-129");
+ AssertType.Fail ("-129");
+ } catch (OverflowException) {
+ }
+ try {
+ XmlConvert.ToSByte ("0x80");
+ AssertType.Fail ("0x80");
+ } catch (FormatException) {
+ }
}
[Test]
AssertEquals (33, dateString.Length);
AssertEquals ("2003-05-05T00:00:00.0000000", dateString.Substring (0, 27));
}
-
+
+ [Test]
+ public void FromTimeSpan ()
+ {
+ // bug #77252
+ TimeSpan t1 = TimeSpan.FromTicks (
+ TimeSpan.TicksPerSecond + 1);
+ AssertEquals ("PT1.0000001S", XmlConvert.ToString (t1));
+ }
+
[Test]
- public void ToTimeSpan ()//not done
+ public void ToTimeSpan ()
{
AssertEquals ("#1", new TimeSpan (0, 0, 0, 0, 1),
XmlConvert.ToTimeSpan ("PT0.001S"));
+ // bug #76328
+ AssertEquals ("#2", new TimeSpan (0, 0, 0, 0, 100),
+ XmlConvert.ToTimeSpan ("PT0.1S"));
+ AssertEquals ("#3", new TimeSpan (0, 0, 0, 0, 100),
+ XmlConvert.ToTimeSpan ("PT0.100S"));
+ AssertEquals ("#4", new TimeSpan (0, 0, 0, 0, 10),
+ XmlConvert.ToTimeSpan ("PT0.010S"));
+ AssertEquals ("#5", new TimeSpan (0, 0, 0, 0, 10),
+ XmlConvert.ToTimeSpan ("PT0.01S"));
+
+ // bug #77252
+ AssertEquals ("#6",
+ TimeSpan.FromTicks (TimeSpan.TicksPerSecond + 1),
+ XmlConvert.ToTimeSpan ("PT1.0000001S"));
+
+ AssertEquals ("#7",
+ TimeSpan.MinValue,
+ XmlConvert.ToTimeSpan ("-P10675199DT2H48M5.4775808S"));
+
+ AssertEquals ("#8",
+ TimeSpan.MaxValue,
+ XmlConvert.ToTimeSpan ("P10675199DT2H48M5.4775807S"));
}
[Test]
- public void ToUInt16 ()//not done
+ public void ToUInt16 ()
{
-
+ AssertType.AreEqual (0, XmlConvert.ToUInt16 ("0"), "0");
+ AssertType.AreEqual (1, XmlConvert.ToUInt16 ("1"), "1");
+ AssertType.AreEqual (ushort.MaxValue, XmlConvert.ToUInt16 ("65535"), "65535");
+ try {
+ ushort.Parse ("65536", CultureInfo.CurrentCulture);
+ AssertType.Fail ("ushort.Parse(current culture)");
+ } catch (OverflowException) {
+ }
+ try {
+ ushort.Parse ("65536", CultureInfo.InvariantCulture);
+ AssertType.Fail ("ushort.Parse(invariant culture)");
+ } catch (OverflowException) {
+ }
+ try {
+ XmlConvert.ToUInt16 ("65536");
+ AssertType.Fail ("65536");
+ } catch (OverflowException) {
+ }
+ try {
+ XmlConvert.ToUInt16 ("0x10000");
+ AssertType.Fail ("0x10000");
+ } catch (FormatException) {
+ }
}
[Test]
- public void ToUInt32 ()//not done
+ public void ToUInt32 ()
{
-
+ AssertType.AreEqual (0, XmlConvert.ToUInt32 ("0"), "0");
+ AssertType.AreEqual (1, XmlConvert.ToUInt32 ("1"), "1");
+ AssertType.AreEqual (uint.MaxValue, XmlConvert.ToUInt32 ("4294967295"), "4294967295");
+ try {
+ uint.Parse ("4294967296", CultureInfo.CurrentCulture);
+ AssertType.Fail ("uint.Parse(current culture)");
+ } catch (OverflowException) {
+ }
+ try {
+ uint.Parse ("4294967296", CultureInfo.InvariantCulture);
+ AssertType.Fail ("uint.Parse(invariant culture)");
+ } catch (OverflowException) {
+ }
+ try {
+ XmlConvert.ToUInt32 ("4294967296");
+ AssertType.Fail ("4294967296");
+ } catch (OverflowException) {
+ }
+ try {
+ XmlConvert.ToUInt32 ("0x10000");
+ AssertType.Fail ("0x10000");
+ } catch (FormatException) {
+ }
}
[Test]
- public void ToUInt64 ()//not done
+ public void ToUInt64 ()
{
-
+ AssertType.AreEqual (0, XmlConvert.ToUInt64 ("0"), "0");
+ AssertType.AreEqual (1, XmlConvert.ToUInt64 ("1"), "1");
+ AssertType.AreEqual (ulong.MaxValue, XmlConvert.ToUInt64 ("18446744073709551615"), "18446744073709551615");
+ try {
+ ulong.Parse ("18446744073709551616", CultureInfo.CurrentCulture);
+ AssertType.Fail ("ulong.Parse(current culture)");
+ } catch (OverflowException) {
+ }
+ try {
+ ulong.Parse ("18446744073709551616", CultureInfo.InvariantCulture);
+ AssertType.Fail ("ulong.Parse(invariant culture)");
+ } catch (OverflowException) {
+ }
+ try {
+ XmlConvert.ToUInt64 ("18446744073709551616");
+ AssertType.Fail ("18446744073709551616");
+ } catch (OverflowException) {
+ }
+ try {
+ XmlConvert.ToUInt64 ("0x10000");
+ AssertType.Fail ("0x10000");
+ } catch (FormatException) {
+ }
}
[Test]
- public void VerifyName ()//not done
+ public void VerifyName ()
{
-
+ VerifyNameValid ("a");
+ VerifyNameValid ("a1");
+ VerifyNameValid ("\u3041");
+ VerifyNameValid ("a:b");
+ VerifyNameValid ("_");
+ VerifyNameValid ("__");
+ VerifyNameValid ("_1");
+ VerifyNameValid (":");
+ VerifyNameValid (":a");
+ VerifyNameValid ("a.b");
}
-
+
+ [Test]
+ public void VerifyNameInvalid ()
+ {
+ VerifyNameInvalid ("!");
+ VerifyNameInvalid ("_a!b");
+ VerifyNameInvalid ("?a");
+ VerifyNameInvalid (" ");
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentNullException))]
+ public void VerifyNameNull ()
+ {
+ XmlConvert.VerifyName (null);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentNullException))]
+ public void VerifyNameEmpty ()
+ {
+ XmlConvert.VerifyName ("");
+ }
+
+ private void VerifyNameValid (string value)
+ {
+ try {
+ XmlConvert.VerifyName (value);
+ } catch (XmlException) {
+ AssertType.Fail (String.Format ("'{0}'", value));
+ }
+ }
+
+ private void VerifyNameInvalid (string value)
+ {
+ try {
+ XmlConvert.VerifyName (value);
+ AssertType.Fail (value);
+ } catch (XmlException) {
+ }
+ }
+
[Test]
public void VerifyNCName ()
{
Fail ();
} catch (XmlException) {}
}
+
+ [Test]
+ [ExpectedException (typeof (ArgumentNullException))]
+ public void VerifyNCNameNull ()
+ {
+ XmlConvert.VerifyNCName (null);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentNullException))]
+ public void VerifyNCNameEmpty ()
+ {
+ XmlConvert.VerifyNCName ("");
+ }
+
+ [Test]
+ public void DurationZero () // bug #77350
+ {
+ AssertEquals ("PT0S", XmlConvert.ToString (TimeSpan.FromSeconds (0)));
+ }
+
+#if NET_2_0
+ [Test]
+ public void VerifyTOKEN ()
+ {
+ VerifyToken ("", true);
+ VerifyToken (" ", false);
+ VerifyToken ("A", true);
+ VerifyToken ("!", true);
+ VerifyToken (" !", false);
+ VerifyToken ("! ", false);
+ VerifyToken ("! !", true);
+ VerifyToken ("!\t!", false);
+ VerifyToken ("!\n!", false);
+ VerifyToken ("!\r!", false);
+ VerifyToken ("###", true);
+ }
+
+ private void VerifyToken (string s, bool success)
+ {
+ try {
+ XmlConvert.VerifyTOKEN (s);
+ if (success)
+ return;
+ AssertType.Fail (s + "should fail");
+ } catch (XmlException ex) {
+ if (success)
+ AssertType.Fail (s + "should not fail");
+ }
+ }
+#endif
}
}
projects / mono.git / blobdiff