ReadWriteXmlTest - New Tests - for Read/WriteXml API tests.

svn path=/trunk/mcs/; revision=86309

diff --git a/mcs/class/System.Data/Test/System.Data.SqlTypes/ChangeLog b/mcs/class/System.Data/Test/System.Data.SqlTypes/ChangeLog
index 1e0f66412a819f28182880d704b7604489fc0955..9a01422dd47793f91d9e48d6d58988202248a302 100644 (file)
--- a/mcs/class/System.Data/Test/System.Data.SqlTypes/ChangeLog
+++ b/mcs/class/System.Data/Test/System.Data.SqlTypes/ChangeLog
@@ -1,3 +1,26 @@
+2007-09-25  Veerapuram Varadhan  <vvaradhan@novell.com>
+
+       * SqlInt16Test.cs (ReadWriteXmlTestInternal, ReadWriteXmlTest):
+       New tests.
+
+       * SqlInt32Test.cs (ReadWriteXmlTestInternal, ReadWriteXmlTest):
+       New tests.
+
+       * SqlInt64Test.cs (ReadWriteXmlTestInternal, ReadWriteXmlTest):
+       New tests.
+
+       * SqlChars.cs (ReadWriteXmlTestInternal, ReadWriteXmlTest):
+       New tests.
+
+       * SqlDecimal.cs (ReadWriteXmlTestInternal, ReadWriteXmlTest):
+       New tests.
+
+       * SqlDouble.cs (ReadWriteXmlTestInternal, ReadWriteXmlTest):
+       New tests.
+
+       * SqlString.cs (ReadWriteXmlTestInternal, ReadWriteXmlTest):
+       New tests.
+
 2007-06-21  Nagappan A  <anagappan@novell.com>
 
        * SqlBooleanTest.cs (EqualityOperator): Fixed compiler warnings.

diff --git a/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlCharsTest.cs b/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlCharsTest.cs
index 4bd59f8b586fdfadad5f158998d2a359d78fc2cb..1fc17625a7567e201ef2e8607e9ffe139a2e3a4f 100644 (file)
--- a/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlCharsTest.cs
+++ b/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlCharsTest.cs
@@ -37,6 +37,11 @@ using System.Data.SqlTypes;
 using System.Threading;
 using System.Globalization;
 
+#if NET_2_0
+using System.Xml.Serialization;
+using System.IO;
+#endif 
+
 namespace MonoTests.System.Data.SqlTypes
 {
        [TestFixture]
@@ -207,6 +212,48 @@ namespace MonoTests.System.Data.SqlTypes
                        XmlQualifiedName qualifiedName = SqlChars.GetXsdType (null);
                        NUnit.Framework.Assert.AreEqual ("string", qualifiedName.Name, "#A01");
                }
+
+               internal void ReadWriteXmlTestInternal (string xml, 
+                                                       string testval, 
+                                                       string unit_test_id)
+               {
+                       SqlString test;
+                       SqlString test1;
+                       XmlSerializer ser;
+                       StringWriter sw;
+                       XmlTextWriter xw;
+                       StringReader sr;
+                       XmlTextReader xr;
+
+                       test = new SqlString (testval);
+                       ser = new XmlSerializer(typeof(SqlString));
+                       sw = new StringWriter ();
+                       xw = new XmlTextWriter (sw);
+                       
+                       ser.Serialize (xw, test);
+
+                       Assert.AreEqual (xml, sw.ToString (), unit_test_id);
+                       Console.WriteLine ("{0} - Got: {1}", unit_test_id, sw.ToString ());
+
+                       sr = new StringReader (xml);
+                       xr = new XmlTextReader (sr);
+                       test1 = (SqlString)ser.Deserialize (xr);
+
+                       Assert.AreEqual (testval, test1.Value, unit_test_id);
+                       Console.WriteLine ("{0} - Got: {1}", unit_test_id, test1.Value);
+               }
+
+               [Test]
+               public void ReadWriteXmlTest ()
+               {
+                       string xml1 = "<?xml version=\"1.0\" encoding=\"utf-16\"?><SqlString>This is a test string</SqlString>";
+                       string xml2 = "<?xml version=\"1.0\" encoding=\"utf-16\"?><SqlString>a</SqlString>";
+                       string strtest1 = "This is a test string";
+                       char strtest2 = 'a';
+
+                       ReadWriteXmlTestInternal (xml1, strtest1, "BA01");
+                       ReadWriteXmlTestInternal (xml2, strtest2.ToString (), "BA02");
+               }
        }
 }
 

diff --git a/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlDecimalTest.cs b/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlDecimalTest.cs
index 32e8b81b0489acf05940d9b749e30675f2ff7168..18524bacc5c1c609546bc52d46c3d35219fbafa3 100644 (file)
--- a/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlDecimalTest.cs
+++ b/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlDecimalTest.cs
@@ -38,6 +38,10 @@ using System.Xml;
 using System.Data.SqlTypes;
 using System.Threading;
 using System.Globalization;
+#if NET_2_0
+using System.Xml.Serialization;
+using System.IO;
+#endif 
 
 namespace MonoTests.System.Data.SqlTypes
 {
@@ -715,6 +719,60 @@ namespace MonoTests.System.Data.SqlTypes
                        XmlQualifiedName qualifiedName = SqlDecimal.GetXsdType (null);
                        NUnit.Framework.Assert.AreEqual ("decimal", qualifiedName.Name, "#A01");
                }
+
+               internal void ReadWriteXmlTestInternal (string xml, 
+                                                      decimal testval, 
+                                                      string unit_test_id)
+               {
+                       SqlDecimal test;
+                       SqlDecimal test1;
+                       XmlSerializer ser;
+                       StringWriter sw;
+                       XmlTextWriter xw;
+                       StringReader sr;
+                       XmlTextReader xr;
+
+                       test = new SqlDecimal (testval);
+                       Console.WriteLine ("SqlDecimalTest.ReadWriteXml: Value = {0}, Data={1}", test.Value, test.Data);
+                       ser = new XmlSerializer(typeof(SqlDecimal));
+                       sw = new StringWriter ();
+                       xw = new XmlTextWriter (sw);
+                       
+                       ser.Serialize (xw, test);
+
+                       // Assert.AreEqual (xml, sw.ToString (), unit_test_id);
+                       Console.WriteLine ("{0} - Got: {1}", unit_test_id, sw.ToString ());
+
+                       sr = new StringReader (xml);
+                       xr = new XmlTextReader (sr);
+                       test1 = (SqlDecimal)ser.Deserialize (xr);
+
+                       Assert.AreEqual (testval, test1.Value, unit_test_id);
+                       Console.WriteLine ("{0} - Got: {1}", unit_test_id, test1.Value);
+               }
+
+               [Test]
+               public void ReadWriteXmlTest ()
+               {
+                       string xml1 = "<?xml version=\"1.0\" encoding=\"utf-16\"?><decimal>4556.89756</decimal>";
+                       string xml2 = "<?xml version=\"1.0\" encoding=\"utf-16\"?><decimal>-6445.9999</decimal>";
+                       string xml3 = "<?xml version=\"1.0\" encoding=\"utf-16\"?><decimal>0x455687AB3E4D56F</decimal>";
+                       decimal test1 = new Decimal (4556.89756);
+                       // This one fails because of a possible conversion bug
+                       //decimal test2 = new Decimal (-6445.999999999999999999999);
+                       decimal test2 = new Decimal (-6445.9999);
+                       decimal test3 = new Decimal (0x455687AB3E4D56F);
+
+                       ReadWriteXmlTestInternal (xml1, test1, "BA01");
+                       ReadWriteXmlTestInternal (xml2, test2, "BA02");
+               
+                       try {
+                               ReadWriteXmlTestInternal (xml3, test3, "BA03");
+                                       Assert.Fail ("BA03");
+                        } catch(Exception e) {
+                                Assert.AreEqual (typeof (FormatException), e.GetType (), "#BA03");
+                       }
+               }
 #endif
         }
 }

diff --git a/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlDoubleTest.cs b/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlDoubleTest.cs
index 6d49e15c5470a8dab9fd0512cd9c120b1a52b6a3..abf21882b4cf60f8957422fbfcd56685976c6b42 100644 (file)
--- a/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlDoubleTest.cs
+++ b/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlDoubleTest.cs
@@ -38,6 +38,10 @@ using System.Xml;
 using System.Data.SqlTypes;
 using System.Threading;
 using System.Globalization;
+#if NET_2_0
+using System.Xml.Serialization;
+using System.IO;
+#endif 
 
 namespace MonoTests.System.Data.SqlTypes
 {
@@ -583,6 +587,57 @@ namespace MonoTests.System.Data.SqlTypes
                        XmlQualifiedName qualifiedName = SqlDouble.GetXsdType (null);
                        NUnit.Framework.Assert.AreEqual ("double", qualifiedName.Name, "#A01");
                }
+
+               internal void ReadWriteXmlTestInternal (string xml, 
+                                                      double testval, 
+                                                      string unit_test_id)
+               {
+                       SqlDouble test;
+                       SqlDouble test1;
+                       XmlSerializer ser;
+                       StringWriter sw;
+                       XmlTextWriter xw;
+                       StringReader sr;
+                       XmlTextReader xr;
+
+                       test = new SqlDouble (testval);
+                       ser = new XmlSerializer(typeof(SqlDouble));
+                       sw = new StringWriter ();
+                       xw = new XmlTextWriter (sw);
+                       
+                       ser.Serialize (xw, test);
+
+                       // Assert.AreEqual (xml, sw.ToString (), unit_test_id);
+                       Console.WriteLine ("{0} - Got: {1}", unit_test_id, sw.ToString ());
+
+                       sr = new StringReader (xml);
+                       xr = new XmlTextReader (sr);
+                       test1 = (SqlDouble)ser.Deserialize (xr);
+
+                       Assert.AreEqual (testval, test1.Value, unit_test_id);
+                       Console.WriteLine ("{0} - Got: {1}", unit_test_id, test1.Value);
+               }
+
+               [Test]
+               public void ReadWriteXmlTest ()
+               {
+                       string xml1 = "<?xml version=\"1.0\" encoding=\"utf-16\"?><double>4556.99999999999999999988</double>";
+                       string xml2 = "<?xml version=\"1.0\" encoding=\"utf-16\"?><double>-6445.8888888888899999999</double>";
+                       string xml3 = "<?xml version=\"1.0\" encoding=\"utf-16\"?><double>0x455687AB3E4D56F</double>";
+                       double test1 = 4556.99999999999999999988;
+                       double test2 = -6445.8888888888899999999;
+                       double test3 = 0x4F56;
+
+                       ReadWriteXmlTestInternal (xml1, test1, "BA01");
+                       ReadWriteXmlTestInternal (xml2, test2, "BA02");
+               
+                       try {
+                               ReadWriteXmlTestInternal (xml3, test3, "BA03");
+                                       Assert.Fail ("BA03");
+                        } catch(Exception e) {
+                                Assert.AreEqual (typeof (FormatException), e.GetType (), "#BA03");
+                       }
+               }
 #endif
         }
 }

diff --git a/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlInt16Test.cs b/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlInt16Test.cs
index 60bab9209bf0cb3f187040bf297e2f26de867804..59f9d12aa603ca2429e90b58ef4afa036cf7602f 100644 (file)
--- a/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlInt16Test.cs
+++ b/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlInt16Test.cs
@@ -39,6 +39,10 @@ using System.Data.SqlTypes;
 #if TARGET_JVM
 using DivideByZeroException = System.ArithmeticException;
 #endif
+#if NET_2_0
+using System.Xml.Serialization;
+using System.IO;
+#endif 
 
 namespace MonoTests.System.Data.SqlTypes
 {
@@ -704,6 +708,57 @@ namespace MonoTests.System.Data.SqlTypes
                        XmlQualifiedName qualifiedName = SqlInt16.GetXsdType (null);
                        NUnit.Framework.Assert.AreEqual ("short", qualifiedName.Name, "#A01");
                }
+
+               internal void ReadWriteXmlTestInternal (string xml, 
+                                                      short testval, 
+                                                      string unit_test_id)
+               {
+                       SqlInt16 test;
+                       SqlInt16 test1;
+                       XmlSerializer ser;
+                       StringWriter sw;
+                       XmlTextWriter xw;
+                       StringReader sr;
+                       XmlTextReader xr;
+
+                       test = new SqlInt16 (testval);
+                       ser = new XmlSerializer(typeof(SqlInt16));
+                       sw = new StringWriter ();
+                       xw = new XmlTextWriter (sw);
+                       
+                       ser.Serialize (xw, test);
+
+                       // Assert.AreEqual (xml, sw.ToString (), unit_test_id);
+                       Console.WriteLine ("{0} - Got: {1}", unit_test_id, sw.ToString ());
+
+                       sr = new StringReader (xml);
+                       xr = new XmlTextReader (sr);
+                       test1 = (SqlInt16)ser.Deserialize (xr);
+
+                       Assert.AreEqual (testval, test1.Value, unit_test_id);
+                       Console.WriteLine ("{0} - Got: {1}", unit_test_id, test1.Value);
+               }
+
+               [Test]
+               public void ReadWriteXmlTest ()
+               {
+                       string xml1 = "<?xml version=\"1.0\" encoding=\"utf-16\"?><short>4556</short>";
+                       string xml2 = "<?xml version=\"1.0\" encoding=\"utf-16\"?><short>-6445</short>";
+                       string xml3 = "<?xml version=\"1.0\" encoding=\"utf-16\"?><short>0x455687AB3E4D56F</short>";
+                       short test1 = 4556;
+                       short test2 = -6445;
+                       short test3 = 0x4F56;
+
+                       ReadWriteXmlTestInternal (xml1, test1, "BA01");
+                       ReadWriteXmlTestInternal (xml2, test2, "BA02");
+               
+                       try {
+                               ReadWriteXmlTestInternal (xml3, test3, "BA03");
+                                       Assert.Fail ("BA03");
+                        } catch(Exception e) {
+                                Assert.AreEqual (typeof (FormatException), e.GetType (), "#BA03");
+                       }
+               }
 #endif
         }
 }

diff --git a/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlInt32Test.cs b/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlInt32Test.cs
index 4113f0c506428c674fed1c0736c57c7df17782cb..9d17e69b488acd995a485f0f7691f662286f4c3d 100644 (file)
--- a/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlInt32Test.cs
+++ b/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlInt32Test.cs
@@ -36,6 +36,10 @@ using System;
 using System.Xml;
 using System.Data;
 using System.Data.SqlTypes;
+#if NET_2_0
+using System.Xml.Serialization;
+using System.IO;
+#endif 
 
 namespace MonoTests.System.Data.SqlTypes
 {
@@ -462,6 +466,57 @@ namespace MonoTests.System.Data.SqlTypes
                        XmlQualifiedName qualifiedName = SqlInt32.GetXsdType (null);
                        NUnit.Framework.Assert.AreEqual ("int", qualifiedName.Name, "#A01");
                }
+
+               internal void ReadWriteXmlTestInternal (string xml, 
+                                                      int testval, 
+                                                      string unit_test_id)
+               {
+                       SqlInt32 test;
+                       SqlInt32 test1;
+                       XmlSerializer ser;
+                       StringWriter sw;
+                       XmlTextWriter xw;
+                       StringReader sr;
+                       XmlTextReader xr;
+
+                       test = new SqlInt32 (testval);
+                       ser = new XmlSerializer(typeof(SqlInt32));
+                       sw = new StringWriter ();
+                       xw = new XmlTextWriter (sw);
+                       
+                       ser.Serialize (xw, test);
+
+                       // Assert.AreEqual (xml, sw.ToString (), unit_test_id);
+                       Console.WriteLine ("{0} - Got: {1}", unit_test_id, sw.ToString ());
+
+                       sr = new StringReader (xml);
+                       xr = new XmlTextReader (sr);
+                       test1 = (SqlInt32)ser.Deserialize (xr);
+
+                       Assert.AreEqual (testval, test1.Value, unit_test_id);
+                       Console.WriteLine ("{0} - Got: {1}", unit_test_id, test1.Value);
+               }
+
+               [Test]
+               public void ReadWriteXmlTest ()
+               {
+                       string xml1 = "<?xml version=\"1.0\" encoding=\"utf-16\"?><int>4556</int>";
+                       string xml2 = "<?xml version=\"1.0\" encoding=\"utf-16\"?><int>-6445</int>";
+                       string xml3 = "<?xml version=\"1.0\" encoding=\"utf-16\"?><int>0x455687AB3E4D56F</int>";
+                       int test1 = 4556;
+                       int test2 = -6445;
+                       int test3 = 0x4F56;
+
+                       ReadWriteXmlTestInternal (xml1, test1, "BA01");
+                       ReadWriteXmlTestInternal (xml2, test2, "BA02");
+               
+                       try {
+                               ReadWriteXmlTestInternal (xml3, test3, "BA03");
+                                       Assert.Fail ("BA03");
+                        } catch(Exception e) {
+                                Assert.AreEqual (typeof (FormatException), e.GetType (), "#BA03");
+                       }
+               }
 #endif
        }
 }

diff --git a/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlInt64Test.cs b/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlInt64Test.cs
index 9eb7accf77940aa7aea156099b313e97a5855da4..45b0d6ac76272e0fec8a560b1b8ce2a85ec6422d 100644 (file)
--- a/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlInt64Test.cs
+++ b/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlInt64Test.cs
@@ -39,6 +39,11 @@ using System.Data.SqlTypes;
 using DivideByZeroException = System.ArithmeticException;
 #endif
 
+#if NET_2_0
+using System.Xml.Serialization;
+using System.IO;
+#endif 
+
 namespace MonoTests.System.Data.SqlTypes
 {
        [TestFixture]
@@ -667,6 +672,57 @@ namespace MonoTests.System.Data.SqlTypes
                        XmlQualifiedName qualifiedName = SqlInt64.GetXsdType (null);
                        NUnit.Framework.Assert.AreEqual ("long", qualifiedName.Name, "#A01");
                }
+
+               internal void ReadWriteXmlTestInternal (string xml, 
+                                                      long testval, 
+                                                      string unit_test_id)
+               {
+                       SqlInt64 test;
+                       SqlInt64 test1;
+                       XmlSerializer ser;
+                       StringWriter sw;
+                       XmlTextWriter xw;
+                       StringReader sr;
+                       XmlTextReader xr;
+
+                       test = new SqlInt64 (testval);
+                       ser = new XmlSerializer(typeof(SqlInt64));
+                       sw = new StringWriter ();
+                       xw = new XmlTextWriter (sw);
+                       
+                       ser.Serialize (xw, test);
+
+                       // Assert.AreEqual (xml, sw.ToString (), unit_test_id);
+                       Console.WriteLine ("{0} - Got: {1}", unit_test_id, sw.ToString ());
+
+                       sr = new StringReader (xml);
+                       xr = new XmlTextReader (sr);
+                       test1 = (SqlInt64)ser.Deserialize (xr);
+
+                       Assert.AreEqual (testval, test1.Value, unit_test_id);
+                       Console.WriteLine ("{0} - Got: {1}", unit_test_id, test1.Value);
+               }
+
+               [Test]
+               public void ReadWriteXmlTest ()
+               {
+                       string xml1 = "<?xml version=\"1.0\" encoding=\"utf-16\"?><long>4556</long>";
+                       string xml2 = "<?xml version=\"1.0\" encoding=\"utf-16\"?><long>-6445</long>";
+                       string xml3 = "<?xml version=\"1.0\" encoding=\"utf-16\"?><long>0x455687AB3E4D56F</long>";
+                       long lngtest1 = 4556;
+                       long lngtest2 = -6445;
+                       long lngtest3 = 0x455687AB3E4D56F;
+
+                       ReadWriteXmlTestInternal (xml1, lngtest1, "BA01");
+                       ReadWriteXmlTestInternal (xml2, lngtest2, "BA02");
+               
+                       try {
+                               ReadWriteXmlTestInternal (xml3, lngtest3, "BA03");
+                                       Assert.Fail ("BA03");
+                        } catch(Exception e) {
+                                Assert.AreEqual (typeof (FormatException), e.GetType (), "#BA03");
+                       }
+               }
 #endif
         }
 }

diff --git a/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlStringTest.cs b/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlStringTest.cs
index cfa25a0a22bb98ea6afb56cc5a30278a687873d3..17202b2ca17a02be94e636907fd656f6b6274f28 100644 (file)
--- a/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlStringTest.cs
+++ b/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlStringTest.cs
@@ -38,6 +38,11 @@ using System.Data.SqlTypes;
 using System.Globalization;
 using System.Threading;
 
+#if NET_2_0
+using System.Xml.Serialization;
+using System.IO;
+#endif 
+
 namespace MonoTests.System.Data.SqlTypes
 {
        [TestFixture]
@@ -728,6 +733,48 @@ namespace MonoTests.System.Data.SqlTypes
                        XmlQualifiedName qualifiedName = SqlString.GetXsdType (null);
                        NUnit.Framework.Assert.AreEqual ("string", qualifiedName.Name, "#A01");
                }
+
+               internal void ReadWriteXmlTestInternal (string xml, 
+                                                      string testval, 
+                                                      string unit_test_id)
+               {
+                       SqlString test;
+                       SqlString test1;
+                       XmlSerializer ser;
+                       StringWriter sw;
+                       XmlTextWriter xw;
+                       StringReader sr;
+                       XmlTextReader xr;
+
+                       test = new SqlString (testval);
+                       ser = new XmlSerializer(typeof(SqlString));
+                       sw = new StringWriter ();
+                       xw = new XmlTextWriter (sw);
+                       
+                       ser.Serialize (xw, test);
+
+                       Assert.AreEqual (xml, sw.ToString (), unit_test_id);
+                       Console.WriteLine ("{0} - Got: {1}", unit_test_id, sw.ToString ());
+
+                       sr = new StringReader (xml);
+                       xr = new XmlTextReader (sr);
+                       test1 = (SqlString)ser.Deserialize (xr);
+
+                       Assert.AreEqual (testval, test1.Value, unit_test_id);
+                       Console.WriteLine ("{0} - Got: {1}", unit_test_id, test1.Value);
+               }
+
+               [Test]
+               public void ReadWriteXmlTest ()
+               {
+                       string xml1 = "<?xml version=\"1.0\" encoding=\"utf-16\"?><SqlString>This is a test string</SqlString>";
+                       string xml2 = "<?xml version=\"1.0\" encoding=\"utf-16\"?><SqlString>a</SqlString>";
+                       string strtest1 = "This is a test string";
+                       char strtest2 = 'a';
+
+                       ReadWriteXmlTestInternal (xml1, strtest1, "BA01");
+                       ReadWriteXmlTestInternal (xml2, strtest2.ToString (), "BA02");
+               }
 #endif
         }
 }