mcs/class/System.Data/Test/System.Data/DataSetTest.cs

   1 // MonoTests.System.Data.DataSetTest.cs
   2 //
   3 // Authors:
   4 //   Ville Palo <vi64pa@koti.soon.fi>
   5 //   Martin Willemoes Hansen <mwh@sysrq.dk>
   6 //   Atsushi Enomoto <atsushi@ximian.com>
   7 //   Hagit Yidov <hagity@mainsoft.com>
   8 //
   9 // (C) Copyright 2002 Ville Palo
  10 // (C) Copyright 2003 Martin Willemoes Hansen
  11 // (C) 2005 Mainsoft Corporation (http://www.mainsoft.com)
  12 // Copyright 2011 Xamarin Inc.
  13 //
  14 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
  15 //
  16 // Permission is hereby granted, free of charge, to any person obtaining
  17 // a copy of this software and associated documentation files (the
  18 // "Software"), to deal in the Software without restriction, including
  19 // without limitation the rights to use, copy, modify, merge, publish,
  20 // distribute, sublicense, and/or sell copies of the Software, and to
  21 // permit persons to whom the Software is furnished to do so, subject to
  22 // the following conditions:
  23 //
  24 // The above copyright notice and this permission notice shall be
  25 // included in all copies or substantial portions of the Software.
  26 //
  27 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  28 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  29 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  30 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  31 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  32 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  33 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  34 //
  35
  36
  37 using NUnit.Framework;
  38 using System;
  39 using System.Xml;
  40 using System.Xml.Schema;
  41 using System.Xml.Serialization;
  42 using System.IO;
  43 using System.Data;
  44 using System.Data.SqlTypes;
  45 using System.Globalization;
  46 using System.Threading;
  47 using System.Text;
  48
  49 namespace MonoTests.System.Data
  50 {
  51         [TestFixture]
  52         public class DataSetTest : DataSetAssertion
  53         {
  54                 string EOL = Environment.NewLine;
  55                 CultureInfo currentCultureBackup;
  56
  57                 [SetUp]
  58                 public void Setup () {
  59                         currentCultureBackup = Thread.CurrentThread.CurrentCulture;
  60                         Thread.CurrentThread.CurrentCulture = new CultureInfo ("fi-FI");
  61                 }
  62
  63                 //[SetUp]
  64                 //public void GetReady()
  65                 //{
  66                 //        currentCultureBackup = Thread.CurrentThread.CurrentCulture;
  67                 //        Thread.CurrentThread.CurrentCulture = new CultureInfo ("fi-FI");
  68                 //}
  69
  70                 [TearDown]
  71                 public void Teardown ()
  72                 {
  73                         Thread.CurrentThread.CurrentCulture = currentCultureBackup;
  74                 }
  75
  76                 [Test]
  77                 public void Properties ()
  78                 {
  79                         DataSet ds = new DataSet ();
  80                         Assert.AreEqual (String.Empty, ds.Namespace, "default namespace");
  81                         ds.Namespace = null; // setting null == setting ""
  82                         Assert.AreEqual (String.Empty, ds.Namespace, "after setting null to namespace");
  83
  84                         Assert.AreEqual (String.Empty, ds.Prefix, "default prefix");
  85                         ds.Prefix = null; // setting null == setting ""
  86                         Assert.AreEqual (String.Empty, ds.Prefix, "after setting null to prefix");
  87                 }
  88
  89                 [Test]
  90                 public void ReadXmlSchema ()
  91                 {
  92                         DataSet ds = new DataSet ();
  93                         ds.ReadXmlSchema ("Test/System.Data/own_schema.xsd");
  94
  95                         Assert.AreEqual (2, ds.Tables.Count, "test#01");
  96                         DataTable Table = ds.Tables [0];
  97                         Assert.AreEqual ("test_table", Table.TableName, "test#02");
  98                         Assert.AreEqual ("", Table.Namespace, "test#03");
  99                         Assert.AreEqual (2, Table.Columns.Count, "test#04");
 100                         Assert.AreEqual (0, Table.Rows.Count, "test#05");
 101                         Assert.IsFalse (Table.CaseSensitive, "test#06");
 102                         Assert.AreEqual (1, Table.Constraints.Count, "test#07");
 103                         Assert.AreEqual ("", Table.Prefix, "test#08");
 104
 105                         Constraint cons = Table.Constraints [0];
 106                         Assert.AreEqual ("Constraint1", cons.ConstraintName.ToString (), "test#09");
 107                         Assert.AreEqual ("Constraint1", cons.ToString (), "test#10");
 108
 109                         DataColumn column = Table.Columns [0];
 110                         Assert.IsTrue (column.AllowDBNull, "test#11");
 111                         Assert.IsFalse (column.AutoIncrement, "test#12");
 112                         Assert.AreEqual (0L, column.AutoIncrementSeed, "test#13");
 113                         Assert.AreEqual (1L, column.AutoIncrementStep, "test#14");
 114                         Assert.AreEqual ("test", column.Caption, "test#15");
 115                         Assert.AreEqual ("Element", column.ColumnMapping.ToString (), "test#16");
 116                         Assert.AreEqual ("first", column.ColumnName, "test#17");
 117                         Assert.AreEqual ("System.String", column.DataType.ToString (), "test#18");
 118                         Assert.AreEqual ("test_default_value", column.DefaultValue.ToString (), "test#19");
 119                         Assert.IsFalse (column.DesignMode, "test#20");
 120                         Assert.AreEqual ("", column.Expression, "test#21");
 121                         Assert.AreEqual (100, column.MaxLength, "test#22");
 122                         Assert.AreEqual ("", column.Namespace, "test#23");
 123                         Assert.AreEqual (0, column.Ordinal, "test#24");
 124                         Assert.AreEqual ("", column.Prefix, "test#25");
 125                         Assert.IsFalse (column.ReadOnly, "test#26");
 126                         Assert.IsTrue (column.Unique, "test#27");
 127
 128                         DataColumn column2 = Table.Columns [1];
 129                         Assert.IsTrue (column2.AllowDBNull, "test#28");
 130                         Assert.IsFalse (column2.AutoIncrement, "test#29");
 131                         Assert.AreEqual (0L, column2.AutoIncrementSeed, "test#30");
 132                         Assert.AreEqual (1L, column2.AutoIncrementStep, "test#31");
 133                         Assert.AreEqual ("second", column2.Caption, "test#32");
 134                         Assert.AreEqual ("Element", column2.ColumnMapping.ToString (), "test#33");
 135                         Assert.AreEqual ("second", column2.ColumnName, "test#34");
 136                         Assert.AreEqual ("System.Data.SqlTypes.SqlGuid", column2.DataType.ToString (), "test#35");
 137 #if NET_2_0
 138                         Assert.AreEqual (SqlGuid.Null, column2.DefaultValue, "test#36");
 139 #else
 140                         Assert.AreEqual (DBNull.Value, column2.DefaultValue, "test#36");
 141 #endif
 142                         Assert.IsFalse (column2.DesignMode, "test#37");
 143                         Assert.AreEqual ("", column2.Expression, "test#38");
 144                         Assert.AreEqual (-1, column2.MaxLength, "test#39");
 145                         Assert.AreEqual ("", column2.Namespace, "test#40");
 146                         Assert.AreEqual (1, column2.Ordinal, "test#41");
 147                         Assert.AreEqual ("", column2.Prefix, "test#42");
 148                         Assert.IsFalse (column2.ReadOnly, "test#43");
 149                         Assert.IsFalse (column2.Unique, "test#44");
 150
 151                         DataTable Table2 = ds.Tables [1];
 152                         Assert.AreEqual ("second_test_table", Table2.TableName, "test#45");
 153                         Assert.AreEqual ("", Table2.Namespace, "test#46");
 154                         Assert.AreEqual (1, Table2.Columns.Count, "test#47");
 155                         Assert.AreEqual (0, Table2.Rows.Count, "test#48");
 156                         Assert.IsFalse (Table2.CaseSensitive, "test#49");
 157                         Assert.AreEqual (1, Table2.Constraints.Count, "test#50");
 158                         Assert.AreEqual ("", Table2.Prefix, "test#51");
 159
 160                         DataColumn column3 = Table2.Columns [0];
 161                         Assert.IsTrue (column3.AllowDBNull, "test#52");
 162                         Assert.IsFalse (column3.AutoIncrement, "test#53");
 163                         Assert.AreEqual (0L, column3.AutoIncrementSeed, "test#54");
 164                         Assert.AreEqual (1L, column3.AutoIncrementStep, "test#55");
 165                         Assert.AreEqual ("second_first", column3.Caption, "test#56");
 166                         Assert.AreEqual ("Element", column3.ColumnMapping.ToString (), "test#57");
 167                         Assert.AreEqual ("second_first", column3.ColumnName, "test#58");
 168                         Assert.AreEqual ("System.String", column3.DataType.ToString (), "test#59");
 169                         Assert.AreEqual ("default_value", column3.DefaultValue.ToString (), "test#60");
 170                         Assert.IsFalse (column3.DesignMode, "test#61");
 171                         Assert.AreEqual ("", column3.Expression, "test#62");
 172                         Assert.AreEqual (100, column3.MaxLength, "test#63");
 173                         Assert.AreEqual ("", column3.Namespace, "test#64");
 174                         Assert.AreEqual (0, column3.Ordinal, "test#65");
 175                         Assert.AreEqual ("", column3.Prefix, "test#66");
 176                         Assert.IsFalse (column3.ReadOnly, "test#67");
 177                         Assert.IsTrue (column3.Unique, "test#68");
 178                 }
 179
 180                 [Test]
 181                 public void OwnWriteXmlSchema ()
 182                 {
 183                         DataSet ds = new DataSet ("test_dataset");
 184                         DataTable table = new DataTable ("test_table");
 185                         DataColumn column = new DataColumn ("first", typeof (string));
 186                         column.AllowDBNull = true;
 187                         column.DefaultValue = "test_default_value";
 188                         column.MaxLength = 100;
 189                         column.Caption = "test";
 190                         column.Unique = true;
 191                         table.Columns.Add (column);
 192
 193                         DataColumn column2 = new DataColumn ("second", typeof (SqlGuid));
 194                         column2.ColumnMapping = MappingType.Element;
 195                         table.Columns.Add (column2);
 196                         ds.Tables.Add (table);
 197
 198                         DataTable table2 = new DataTable ("second_test_table");
 199                         DataColumn column3 = new DataColumn ("second_first", typeof (string));
 200                         column3.AllowDBNull = true;
 201                         column3.DefaultValue = "default_value";
 202                         column3.MaxLength = 100;
 203                         column3.Unique = true;
 204                         table2.Columns.Add (column3);
 205                         ds.Tables.Add (table2);
 206
 207                         TextWriter writer = new StringWriter ();
 208                         ds.WriteXmlSchema (writer);
 209
 210                         string TextString = GetNormalizedSchema (writer.ToString ());
 211 //                      string TextString = writer.ToString ();
 212
 213                         string substring = TextString.Substring (0, TextString.IndexOf(EOL));
 214                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 215                         Assert.AreEqual ("<?xml version=\"1.0\" encoding=\"utf-16\"?>", substring, "test#01");
 216
 217                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 218                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 219                         // This is original DataSet.WriteXmlSchema() output
 220 //                      Assert.AreEqual ("<xs:schema id=\"test_dataset\" xmlns=\"\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\">", substring, "test#02");
 221                         Assert.AreEqual ("<xs:schema id=\"test_dataset\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">", substring, "test#02");
 222
 223                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 224                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 225                         // This is original DataSet.WriteXmlSchema() output
 226 //                      Assert.AreEqual ("  <xs:element name=\"test_dataset\" msdata:IsDataSet=\"true\" msdata:Locale=\"fi-FI\">", substring, "test#03");
 227 #if !NET_2_0
 228                         Assert.AreEqual ("  <xs:element msdata:IsDataSet=\"true\" msdata:Locale=\"fi-FI\" name=\"test_dataset\">", substring, "test#03");
 229 #else
 230                         Assert.AreEqual ("  <xs:element msdata:IsDataSet=\"true\" msdata:UseCurrentLocale=\"true\" name=\"test_dataset\">", substring, "test#03");
 231 #endif
 232
 233                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 234                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 235                         Assert.AreEqual ("    <xs:complexType>", substring, "test#04");
 236
 237                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 238                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 239                         Assert.AreEqual ("      <xs:choice maxOccurs=\"unbounded\" minOccurs=\"0\">", substring, "test#05");
 240
 241                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 242                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 243                         Assert.AreEqual ("        <xs:element name=\"test_table\">", substring, "test#06");
 244
 245                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 246                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 247                         Assert.AreEqual ("          <xs:complexType>", substring, "test#07");
 248
 249                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 250                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 251                         Assert.AreEqual ("            <xs:sequence>", substring, "test#08");
 252
 253                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 254                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 255                         // This is original DataSet.WriteXmlSchema() output
 256 //                      Assert.AreEqual ("              <xs:element name=\"first\" msdata:Caption=\"test\" default=\"test_default_value\" minOccurs=\"0\">", substring, "test#09");
 257                         Assert.AreEqual ("              <xs:element default=\"test_default_value\" minOccurs=\"0\" msdata:Caption=\"test\" name=\"first\">", substring, "test#09");
 258
 259                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 260                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 261                         Assert.AreEqual ("                <xs:simpleType>", substring, "test#10");
 262
 263                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 264                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 265                         Assert.AreEqual ("                  <xs:restriction base=\"xs:string\">", substring, "test#11");
 266
 267                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 268                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 269                         Assert.AreEqual ("                    <xs:maxLength value=\"100\" />", substring, "test#12");
 270
 271                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 272                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 273                         Assert.AreEqual ("                  </xs:restriction>", substring, "test#13");
 274
 275                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 276                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 277                         Assert.AreEqual ("                </xs:simpleType>", substring, "test#14");
 278
 279                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 280                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 281                         Assert.AreEqual ("              </xs:element>", substring, "test#15");
 282
 283                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 284                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 285                         // This is original DataSet.WriteXmlSchema() output
 286 #if NET_4_0
 287                         Assert.AreEqual ("              <xs:element minOccurs=\"0\" msdata:DataType=\"System.Data.SqlTypes.SqlGuid, System.Data, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089\" name=\"second\" type=\"xs:string\" />", substring, "test#16");
 288 #elif NET_2_0
 289                         Assert.AreEqual ("              <xs:element minOccurs=\"0\" msdata:DataType=\"System.Data.SqlTypes.SqlGuid, System.Data, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089\" name=\"second\" type=\"xs:string\" />", substring, "test#16");
 290 #else
 291                         #error "Unknown profile"
 292 #endif
 293                         if (substring.IndexOf ("<xs:element") < 0)
 294                                 Assert.Fail ("test#16: " + substring);
 295                         if (substring.IndexOf ("name=\"second\"") < 0)
 296                                 Assert.Fail ("test#16: " + substring);
 297                         if (substring.IndexOf ("msdata:DataType=\"System.Data.SqlTypes.SqlGuid, System.Data, Version=") < 0)
 298                                 Assert.Fail ("test#16: " + substring);
 299                         if (substring.IndexOf ("type=\"xs:string\"") < 0)
 300                                 Assert.Fail ("test#16: " + substring);
 301                         if (substring.IndexOf ("minOccurs=\"0\"") < 0)
 302                                 Assert.Fail ("test#16: " + substring);
 303
 304                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 305                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 306                         Assert.AreEqual ("            </xs:sequence>", substring, "test#17");
 307
 308                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 309                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 310                         Assert.AreEqual ("          </xs:complexType>", substring, "test#18");
 311
 312                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 313                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 314                         Assert.AreEqual ("        </xs:element>", substring, "test#19");
 315
 316                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 317                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 318                         Assert.AreEqual ("        <xs:element name=\"second_test_table\">", substring, "test#20");
 319
 320                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 321                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 322                         Assert.AreEqual ("          <xs:complexType>", substring, "test#21");
 323
 324                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 325                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 326                         Assert.AreEqual ("            <xs:sequence>", substring, "test#22");
 327
 328                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 329                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 330                         // This is original DataSet.WriteXmlSchema() output
 331 //                      Assert.AreEqual ("              <xs:element name=\"second_first\" default=\"default_value\" minOccurs=\"0\">", substring, "test#23");
 332                         Assert.AreEqual ("              <xs:element default=\"default_value\" minOccurs=\"0\" name=\"second_first\">", substring, "test#23");
 333
 334                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 335                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 336                         Assert.AreEqual ("                <xs:simpleType>", substring, "test#24");
 337
 338                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 339                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 340                         Assert.AreEqual ("                  <xs:restriction base=\"xs:string\">", substring, "test#25");
 341
 342                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 343                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 344                         Assert.AreEqual ("                    <xs:maxLength value=\"100\" />", substring, "test#26");
 345
 346                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 347                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 348                         Assert.AreEqual ("                  </xs:restriction>", substring, "test#27");
 349
 350                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 351                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 352                         Assert.AreEqual ("                </xs:simpleType>", substring, "test#28");
 353
 354                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 355                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 356                         Assert.AreEqual ("              </xs:element>", substring, "test#29");
 357
 358                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 359                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 360                         Assert.AreEqual ("            </xs:sequence>", substring, "test#30");
 361
 362                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 363                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 364                         Assert.AreEqual ("          </xs:complexType>", substring, "test#31");
 365
 366                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 367                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 368                         Assert.AreEqual ("        </xs:element>", substring, "test#32");
 369
 370                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 371                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 372                         Assert.AreEqual ("      </xs:choice>", substring, "test#33");
 373
 374                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 375                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 376                         Assert.AreEqual ("    </xs:complexType>", substring, "test#34");
 377
 378                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 379                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 380                         Assert.AreEqual ("    <xs:unique name=\"Constraint1\">", substring, "test#36");
 381
 382                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 383                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 384                         Assert.AreEqual ("      <xs:selector xpath=\".//test_table\" />", substring, "test#37");
 385
 386                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 387                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 388                         Assert.AreEqual ("      <xs:field xpath=\"first\" />", substring, "test#38");
 389
 390                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 391                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 392                         Assert.AreEqual ("    </xs:unique>", substring, "test#39");
 393
 394                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 395                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 396                         // This is original DataSet.WriteXmlSchema() output
 397 //                      Assert.AreEqual ("    <xs:unique name=\"second_test_table_Constraint1\" msdata:ConstraintName=\"Constraint1\">", substring, "test#40");
 398                         Assert.AreEqual ("    <xs:unique msdata:ConstraintName=\"Constraint1\" name=\"second_test_table_Constraint1\">", substring, "test#40");
 399
 400                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 401                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 402                         Assert.AreEqual ("      <xs:selector xpath=\".//second_test_table\" />", substring, "test#41");
 403
 404                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 405                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 406                         Assert.AreEqual ("      <xs:field xpath=\"second_first\" />", substring, "test#42");
 407
 408                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 409                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 410                         Assert.AreEqual ("    </xs:unique>", substring, "test#43");
 411
 412                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 413                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 414                         Assert.AreEqual ("  </xs:element>", substring, "test#44");
 415                         Assert.AreEqual ("</xs:schema>", TextString, "test#45");
 416                 }
 417
 418                 [Test]
 419                 public void ReadWriteXml ()
 420                 {
 421                         DataSet ds = new DataSet ();
 422                         ds.ReadXml ("Test/System.Data/region.xml");
 423                         TextWriter writer = new StringWriter ();
 424                         ds.WriteXml (writer);
 425
 426                         string TextString = writer.ToString ();
 427                         string substring = TextString.Substring (0, TextString.IndexOf(EOL));
 428                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 429                         Assert.AreEqual ("<Root>", substring, "test#01");
 430
 431                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 432                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 433                         Assert.AreEqual ("  <Region>", substring, "test#02");
 434
 435                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 436                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 437                         Assert.AreEqual ("    <RegionID>1</RegionID>", substring, "test#03");
 438                         // Here the end of line is text markup "\n"
 439                         substring = TextString.Substring (0, TextString.IndexOf('\n'));
 440                         TextString = TextString.Substring (TextString.IndexOf('\n') + 1);
 441                         Assert.AreEqual ("    <RegionDescription>Eastern", substring, "test#04");
 442
 443                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 444                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 445                         Assert.AreEqual ("   </RegionDescription>", substring, "test#05");
 446
 447                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 448                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 449                         Assert.AreEqual ("  </Region>", substring, "test#06");
 450
 451                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 452                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 453                         Assert.AreEqual ("  <Region>", substring, "test#07");
 454
 455                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 456                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 457                         Assert.AreEqual ("    <RegionID>2</RegionID>", substring, "test#08");
 458
 459                         // Here the end of line is text markup "\n"
 460                         substring = TextString.Substring (0, TextString.IndexOf('\n'));
 461                         TextString = TextString.Substring (TextString.IndexOf('\n') + 1);
 462                         Assert.AreEqual ("    <RegionDescription>Western", substring, "test#09");
 463
 464                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 465                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 466                         Assert.AreEqual ("   </RegionDescription>", substring, "test#10");
 467
 468                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 469                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 470                         Assert.AreEqual ("  </Region>", substring, "test#11");
 471
 472                         Assert.AreEqual ("</Root>", TextString, "test#11");
 473                 }
 474
 475                 [Test]
 476                 public void ReadWriteXmlDiffGram ()
 477                 {
 478                         DataSet ds = new DataSet ();
 479                         // It is not a diffgram, so no data loading should be done.
 480                         ds.ReadXml ("Test/System.Data/region.xml", XmlReadMode.DiffGram);
 481                         TextWriter writer = new StringWriter ();
 482                         ds.WriteXml (writer);
 483
 484                         string TextString = writer.ToString ();
 485                         Assert.AreEqual ("<NewDataSet />", TextString, "test#01");
 486
 487                         ds.WriteXml (writer, XmlWriteMode.DiffGram);
 488                         TextString = writer.ToString ();
 489
 490                         Assert.AreEqual ("<NewDataSet /><diffgr:diffgram xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\" xmlns:diffgr=\"urn:schemas-microsoft-com:xml-diffgram-v1\" />", TextString, "test#02");
 491
 492
 493                         ds = new DataSet ();
 494                         ds.ReadXml ("Test/System.Data/region.xml");
 495                         DataTable table = ds.Tables ["Region"];
 496                         table.Rows [0] [0] = "64";
 497                         ds.ReadXml ("Test/System.Data/region.xml", XmlReadMode.DiffGram);
 498                         ds.WriteXml (writer, XmlWriteMode.DiffGram);
 499
 500                         TextString = writer.ToString ();
 501                         string substring = TextString.Substring (0, TextString.IndexOf(EOL));
 502                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 503                         Assert.AreEqual ("<NewDataSet /><diffgr:diffgram xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\" xmlns:diffgr=\"urn:schemas-microsoft-com:xml-diffgram-v1\" /><diffgr:diffgram xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\" xmlns:diffgr=\"urn:schemas-microsoft-com:xml-diffgram-v1\">", substring, "test#03");
 504
 505                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 506                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 507                         Assert.AreEqual ("  <Root>", substring, "test#04");
 508
 509                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 510                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 511                         Assert.AreEqual ("    <Region diffgr:id=\"Region1\" msdata:rowOrder=\"0\" diffgr:hasChanges=\"inserted\">", substring, "test#05");
 512
 513                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 514                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 515                         Assert.AreEqual ("      <RegionID>64</RegionID>", substring, "test#06");
 516
 517                         // not EOL but literal '\n'
 518                         substring = TextString.Substring (0, TextString.IndexOf('\n'));
 519                         TextString = TextString.Substring (TextString.IndexOf('\n') + 1);
 520                         Assert.AreEqual ("      <RegionDescription>Eastern", substring, "test#07");
 521
 522                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 523                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 524                         Assert.AreEqual ("   </RegionDescription>", substring, "test#07");
 525
 526                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 527                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 528                         Assert.AreEqual ("    </Region>", substring, "test#08");
 529
 530                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 531                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 532                         Assert.AreEqual ("    <Region diffgr:id=\"Region2\" msdata:rowOrder=\"1\" diffgr:hasChanges=\"inserted\">", substring, "test#09");
 533
 534                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 535                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 536                         Assert.AreEqual ("      <RegionID>2</RegionID>", substring, "test#10");
 537
 538                         // not EOL but literal '\n'
 539                         substring = TextString.Substring (0, TextString.IndexOf('\n'));
 540                         TextString = TextString.Substring (TextString.IndexOf('\n') + 1);
 541                         Assert.AreEqual ("      <RegionDescription>Western", substring, "test#11");
 542
 543                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 544                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 545                         Assert.AreEqual ("   </RegionDescription>", substring, "test#12");
 546
 547                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 548                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 549                         Assert.AreEqual ("    </Region>", substring, "test#13");
 550
 551                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 552                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 553                         Assert.AreEqual ("  </Root>", substring, "test#14");
 554
 555                         Assert.AreEqual ("</diffgr:diffgram>", TextString, "test#15");
 556                 }
 557
 558                 [Test]
 559                 public void WriteXmlSchema ()
 560                 {
 561                         DataSet ds = new DataSet ();
 562                         ds.ReadXml ("Test/System.Data/region.xml");
 563                         TextWriter writer = new StringWriter ();
 564                         ds.WriteXmlSchema (writer);
 565
 566
 567                         string TextString = GetNormalizedSchema (writer.ToString ());
 568 //                      string TextString = writer.ToString ();
 569
 570                         string substring = TextString.Substring (0, TextString.IndexOf(EOL));
 571                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 572                         Assert.AreEqual ("<?xml version=\"1.0\" encoding=\"utf-16\"?>", substring, "test#01");
 573
 574                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 575                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 576                         // This is original DataSet.WriteXmlSchema() output
 577 //                      Assert.AreEqual ("<xs:schema id=\"Root\" xmlns=\"\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\">", substring, "test#02");
 578                         Assert.AreEqual ("<xs:schema id=\"Root\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">", substring, "test#02");
 579
 580                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 581                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 582                         Assert.AreEqual ("  <xs:element msdata:IsDataSet=\"true\" msdata:Locale=\"en-US\" name=\"Root\">", substring, "test#03");
 583
 584                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 585                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 586                         Assert.AreEqual ("    <xs:complexType>", substring, "test#04");
 587
 588                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 589                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 590                         Assert.AreEqual ("      <xs:choice maxOccurs=\"unbounded\" minOccurs=\"0\">", substring, "test#05");
 591
 592                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 593                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 594                         Assert.AreEqual ("        <xs:element name=\"Region\">", substring, "test#06");
 595
 596                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 597                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 598                         Assert.AreEqual ("          <xs:complexType>", substring, "test#07");
 599
 600                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 601                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 602                         Assert.AreEqual ("            <xs:sequence>", substring, "test#08");
 603
 604                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 605                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 606                         // This is original DataSet.WriteXmlSchema() output
 607 //                      Assert.AreEqual ("              <xs:element name=\"RegionID\" type=\"xs:string\" minOccurs=\"0\" />", substring, "test#09");
 608                         Assert.AreEqual ("              <xs:element minOccurs=\"0\" name=\"RegionID\" type=\"xs:string\" />", substring, "test#09");
 609
 610                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 611                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 612                         // This is original DataSet.WriteXmlSchema() output
 613 //                      Assert.AreEqual ("              <xs:element name=\"RegionDescription\" type=\"xs:string\" minOccurs=\"0\" />", substring, "test#10");
 614                         Assert.AreEqual ("              <xs:element minOccurs=\"0\" name=\"RegionDescription\" type=\"xs:string\" />", substring, "test#10");
 615
 616                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 617                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 618                         Assert.AreEqual ("            </xs:sequence>", substring, "test#11");
 619
 620                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 621                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 622                         Assert.AreEqual ("          </xs:complexType>", substring, "test#12");
 623
 624                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 625                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 626                         Assert.AreEqual ("        </xs:element>", substring, "test#13");
 627
 628                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 629                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 630                         Assert.AreEqual ("      </xs:choice>", substring, "test#14");
 631
 632                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 633                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 634                         Assert.AreEqual ("    </xs:complexType>", substring, "test#15");
 635
 636                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 637                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 638                         Assert.AreEqual ("  </xs:element>", substring, "test#16");
 639
 640                         Assert.AreEqual ("</xs:schema>", TextString, "test#17");
 641                 }
 642
 643                 [Test]
 644                 [Ignore ("MS behavior is far from consistent to be regarded as a reference implementation.")]
 645                 // MS ReadXmlSchema() is too inconsistent to regard as a
 646                 // reference implementation. To find the reason why, try to
 647                 // read store2.xsd and store4.xsd, write and compare for each
 648                 // DataSet property.
 649                 public void ReadWriteXmlSchemaIgnoreSchema ()
 650                 {
 651                         DataSet ds = new DataSet ();
 652                         ds.ReadXmlSchema ("Test/System.Data/store.xsd");
 653                         AssertDataSet ("read DataSet", ds, "NewDataSet", 3, 2);
 654                         AssertDataTable ("read bookstore table", ds.Tables [0], "bookstore", 1, 0, 0, 1, 1, 1);
 655                         AssertDataTable ("read book table", ds.Tables [1], "book", 5, 0, 1, 1, 2, 1);
 656                         ds.ReadXml ("Test/System.Data/region.xml", XmlReadMode.IgnoreSchema);
 657                         TextWriter writer = new StringWriter ();
 658
 659                         ds.WriteXmlSchema (writer);
 660                         string TextString = GetNormalizedSchema (writer.ToString ());
 661 //                      string TextString = writer.ToString ();
 662
 663
 664                         string substring = TextString.Substring (0, TextString.IndexOf(EOL));
 665                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 666                         Assert.AreEqual ("<?xml version=\"1.0\" encoding=\"utf-16\"?>", substring, "test#01");
 667
 668                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 669                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 670                         // This is original DataSet.WriteXmlSchema() output
 671 //                      Assert.AreEqual ("<xs:schema id=\"NewDataSet\" xmlns=\"\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\">", substring, "test#02");
 672                         Assert.AreEqual ("<xs:schema id=\"NewDataSet\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">", substring, "test#02");
 673
 674                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 675                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 676                         Assert.AreEqual ("  <xs:complexType name=\"bookstoreType\">", substring, "test#03");
 677
 678                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 679                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 680                         Assert.AreEqual ("    <xs:sequence>", substring, "test#04");
 681
 682                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 683                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 684                         // This is original DataSet.WriteXmlSchema() output
 685 //                      Assert.AreEqual ("      <xs:element name=\"book\" type=\"bookType\" minOccurs=\"0\" maxOccurs=\"unbounded\" />", substring, "test#05");
 686                         Assert.AreEqual ("      <xs:element maxOccurs=\"unbounded\" minOccurs=\"0\" name=\"book\" type=\"bookType\" />", substring, "test#05");
 687
 688                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 689                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 690                         Assert.AreEqual ("    </xs:sequence>", substring, "test#06");
 691
 692                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 693                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 694                         Assert.AreEqual ("  </xs:complexType>", substring, "test#07");
 695
 696                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 697                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 698                         Assert.AreEqual ("  <xs:complexType name=\"bookType\">", substring, "test#08");
 699
 700                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 701                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 702                         Assert.AreEqual ("    <xs:sequence>", substring, "test#09");
 703
 704                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 705                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 706                         // This is original DataSet.WriteXmlSchema() output
 707 //                      Assert.AreEqual ("      <xs:element name=\"title\" type=\"xs:string\" msdata:Ordinal=\"1\" />", substring, "test#10");
 708
 709                         Assert.AreEqual ("      <xs:element msdata:Ordinal=\"1\" name=\"title\" type=\"xs:string\" />", substring, "test#10");
 710
 711                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 712                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 713                         // This is original DataSet.WriteXmlSchema() output
 714 //                      Assert.AreEqual ("      <xs:element name=\"price\" type=\"xs:decimal\" msdata:Ordinal=\"2\" />", substring, "test#11");
 715                         Assert.AreEqual ("      <xs:element msdata:Ordinal=\"2\" name=\"price\" type=\"xs:decimal\" />", substring, "test#11");
 716
 717                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 718                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 719                         // This is original DataSet.WriteXmlSchema() output
 720 //                      Assert.AreEqual ("      <xs:element name=\"author\" type=\"authorName\" minOccurs=\"0\" maxOccurs=\"unbounded\" />", substring, "test#12");
 721                         Assert.AreEqual ("      <xs:element maxOccurs=\"unbounded\" minOccurs=\"0\" name=\"author\" type=\"authorName\" />", substring, "test#12");
 722
 723                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 724                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 725                         Assert.AreEqual ("    </xs:sequence>", substring, "test#13");
 726
 727                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 728                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 729                         Assert.AreEqual ("    <xs:attribute name=\"genre\" type=\"xs:string\" />", substring, "test#14");
 730
 731                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 732                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 733                         Assert.AreEqual ("  </xs:complexType>", substring, "test#15");
 734
 735                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 736                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 737                         Assert.AreEqual ("  <xs:complexType name=\"authorName\">", substring, "test#16");
 738
 739                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 740                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 741                         Assert.AreEqual ("    <xs:sequence>", substring, "test#17");
 742
 743                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 744                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 745                         Assert.AreEqual ("      <xs:element name=\"first-name\" type=\"xs:string\" />", substring, "test#18");
 746
 747                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 748                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 749                         Assert.AreEqual ("      <xs:element name=\"last-name\" type=\"xs:string\" />", substring, "test#19");
 750
 751                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 752                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 753                         Assert.AreEqual ("    </xs:sequence>", substring, "test#20");
 754
 755                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 756                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 757                         Assert.AreEqual ("  </xs:complexType>", substring, "test#21");
 758
 759                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 760                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 761                         Assert.AreEqual ("  <xs:element name=\"bookstore\" type=\"bookstoreType\" />", substring, "test#22");
 762
 763                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 764                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 765                         // This is original DataSet.WriteXmlSchema() output
 766 //                      Assert.AreEqual ("  <xs:element name=\"NewDataSet\" msdata:IsDataSet=\"true\" msdata:Locale=\"fi-FI\">", substring, "test#23");
 767                         Assert.AreEqual ("  <xs:element msdata:IsDataSet=\"true\" msdata:Locale=\"fi-FI\" name=\"NewDataSet\">", substring, "test#23");
 768
 769                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 770                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 771                         Assert.AreEqual ("    <xs:complexType>", substring, "test#24");
 772
 773                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 774                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 775                         Assert.AreEqual ("      <xs:choice maxOccurs=\"unbounded\" minOccurs=\"0\">", substring, "test#25");
 776
 777                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 778                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 779                         Assert.AreEqual ("        <xs:element ref=\"bookstore\" />", substring, "test#26");
 780
 781                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 782                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 783                         Assert.AreEqual ("      </xs:choice>", substring, "test#27");
 784
 785                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 786                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 787                         Assert.AreEqual ("    </xs:complexType>", substring, "test#28");
 788
 789                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 790                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 791                         Assert.AreEqual ("  </xs:element>", substring, "test#29");
 792
 793                         Assert.AreEqual ("</xs:schema>", TextString, "test#30");
 794                 }
 795
 796                 [Test]
 797                 [Ignore ("MS behavior is far from consistent to be regarded as a reference implementation.")]
 798                 // See comments on ReadWriteXmlSchemaIgnoreSchema().
 799                 public void ReadWriteXmlSchema ()
 800                 {
 801                         DataSet ds = new DataSet ();
 802                         ds.ReadXmlSchema ("Test/System.Data/store.xsd");
 803                         // check dataset properties before testing write
 804                         AssertDataSet ("ds", ds, "NewDataSet", 3, 2);
 805                         AssertDataTable ("tab1", ds.Tables [0], "bookstore", 1, 0, 0, 1, 1, 1);
 806                         AssertDataTable ("tab2", ds.Tables [1], "book", 5, 0, 1, 1, 2, 1);
 807                         AssertDataTable ("tab3", ds.Tables [2], "author", 3, 0, 1, 0, 1, 0);
 808                         // FIXME: currently order is not compatible. Use name as index
 809                         AssertDataRelation ("rel1", ds.Relations ["book_author"], "book_author", true, new string [] {"book_Id"}, new string [] {"book_Id"}, true, true);
 810                         AssertDataRelation ("rel2", ds.Relations ["bookstore_book"], "bookstore_book", true, new string [] {"bookstore_Id"}, new string [] {"bookstore_Id"}, true, true);
 811
 812                         ds.ReadXml ("Test/System.Data/region.xml", XmlReadMode.InferSchema);
 813
 814                         TextWriter writer = new StringWriter ();
 815                         ds.WriteXmlSchema (writer);
 816
 817                         string TextString = GetNormalizedSchema (writer.ToString ());
 818 //                      string TextString = writer.ToString ();
 819
 820                         string substring = TextString.Substring (0, TextString.IndexOf(EOL));
 821                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 822                         Assert.AreEqual ("<?xml version=\"1.0\" encoding=\"utf-16\"?>", substring, "test#01");
 823
 824                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 825                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 826                         // This is original DataSet.WriteXmlSchema() output
 827 //                      Assert.AreEqual ("<xs:schema id=\"Root\" xmlns=\"\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\">", substring, "test#02");
 828                         Assert.AreEqual ("<xs:schema id=\"Root\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">", substring, "test#02");
 829
 830                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 831                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 832                         Assert.AreEqual ("  <xs:complexType name=\"bookstoreType\">", substring, "test#03");
 833
 834                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 835                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 836                         Assert.AreEqual ("    <xs:sequence>", substring, "test#04");
 837
 838                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 839                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 840                         // This is original DataSet.WriteXmlSchema() output
 841 //                      Assert.AreEqual ("      <xs:element name=\"book\" type=\"bookType\" minOccurs=\"0\" maxOccurs=\"unbounded\" />", substring, "test#05");
 842                         Assert.AreEqual ("      <xs:element maxOccurs=\"unbounded\" minOccurs=\"0\" name=\"book\" type=\"bookType\" />", substring, "test#05");
 843
 844                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 845                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 846                         Assert.AreEqual ("    </xs:sequence>", substring, "test#06");
 847
 848                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 849                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 850                         Assert.AreEqual ("  </xs:complexType>", substring, "test#07");
 851
 852                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 853                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 854                         Assert.AreEqual ("  <xs:complexType name=\"bookType\">", substring, "test#08");
 855
 856                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 857                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 858                         Assert.AreEqual ("    <xs:sequence>", substring, "test#09");
 859
 860                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 861                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 862                         // This is original DataSet.WriteXmlSchema() output
 863 //                      Assert.AreEqual ("      <xs:element name=\"title\" type=\"xs:string\" msdata:Ordinal=\"1\" />", substring, "test#10");
 864                         Assert.AreEqual ("      <xs:element msdata:Ordinal=\"1\" name=\"title\" type=\"xs:string\" />", substring, "test#10");
 865
 866                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 867                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 868                         // This is original DataSet.WriteXmlSchema() output
 869 //                      Assert.AreEqual ("      <xs:element name=\"price\" type=\"xs:decimal\" msdata:Ordinal=\"2\" />", substring, "test#11");
 870                         Assert.AreEqual ("      <xs:element msdata:Ordinal=\"2\" name=\"price\" type=\"xs:decimal\" />", substring, "test#11");
 871
 872                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 873                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 874                         // This is original DataSet.WriteXmlSchema() output
 875 //                      Assert.AreEqual ("      <xs:element name=\"author\" type=\"authorName\" minOccurs=\"0\" maxOccurs=\"unbounded\" />", substring, "test#12");
 876                         Assert.AreEqual ("      <xs:element maxOccurs=\"unbounded\" minOccurs=\"0\" name=\"author\" type=\"authorName\" />", substring, "test#12");
 877
 878                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 879                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 880                         Assert.AreEqual ("    </xs:sequence>", substring, "test#13");
 881
 882                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 883                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 884                         Assert.AreEqual ("    <xs:attribute name=\"genre\" type=\"xs:string\" />", substring, "test#14");
 885
 886                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 887                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 888                         Assert.AreEqual ("  </xs:complexType>", substring, "test#15");
 889
 890                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 891                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 892                         Assert.AreEqual ("  <xs:complexType name=\"authorName\">", substring, "test#16");
 893
 894                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 895                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 896                         Assert.AreEqual ("    <xs:sequence>", substring, "test#17");
 897
 898                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 899                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 900                         Assert.AreEqual ("      <xs:element name=\"first-name\" type=\"xs:string\" />", substring, "test#18");
 901
 902                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 903                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 904                         Assert.AreEqual ("      <xs:element name=\"last-name\" type=\"xs:string\" />", substring, "test#19");
 905
 906                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 907                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 908                         Assert.AreEqual ("    </xs:sequence>", substring, "test#20");
 909
 910                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 911                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 912                         Assert.AreEqual ("  </xs:complexType>", substring, "test#21");
 913
 914                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 915                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 916                         Assert.AreEqual ("  <xs:element name=\"bookstore\" type=\"bookstoreType\" />", substring, "test#22");
 917
 918                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 919                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 920                         // This is original DataSet.WriteXmlSchema() output
 921 //                      Assert.AreEqual ("  <xs:element name=\"Root\" msdata:IsDataSet=\"true\" msdata:Locale=\"fi-FI\">", substring, "test#23");
 922                         Assert.AreEqual ("  <xs:element msdata:IsDataSet=\"true\" msdata:Locale=\"fi-FI\" name=\"Root\">", substring, "test#23");
 923
 924                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 925                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 926                         Assert.AreEqual ("    <xs:complexType>", substring, "test#24");
 927
 928                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 929                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 930                         Assert.AreEqual ("      <xs:choice maxOccurs=\"unbounded\" minOccurs=\"0\">", substring, "test#25");
 931
 932                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 933                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 934                         Assert.AreEqual ("        <xs:element ref=\"bookstore\" />", substring, "test#26");
 935
 936                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 937                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 938                         Assert.AreEqual ("        <xs:element name=\"Region\">", substring, "test#27");
 939
 940                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 941                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 942                         Assert.AreEqual ("          <xs:complexType>", substring, "test#28");
 943
 944                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 945                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 946                         Assert.AreEqual ("            <xs:sequence>", substring, "test#29");
 947
 948                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 949                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 950                         // This is original DataSet.WriteXmlSchema() output
 951 //                      Assert.AreEqual ("              <xs:element name=\"RegionID\" type=\"xs:string\" minOccurs=\"0\" />", substring, "test#30");
 952                         Assert.AreEqual ("              <xs:element minOccurs=\"0\" name=\"RegionID\" type=\"xs:string\" />", substring, "test#30");
 953
 954                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 955                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 956                         // This is original DataSet.WriteXmlSchema() output
 957 //                      Assert.AreEqual ("              <xs:element name=\"RegionDescription\" type=\"xs:string\" minOccurs=\"0\" />", substring, "test#31");
 958                         Assert.AreEqual ("              <xs:element minOccurs=\"0\" name=\"RegionDescription\" type=\"xs:string\" />", substring, "test#31");
 959
 960                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 961                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 962                         Assert.AreEqual ("            </xs:sequence>", substring, "test#32");
 963
 964                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 965                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 966                         Assert.AreEqual ("          </xs:complexType>", substring, "test#33");
 967
 968                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 969                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 970                         Assert.AreEqual ("        </xs:element>", substring, "test#34");
 971
 972                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 973                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 974                         Assert.AreEqual ("      </xs:choice>", substring, "test#35");
 975
 976                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 977                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 978                         Assert.AreEqual ("    </xs:complexType>", substring, "test#36");
 979
 980                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
 981                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
 982                         Assert.AreEqual ("  </xs:element>", substring, "test#37");
 983
 984                         Assert.AreEqual ("</xs:schema>", TextString, "test#38");
 985                 }
 986
 987                 [Test]
 988                 [Category ("NotWorking")]
 989                 public void WriteDifferentNamespaceSchema ()
 990                 {
 991                         string schema = @"<?xml version='1.0' encoding='utf-16'?>
 992 <xs:schema id='NewDataSet' targetNamespace='urn:bar' xmlns:mstns='urn:bar' xmlns='urn:bar' xmlns:xs='http://www.w3.org/2001/XMLSchema' xmlns:msdata='urn:schemas-microsoft-com:xml-msdata' attributeFormDefault='qualified' elementFormDefault='qualified' xmlns:app1='urn:baz' xmlns:app2='urn:foo'>
 993   <!--ATTENTION: This schema contains references to other imported schemas-->
 994   <xs:import namespace='urn:baz' schemaLocation='_app1.xsd' />
 995   <xs:import namespace='urn:foo' schemaLocation='_app2.xsd' />
 996   <xs:element name='NewDataSet' msdata:IsDataSet='true' msdata:Locale='fi-FI'>
 997     <xs:complexType>
 998       <xs:choice minOccurs='0' maxOccurs='unbounded'>
 999         <xs:element ref='app2:NS1Table' />
1000         <xs:element name='NS2Table'>
1001           <xs:complexType>
1002           </xs:complexType>
1003         </xs:element>
1004       </xs:choice>
1005     </xs:complexType>
1006   </xs:element>
1007 </xs:schema>";
1008                         DataSet ds = new DataSet();
1009                         DataTable dt = new DataTable ();
1010                         dt.TableName = "NS1Table";
1011                         dt.Namespace = "urn:foo";
1012                         dt.Columns.Add ("column1");
1013                         dt.Columns.Add ("column2");
1014                         dt.Columns [1].Namespace = "urn:baz";
1015                         ds.Tables.Add (dt);
1016                         DataTable dt2 = new DataTable ();
1017                         dt2.TableName = "NS2Table";
1018                         dt2.Namespace = "urn:bar";
1019                         ds.Tables.Add (dt2);
1020                         ds.Namespace = "urn:bar";
1021                         StringWriter sw = new StringWriter ();
1022                         XmlTextWriter xw = new XmlTextWriter (sw);
1023                         xw.Formatting = Formatting.Indented;
1024                         xw.QuoteChar = '\'';
1025                         ds.WriteXmlSchema (xw);
1026
1027                         string result = sw.ToString ();
1028                         Assert.AreEqual (result.Replace ("\r\n", "\n"), schema.Replace ("\r\n", "\n"));
1029                 }
1030
1031                 [Test]
1032                 public void IgnoreColumnEmptyNamespace ()
1033                 {
1034                         DataColumn col = new DataColumn ("TEST");
1035                         col.Namespace = "urn:foo";
1036                         DataSet ds = new DataSet ("DS");
1037                         ds.Namespace = "urn:foo";
1038                         DataTable dt = new DataTable ("tab");
1039                         ds.Tables.Add (dt);
1040                         dt.Columns.Add (col);
1041                         dt.Rows.Add (new object [] {"test"});
1042                         StringWriter sw = new StringWriter ();
1043                         ds.WriteXml (new XmlTextWriter (sw));
1044                         string xml = @"<DS xmlns=""urn:foo""><tab><TEST>test</TEST></tab></DS>";
1045                         Assert.AreEqual (xml, sw.ToString ());
1046                 }
1047
1048                 [Test]
1049                 public void SerializeDataSet ()
1050                 {
1051                         // see GetReady() for current culture
1052
1053                         string xml = "<?xml version='1.0' encoding='utf-16'?><DataSet><xs:schema id='DS' xmlns='' xmlns:xs='http://www.w3.org/2001/XMLSchema' xmlns:msdata='urn:schemas-microsoft-com:xml-msdata'><xs:element name='DS' msdata:IsDataSet='true' " +
1054 #if !NET_2_0
1055                           "msdata:Locale='fi-FI'"
1056 #else
1057                           "msdata:UseCurrentLocale='true'"
1058 #endif
1059                           + "><xs:complexType><xs:choice minOccurs='0' maxOccurs='unbounded' /></xs:complexType></xs:element></xs:schema><diffgr:diffgram xmlns:msdata='urn:schemas-microsoft-com:xml-msdata' xmlns:diffgr='urn:schemas-microsoft-com:xml-diffgram-v1' /></DataSet>";
1060                         DataSet ds = new DataSet ();
1061                         ds.DataSetName = "DS";
1062                         XmlSerializer ser = new XmlSerializer (typeof (DataSet));
1063                         StringWriter sw = new StringWriter ();
1064                         XmlTextWriter xw = new XmlTextWriter (sw);
1065                         xw.QuoteChar = '\'';
1066                         ser.Serialize (xw, ds);
1067
1068                         string result = sw.ToString ();
1069                         Assert.AreEqual (result.Replace ("\r\n", "\n"), xml.Replace ("\r\n", "\n"));
1070                 }
1071
1072                 // bug #70961
1073                 [Test]
1074                 public void SerializeDataSet2 ()
1075                 {
1076                         DataSet quota = new DataSet ("Quota");
1077
1078                         // Dimension
1079                         DataTable dt = new DataTable ("Dimension");
1080                         quota.Tables.Add (dt);
1081
1082                         dt.Columns.Add ("Number", typeof(int));
1083                         dt.Columns ["Number"].AllowDBNull = false;
1084                         dt.Columns ["Number"].ColumnMapping = MappingType.Attribute;
1085
1086                         dt.Columns.Add ("Title", typeof(string));
1087                         dt.Columns ["Title"].AllowDBNull = false;
1088                         dt.Columns ["Title"].ColumnMapping =
1089                         MappingType.Attribute;
1090
1091                         dt.Rows.Add (new object [] {0, "Hospitals"});
1092                         dt.Rows.Add (new object [] {1, "Doctors"});
1093
1094                         dt.Constraints.Add ("PK_Dimension", dt.Columns ["Number"], true);
1095
1096                         quota.AcceptChanges ();
1097
1098                         XmlSerializer ser = new XmlSerializer (quota.GetType ());
1099
1100                         StringWriter sw = new StringWriter ();
1101                         ser.Serialize (sw, quota);
1102
1103                         DataSet ds = (DataSet) ser.Deserialize (new StringReader (sw.ToString ()));
1104                 }
1105
1106                 // bug #68007
1107                 public void SerializeDataSet3 ()
1108                 {
1109                         string xml = @"<?xml version=""1.0"" encoding=""utf-8""?><DataSet><xs:schema id=""Example"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata""><xs:element name=""Example"" msdata:IsDataSet=""true""><xs:complexType><xs:choice maxOccurs=""unbounded"" minOccurs=""0""><xs:element name=""Packages""><xs:complexType><xs:attribute name=""ID"" type=""xs:int"" use=""required"" /><xs:attribute name=""ShipDate"" type=""xs:dateTime"" /><xs:attribute name=""Message"" type=""xs:string"" /><xs:attribute name=""Handlers"" type=""xs:int"" /></xs:complexType></xs:element></xs:choice></xs:complexType></xs:element></xs:schema><diffgr:diffgram xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"" xmlns:diffgr=""urn:schemas-microsoft-com:xml-diffgram-v1""><Example><Packages diffgr:id=""Packages1"" msdata:rowOrder=""0"" ID=""0"" ShipDate=""2004-10-11T17:46:18.6962302-05:00"" Message=""Received with no breakage!"" Handlers=""3"" /><Packages diffgr:id=""Packages2"" msdata:rowOrder=""1"" ID=""1"" /></Example></diffgr:diffgram></DataSet>";
1110
1111                         DataSet ds = new DataSet ("Example");
1112
1113                         // Add a DataTable
1114                         DataTable dt = new DataTable ("Packages");
1115                         ds.Tables.Add (dt);
1116
1117                         // Add an ID DataColumn w/ ColumnMapping = MappingType.Attribute
1118                         dt.Columns.Add (new DataColumn ("ID", typeof(int), "",
1119                                 MappingType.Attribute));
1120                         dt.Columns ["ID"].AllowDBNull = false;
1121
1122                         // Add a nullable DataColumn w/ ColumnMapping = MappingType.Attribute
1123                         dt.Columns.Add (new DataColumn ("ShipDate",
1124                                 typeof (DateTime), "", MappingType.Attribute));
1125                         dt.Columns ["ShipDate"].AllowDBNull = true;
1126
1127                         // Add a nullable DataColumn w/ ColumnMapping = MappingType.Attribute
1128                         dt.Columns.Add (new DataColumn ("Message",
1129                                 typeof (string), "", MappingType.Attribute));
1130                         dt.Columns ["Message"].AllowDBNull = true;
1131
1132                         // Add a nullable DataColumn w/ ColumnMapping = MappingType.Attribute
1133                         dt.Columns.Add (new DataColumn ("Handlers",
1134                                 typeof (int), "", MappingType.Attribute));
1135                         dt.Columns ["Handlers"].AllowDBNull = true;
1136
1137                         // Add a non-null value row
1138                         DataRow newRow = dt.NewRow();
1139                         newRow ["ID"] = 0;
1140                         newRow ["ShipDate"] = DateTime.Now;
1141                         newRow ["Message"] = "Received with no breakage!";
1142                         newRow ["Handlers"] = 3;
1143                         dt.Rows.Add (newRow);
1144
1145                         // Add a null value row
1146                         newRow = dt.NewRow ();
1147                         newRow ["ID"] = 1;
1148                         newRow ["ShipDate"] = DBNull.Value;
1149                         newRow ["Message"] = DBNull.Value;
1150                         newRow ["Handlers"] = DBNull.Value;
1151                         dt.Rows.Add (newRow);
1152
1153                         ds.AcceptChanges ();
1154
1155                         XmlSerializer ser = new XmlSerializer (ds.GetType());
1156                         StringWriter sw = new StringWriter ();
1157                         ser.Serialize (sw, ds);
1158
1159                         string result = sw.ToString ();
1160
1161                         Assert.AreEqual (xml, result);
1162                 }
1163
1164                 [Test]
1165                 public void DeserializeDataSet ()
1166                 {
1167                         string xml = @"<DataSet>
1168   <diffgr:diffgram xmlns:msdata='urn:schemas-microsoft-com:xml-msdata' xmlns:diffgr='urn:schemas-microsoft-com:xml-diffgram-v1'>
1169     <Quota>
1170       <Dimension diffgr:id='Dimension1' msdata:rowOrder='0' Number='0' Title='Hospitals' />
1171       <Dimension diffgr:id='Dimension2' msdata:rowOrder='1' Number='1' Title='Doctors' />
1172     </Quota>
1173   </diffgr:diffgram>
1174 </DataSet>";
1175                         XmlSerializer ser = new XmlSerializer (typeof (DataSet));
1176                         ser.Deserialize (new XmlTextReader (
1177                                 xml, XmlNodeType.Document, null));
1178                 }
1179
1180                 /* To be added
1181                 [Test]
1182                 public void WriteDiffReadAutoWriteSchema ()
1183                 {
1184                         DataSet ds = new DataSet ();
1185                         ds.Tables.Add ("Table1");
1186                         ds.Tables.Add ("Table2");
1187                         ds.Tables [0].Columns.Add ("Column1_1");
1188                         ds.Tables [0].Columns.Add ("Column1_2");
1189                         ds.Tables [0].Columns.Add ("Column1_3");
1190                         ds.Tables [1].Columns.Add ("Column2_1");
1191                         ds.Tables [1].Columns.Add ("Column2_2");
1192                         ds.Tables [1].Columns.Add ("Column2_3");
1193                         ds.Tables [0].Rows.Add (new object [] {"ppp", "www", "xxx"});
1194
1195                         // save as diffgram
1196                         StringWriter sw = new StringWriter ();
1197                         ds.WriteXml (sw, XmlWriteMode.DiffGram);
1198                         string xml = sw.ToString ();
1199                         string result = new StreamReader ("Test/System.Data/DataSetReadXmlTest1.xml", Encoding.ASCII).ReadToEnd ();
1200                         Assert.AreEqual (result, xml, "#01");
1201
1202                         // load diffgram above
1203                         ds.ReadXml (new StringReader (sw.ToString ()));
1204                         sw = new StringWriter ();
1205                         ds.WriteXml (sw, XmlWriteMode.WriteSchema);
1206                         xml = sw.ToString ();
1207                         result = new StreamReader ("Test/System.Data/DataSetReadXmlTest2.xml", Encoding.ASCII).ReadToEnd ();
1208                         Assert.AreEqual (result, xml, "#02");
1209                 }
1210                 */
1211
1212                 [Test]
1213                 public void CloneCopy ()
1214                 {
1215                         DataTable table = new DataTable ("pTable");
1216                         DataTable table1 = new DataTable ("cTable");
1217                         DataSet set = new DataSet ();
1218
1219                         set.Tables.Add (table);
1220                         set.Tables.Add (table1);
1221
1222                         DataColumn col = new DataColumn ();
1223                         col.ColumnName = "Id";
1224                         col.DataType = Type.GetType ("System.Int32");
1225                         table.Columns.Add (col);
1226                         UniqueConstraint uc = new UniqueConstraint ("UK1", table.Columns[0] );
1227                         table.Constraints.Add (uc);
1228
1229                         col = new DataColumn ();
1230                         col.ColumnName = "Name";
1231                         col.DataType = Type.GetType ("System.String");
1232                         table.Columns.Add (col);
1233
1234                         col = new DataColumn ();
1235                         col.ColumnName = "Id";
1236                         col.DataType = Type.GetType ("System.Int32");
1237                         table1.Columns.Add (col);
1238
1239                         col = new DataColumn ();
1240                         col.ColumnName = "Name";
1241                         col.DataType = Type.GetType ("System.String");
1242                         table1.Columns.Add (col);
1243                           ForeignKeyConstraint fc = new ForeignKeyConstraint ("FK1", table.Columns[0], table1.Columns[0] );
1244                         table1.Constraints.Add (fc);
1245
1246
1247                         DataRow row = table.NewRow ();
1248
1249                         row ["Id"] = 147;
1250                         row ["name"] = "Row1";
1251                         row.RowError = "Error#1";
1252                         table.Rows.Add (row);
1253
1254                         // Set column to RO as commonly used by auto-increment fields.
1255                         // ds.Copy() has to omit the RO check when cloning DataRows
1256                         table.Columns["Id"].ReadOnly = true;
1257
1258                         row = table1.NewRow ();
1259                         row ["Id"] = 147;
1260                         row ["Name"] = "Row1";
1261                         table1.Rows.Add (row);
1262
1263                         //Setting properties of DataSet
1264                         set.CaseSensitive = true;
1265                         set.DataSetName = "My DataSet";
1266                         set.EnforceConstraints = false;
1267                         set.Namespace = "Namespace#1";
1268                         set.Prefix = "Prefix:1";
1269                         DataRelation dr = new DataRelation ("DR", table.Columns [0],table1.Columns [0]);
1270                         set.Relations.Add (dr);
1271                         set.ExtendedProperties.Add ("TimeStamp", DateTime.Now);
1272                         CultureInfo cultureInfo = new CultureInfo( "ar-SA" );
1273                         set.Locale = cultureInfo;
1274
1275                         //Testing Copy ()
1276                         DataSet copySet = set.Copy ();
1277                         Assert.AreEqual (set.CaseSensitive, copySet.CaseSensitive, "#A01");
1278                         Assert.AreEqual (set.DataSetName, copySet.DataSetName, "#A02");
1279                         Assert.AreEqual (set.EnforceConstraints, copySet.EnforceConstraints, "#A03");
1280                         Assert.AreEqual (set.HasErrors, copySet.HasErrors, "#A04");
1281                         Assert.AreEqual (set.Namespace, copySet.Namespace, "#A05");
1282                         Assert.AreEqual (set.Prefix, copySet.Prefix, "#A06");
1283                         Assert.AreEqual (set.Relations.Count, copySet.Relations.Count, "#A07");
1284                         Assert.AreEqual (set.Tables.Count, copySet.Tables.Count, "#A08");
1285                         Assert.AreEqual (set.ExtendedProperties ["TimeStamp"], copySet.ExtendedProperties ["TimeStamp"], "#A09");
1286                         for (int i = 0;i < copySet.Tables.Count; i++) {
1287                                 Assert.AreEqual (set.Tables [i].Rows.Count, copySet.Tables [i].Rows.Count, "#A10");
1288                                 Assert.AreEqual (set.Tables [i].Columns.Count, copySet.Tables [i].Columns.Count, "#A11");
1289                         }
1290                         //Testing Clone ()
1291                         copySet = set.Clone ();
1292                         Assert.AreEqual (set.CaseSensitive, copySet.CaseSensitive, "#A12");
1293                         Assert.AreEqual (set.DataSetName, copySet.DataSetName, "#A13");
1294                         Assert.AreEqual (set.EnforceConstraints, copySet.EnforceConstraints, "#A14");
1295                         Assert.IsFalse (copySet.HasErrors, "#A15");
1296                         Assert.AreEqual (set.Namespace, copySet.Namespace, "#A16");
1297                         Assert.AreEqual (set.Prefix, copySet.Prefix, "#A17");
1298                         Assert.AreEqual (set.Relations.Count, copySet.Relations.Count, "#A18");
1299                         Assert.AreEqual (set.Tables.Count, copySet.Tables.Count, "#A19");
1300                         Assert.AreEqual (set.ExtendedProperties ["TimeStamp"], copySet.ExtendedProperties ["TimeStamp"], "#A20");
1301                         for (int i = 0;i < copySet.Tables.Count; i++) {
1302                                 Assert.AreEqual (0, copySet.Tables [i].Rows.Count, "#A21");
1303                                 Assert.AreEqual (set.Tables [i].Columns.Count, copySet.Tables [i].Columns.Count, "#A22");
1304                         }
1305                 }
1306
1307                 [Test]
1308                 public void CloneCopy2 ()
1309                 {
1310                         DataSet ds = new DataSet ();
1311                         ds.ReadXmlSchema ("Test/System.Data/store.xsd");
1312                         ds.Clone ();
1313                 }
1314
1315                 [Test]
1316                 public void CloneCopy_TestForeignKeyConstraints ()
1317                 {
1318                         DataTable dirTable = new DataTable("Directories");
1319
1320                         DataColumn dir_UID = new DataColumn("UID", typeof(int));
1321                         dir_UID.Unique = true;
1322                         dir_UID.AllowDBNull = false;
1323
1324                         dirTable.Columns.Add(dir_UID);
1325
1326                         // Build a simple Files table
1327                         DataTable fileTable = new DataTable("Files");
1328
1329                         DataColumn file_DirID = new DataColumn("DirectoryID", typeof(int));
1330                         file_DirID.Unique = false;
1331                         file_DirID.AllowDBNull = false;
1332
1333                         fileTable.Columns.Add(file_DirID);
1334
1335                         // Build the DataSet
1336                         DataSet ds = new DataSet("TestDataset");
1337                         ds.Tables.Add(dirTable);
1338                         ds.Tables.Add(fileTable);
1339
1340                         // Add a foreign key constraint
1341                         DataColumn[] parentColumns = new DataColumn[1];
1342                         parentColumns[0] = ds.Tables["Directories"].Columns["UID"];
1343
1344                         DataColumn[] childColumns = new DataColumn[1];
1345                         childColumns[0] = ds.Tables["Files"].Columns["DirectoryID"];
1346
1347                         ForeignKeyConstraint fk = new ForeignKeyConstraint("FK_Test", parentColumns, childColumns);
1348                         ds.Tables["Files"].Constraints.Add(fk);
1349                         ds.EnforceConstraints = true;
1350
1351                         Assert.AreEqual (1, ds.Tables["Directories"].Constraints.Count, "#1");
1352                         Assert.AreEqual (1, ds.Tables["Files"].Constraints.Count, "#2");
1353
1354                         // check clone works fine
1355                         DataSet cloned_ds = ds.Clone ();
1356                         Assert.AreEqual (1, cloned_ds.Tables["Directories"].Constraints.Count, "#3");
1357                         Assert.AreEqual (1, cloned_ds.Tables["Files"].Constraints.Count, "#4");
1358
1359                         ForeignKeyConstraint clonedFk =  (ForeignKeyConstraint)cloned_ds.Tables["Files"].Constraints[0];
1360                         Assert.AreEqual ("FK_Test", clonedFk.ConstraintName, "#5");
1361                         Assert.AreEqual (1, clonedFk.Columns.Length, "#6");
1362                         Assert.AreEqual ("DirectoryID", clonedFk.Columns[0].ColumnName, "#7");
1363
1364                         UniqueConstraint clonedUc = (UniqueConstraint)cloned_ds.Tables ["Directories"].Constraints[0];
1365                         UniqueConstraint origUc = (UniqueConstraint)ds.Tables ["Directories"].Constraints[0];
1366                         Assert.AreEqual (origUc.ConstraintName, clonedUc.ConstraintName, "#8");
1367                         Assert.AreEqual (1, clonedUc.Columns.Length, "#9");
1368                         Assert.AreEqual ("UID", clonedUc.Columns[0].ColumnName, "#10");
1369
1370                         // check copy works fine
1371                         DataSet copy_ds = ds.Copy ();
1372                         Assert.AreEqual (1, copy_ds.Tables["Directories"].Constraints.Count, "#11");
1373                         Assert.AreEqual (1, copy_ds.Tables["Files"].Constraints.Count, "#12");
1374
1375                         ForeignKeyConstraint copyFk =  (ForeignKeyConstraint)copy_ds.Tables["Files"].Constraints[0];
1376                         Assert.AreEqual ("FK_Test", copyFk.ConstraintName, "#13");
1377                         Assert.AreEqual (1, copyFk.Columns.Length, "#14");
1378                         Assert.AreEqual ("DirectoryID", copyFk.Columns[0].ColumnName, "#15");
1379
1380                         UniqueConstraint copyUc = (UniqueConstraint)copy_ds.Tables ["Directories"].Constraints[0];
1381                         origUc = (UniqueConstraint)ds.Tables ["Directories"].Constraints[0];
1382                         Assert.AreEqual (origUc.ConstraintName, copyUc.ConstraintName, "#16");
1383                         Assert.AreEqual (1, copyUc.Columns.Length, "#17");
1384                         Assert.AreEqual ("UID", copyUc.Columns[0].ColumnName, "#18");
1385                 }
1386
1387                 [Test]
1388                 public void WriteNestedTableXml ()
1389                 {
1390                         string xml = @"<NewDataSet>
1391   <tab1>
1392     <ident>1</ident>
1393     <name>hoge</name>
1394     <tab2>
1395       <timestamp>2004-05-05</timestamp>
1396     </tab2>
1397   </tab1>
1398   <tab1>
1399     <ident>2</ident>
1400     <name>fuga</name>
1401     <tab2>
1402       <timestamp>2004-05-06</timestamp>
1403     </tab2>
1404   </tab1>
1405 </NewDataSet>";
1406                         DataSet ds = new DataSet ();
1407                         DataTable dt = new DataTable ("tab1");
1408                         dt.Columns.Add ("ident");
1409                         dt.Columns.Add ("name");
1410                         dt.Rows.Add (new object [] {"1", "hoge"});
1411                         dt.Rows.Add (new object [] {"2", "fuga"});
1412                         DataTable dt2 = new DataTable ("tab2");
1413                         dt2.Columns.Add ("idref");
1414                         dt2.Columns [0].ColumnMapping = MappingType.Hidden;
1415                         dt2.Columns.Add ("timestamp");
1416                         dt2.Rows.Add (new object [] {"1", "2004-05-05"});
1417                         dt2.Rows.Add (new object [] {"2", "2004-05-06"});
1418                         ds.Tables.Add (dt);
1419                         ds.Tables.Add (dt2);
1420                         DataRelation rel = new DataRelation ("rel", dt.Columns [0], dt2.Columns [0]);
1421                         rel.Nested = true;
1422                         ds.Relations.Add (rel);
1423                         StringWriter sw = new StringWriter ();
1424                         ds.WriteXml (sw);
1425                         Assert.AreEqual (sw.ToString ().Replace ("\r\n", "\n"), xml.Replace ("\r\n", "\n"));
1426                 }
1427
1428                 [Test]
1429                 public void WriteXmlToStream ()
1430                 {
1431                         string xml = "<set><table1><col1>sample text</col1><col2/></table1><table2 attr='value'><col3>sample text 2</col3></table2></set>";
1432                         DataSet ds = new DataSet ();
1433                         ds.ReadXml (new StringReader (xml));
1434                         MemoryStream ms = new MemoryStream ();
1435                         ds.WriteXml (ms);
1436                         MemoryStream ms2 = new MemoryStream (ms.ToArray ());
1437                         StreamReader sr = new StreamReader (ms2, Encoding.UTF8);
1438                         string result = @"<set>
1439   <table1>
1440     <col1>sample text</col1>
1441     <col2 />
1442   </table1>
1443   <table2 attr=""value"">
1444     <col3>sample text 2</col3>
1445   </table2>
1446 </set>";
1447                         Assert.AreEqual (sr.ReadToEnd ().Replace ("\r\n", "\n"), result.Replace ("\r\n", "\n"));
1448                 }
1449
1450                 [Test]
1451                 public void WtiteXmlEncodedXml ()
1452                 {
1453                         string xml = @"<an_x0020_example_x0020_dataset.>
1454   <WOW_x0021__x0020_that_x0027_s_x0020_nasty...>
1455     <URL_x0020_is_x0020_http_x003A__x002F__x002F_www.go-mono.com>content string.</URL_x0020_is_x0020_http_x003A__x002F__x002F_www.go-mono.com>
1456   </WOW_x0021__x0020_that_x0027_s_x0020_nasty...>
1457 </an_x0020_example_x0020_dataset.>";
1458                         DataSet ds = new DataSet ("an example dataset.");
1459                         ds.Tables.Add (new DataTable ("WOW! that's nasty..."));
1460                         ds.Tables [0].Columns.Add ("URL is http://www.go-mono.com");
1461                         ds.Tables [0].Rows.Add (new object [] {"content string."});
1462                         StringWriter sw = new StringWriter ();
1463                         ds.WriteXml (sw);
1464                         Assert.AreEqual (sw.ToString ().Replace ("\r\n", "\n"), xml.Replace ("\r\n", "\n"));
1465                 }
1466
1467                 [Test]
1468                 public void ReadWriteXml2 ()
1469                 {
1470                         string xml = "<FullTextResponse><Domains><AvailResponse info='y' name='novell-ximian-group' /><AvailResponse info='n' name='ximian' /></Domains></FullTextResponse>";
1471                         DataSet ds = new DataSet ();
1472                         ds.ReadXml (new StringReader (xml));
1473                         AssertDataSet ("ds", ds, "FullTextResponse", 2, 1);
1474                         DataTable dt = ds.Tables [0];
1475                         AssertDataTable ("dt1", dt, "Domains", 1, 1, 0, 1, 1, 1);
1476                         dt = ds.Tables [1];
1477                         AssertDataTable ("dt2", dt, "AvailResponse", 3, 2, 1, 0, 1, 0);
1478                         StringWriter sw = new StringWriter ();
1479                         XmlTextWriter xtw = new XmlTextWriter (sw);
1480                         xtw.QuoteChar = '\'';
1481                         ds.WriteXml (xtw);
1482                         Assert.AreEqual (xml, sw.ToString ());
1483                 }
1484
1485                 // bug #53959.
1486                 [Test]
1487                 public void ReadWriteXml3 ()
1488                 {
1489                         string input = @"<FullTextResponse>
1490   <Domains>
1491     <AvailResponse info='y' name='novell-ximian-group' />
1492     <AvailResponse info='n' name='ximian' />
1493   </Domains>
1494 </FullTextResponse>";
1495                         DataSet ds = new DataSet ();
1496                         ds.ReadXml (new StringReader (input));
1497
1498                         StringWriter sw = new StringWriter ();
1499                         XmlTextWriter xtw = new XmlTextWriter (sw);
1500                         xtw.Formatting = Formatting.Indented;
1501                         xtw.QuoteChar = '\'';
1502                         ds.WriteXml (xtw);
1503                         xtw.Flush ();
1504                         Assert.AreEqual (input.Replace ("\r\n", "\n"), sw.ToString ().Replace ("\r\n", "\n"));
1505                 }
1506
1507                 [Test] // bug #60469
1508                 public void WriteXmlSchema2 ()
1509                 {
1510                         string xml = @"<myDataSet xmlns='NetFrameWork'><myTable><id>0</id><item>item 0</item></myTable><myTable><id>1</id><item>item 1</item></myTable><myTable><id>2</id><item>item 2</item></myTable><myTable><id>3</id><item>item 3</item></myTable><myTable><id>4</id><item>item 4</item></myTable><myTable><id>5</id><item>item 5</item></myTable><myTable><id>6</id><item>item 6</item></myTable><myTable><id>7</id><item>item 7</item></myTable><myTable><id>8</id><item>item 8</item></myTable><myTable><id>9</id><item>item 9</item></myTable></myDataSet>";
1511                         string schema = @"<?xml version='1.0' encoding='utf-16'?>
1512 <xs:schema id='myDataSet' targetNamespace='NetFrameWork' xmlns:mstns='NetFrameWork' xmlns='NetFrameWork' xmlns:xs='http://www.w3.org/2001/XMLSchema' xmlns:msdata='urn:schemas-microsoft-com:xml-msdata' attributeFormDefault='qualified' elementFormDefault='qualified'>
1513   <xs:element name='myDataSet' msdata:IsDataSet='true' " +
1514 #if NET_2_0
1515                         "msdata:UseCurrentLocale='true'"
1516 #else
1517                         "msdata:Locale='fi-FI'"
1518 #endif
1519                         + @">
1520     <xs:complexType>
1521       <xs:choice minOccurs='0' maxOccurs='unbounded'>
1522         <xs:element name='myTable'>
1523           <xs:complexType>
1524             <xs:sequence>
1525               <xs:element name='id' msdata:AutoIncrement='true' type='xs:int' minOccurs='0' />
1526               <xs:element name='item' type='xs:string' minOccurs='0' />
1527             </xs:sequence>
1528           </xs:complexType>
1529         </xs:element>
1530       </xs:choice>
1531     </xs:complexType>
1532   </xs:element>
1533 </xs:schema>";
1534                         DataSet OriginalDataSet = new DataSet ("myDataSet");
1535                         OriginalDataSet.Namespace= "NetFrameWork";
1536                         DataTable myTable = new DataTable ("myTable");
1537                         DataColumn c1 = new DataColumn ("id", typeof (int));
1538                         c1.AutoIncrement = true;
1539                         DataColumn c2 = new DataColumn ("item");
1540                         myTable.Columns.Add (c1);
1541                         myTable.Columns.Add (c2);
1542                         OriginalDataSet.Tables.Add (myTable);
1543                         // Add ten rows.
1544                         DataRow newRow;
1545                         for(int i = 0; i < 10; i++) {
1546                                 newRow = myTable.NewRow ();
1547                                 newRow ["item"] = "item " + i;
1548                                 myTable.Rows.Add (newRow);
1549                         }
1550                         OriginalDataSet.AcceptChanges ();
1551
1552                         StringWriter sw = new StringWriter ();
1553                         XmlTextWriter xtw = new XmlTextWriter (sw);
1554                         xtw.QuoteChar = '\'';
1555                         OriginalDataSet.WriteXml (xtw);
1556                         string result = sw.ToString ();
1557
1558                         Assert.AreEqual (xml, result);
1559
1560                         sw = new StringWriter ();
1561                         xtw = new XmlTextWriter (sw);
1562                         xtw.Formatting = Formatting.Indented;
1563                         OriginalDataSet.WriteXmlSchema (xtw);
1564                         result = sw.ToString ();
1565
1566                         result = result.Replace ("\r\n", "\n").Replace ('"', '\'');
1567                         Assert.AreEqual (schema.Replace ("\r\n", "\n"), result);
1568                 }
1569
1570                 // bug #66366
1571                 [Test]
1572                 public void WriteXmlSchema3 ()
1573                 {
1574                         string xmlschema = @"<?xml version=""1.0"" encoding=""utf-16""?>
1575 <xs:schema id=""ExampleDataSet"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">
1576   <xs:element name=""ExampleDataSet"" msdata:IsDataSet=""true"" ";
1577 #if NET_2_0
1578                         xmlschema = xmlschema + "msdata:UseCurrentLocale=\"true\"";
1579 #else
1580                         xmlschema = xmlschema + "msdata:Locale=\"fi-FI\"";
1581 #endif
1582                         xmlschema = xmlschema + @">
1583     <xs:complexType>
1584       <xs:choice minOccurs=""0"" maxOccurs=""unbounded"">
1585         <xs:element name=""ExampleDataTable"">
1586           <xs:complexType>
1587             <xs:attribute name=""PrimaryKeyColumn"" type=""xs:int"" use=""required"" />
1588           </xs:complexType>
1589         </xs:element>
1590       </xs:choice>
1591     </xs:complexType>
1592     <xs:unique name=""PK_ExampleDataTable"" msdata:PrimaryKey=""true"">
1593       <xs:selector xpath="".//ExampleDataTable"" />
1594       <xs:field xpath=""@PrimaryKeyColumn"" />
1595     </xs:unique>
1596   </xs:element>
1597 </xs:schema>";
1598                         DataSet ds = new DataSet ("ExampleDataSet");
1599
1600                         ds.Tables.Add (new DataTable ("ExampleDataTable"));
1601                         ds.Tables ["ExampleDataTable"].Columns.Add (
1602                                 new DataColumn ("PrimaryKeyColumn", typeof(int), "", MappingType.Attribute));
1603                         ds.Tables ["ExampleDataTable"].Columns ["PrimaryKeyColumn"].AllowDBNull = false;
1604
1605                         ds.Tables ["ExampleDataTable"].Constraints.Add (
1606                                 "PK_ExampleDataTable",
1607                                 ds.Tables ["ExampleDataTable"].Columns ["PrimaryKeyColumn"],
1608                                 true);
1609
1610                         ds.AcceptChanges ();
1611                         StringWriter sw = new StringWriter ();
1612                         ds.WriteXmlSchema (sw);
1613
1614                         string result = sw.ToString ();
1615
1616                         Assert.AreEqual (result.Replace ("\r\n", "\n"), xmlschema.Replace ("\r\n", "\n"));
1617                 }
1618
1619                 // bug #67792.
1620                 [Test]
1621                 public void WriteXmlSchema4 ()
1622                 {
1623                         string xmlschema = @"<?xml version=""1.0"" encoding=""utf-16""?>
1624 <xs:schema id=""Example"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">
1625 ";
1626 #if NET_2_0
1627                         xmlschema = xmlschema + "  <xs:element name=\"Example\" msdata:IsDataSet=\"true\" msdata:UseCurrentLocale=\"true\"";
1628 #else
1629                         xmlschema = xmlschema + "  <xs:element name=\"Example\" msdata:IsDataSet=\"true\" msdata:Locale=\"fi-FI\"";
1630 #endif
1631                         xmlschema = xmlschema + @">
1632     <xs:complexType>
1633       <xs:choice minOccurs=""0"" maxOccurs=""unbounded"">
1634         <xs:element name=""MyType"">
1635           <xs:complexType>
1636             <xs:attribute name=""ID"" type=""xs:int"" use=""required"" />
1637             <xs:attribute name=""Desc"" type=""xs:string"" />
1638           </xs:complexType>
1639         </xs:element>
1640       </xs:choice>
1641     </xs:complexType>
1642   </xs:element>
1643 </xs:schema>";
1644                         DataSet ds = new DataSet ("Example");
1645
1646                         // Add MyType DataTable
1647                         DataTable dt = new DataTable ("MyType");
1648                         ds.Tables.Add (dt);
1649
1650                         dt.Columns.Add (new DataColumn ("ID", typeof(int), "",
1651                                 MappingType.Attribute));
1652                         dt.Columns ["ID"].AllowDBNull = false;
1653
1654                         dt.Columns.Add (new DataColumn ("Desc", typeof
1655                                 (string), "", MappingType.Attribute));
1656
1657                         ds.AcceptChanges ();
1658
1659                         StringWriter sw = new StringWriter ();
1660                         ds.WriteXmlSchema (sw);
1661
1662                         string result = sw.ToString ();
1663
1664                         Assert.AreEqual (result.Replace ("\r\n", "\n"), xmlschema.Replace ("\r\n", "\n"));
1665                 }
1666
1667                 // bug # 68432
1668                 [Test]
1669                 public void WriteXmlSchema5 ()
1670                 {
1671                         string xmlschema = @"<?xml version=""1.0"" encoding=""utf-16""?>
1672 <xs:schema id=""Example"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">
1673 "+
1674 #if NET_2_0
1675 "  <xs:element name=\"Example\" msdata:IsDataSet=\"true\" msdata:UseCurrentLocale=\"true\""
1676 #else
1677 "  <xs:element name=\"Example\" msdata:IsDataSet=\"true\" msdata:Locale=\"fi-FI\""
1678 #endif
1679                           + @">
1680     <xs:complexType>
1681       <xs:choice minOccurs=""0"" maxOccurs=""unbounded"">
1682         <xs:element name=""StandAlone"">
1683           <xs:complexType>
1684             <xs:attribute name=""ID"" type=""xs:int"" use=""required"" />
1685             <xs:attribute name=""Desc"" type=""xs:string"" use=""required"" />
1686           </xs:complexType>
1687         </xs:element>
1688         <xs:element name=""Dimension"">
1689           <xs:complexType>
1690             <xs:attribute name=""Number"" msdata:ReadOnly=""true"" type=""xs:int"" use=""required"" />
1691             <xs:attribute name=""Title"" type=""xs:string"" use=""required"" />
1692           </xs:complexType>
1693         </xs:element>
1694         <xs:element name=""Element"">
1695           <xs:complexType>
1696             <xs:attribute name=""Dimension"" msdata:ReadOnly=""true"" type=""xs:int"" use=""required"" />
1697             <xs:attribute name=""Number"" msdata:ReadOnly=""true"" type=""xs:int"" use=""required"" />
1698             <xs:attribute name=""Title"" type=""xs:string"" use=""required"" />
1699           </xs:complexType>
1700         </xs:element>
1701       </xs:choice>
1702     </xs:complexType>
1703     <xs:unique name=""PK_Dimension"" msdata:PrimaryKey=""true"">
1704       <xs:selector xpath="".//Dimension"" />
1705       <xs:field xpath=""@Number"" />
1706     </xs:unique>
1707     <xs:unique name=""PK_Element"" msdata:PrimaryKey=""true"">
1708       <xs:selector xpath="".//Element"" />
1709       <xs:field xpath=""@Dimension"" />
1710       <xs:field xpath=""@Number"" />
1711     </xs:unique>
1712     <xs:keyref name=""FK_Element_To_Dimension"" refer=""PK_Dimension"">
1713       <xs:selector xpath="".//Element"" />
1714       <xs:field xpath=""@Dimension"" />
1715     </xs:keyref>
1716   </xs:element>
1717 </xs:schema>";
1718                         DataSet ds = new DataSet("Example");
1719
1720                         // Add a DataTable with no ReadOnly columns
1721                         DataTable dt1 = new DataTable ("StandAlone");
1722                         ds.Tables.Add (dt1);
1723
1724                         // Add a ReadOnly column
1725                         dt1.Columns.Add (new DataColumn ("ID", typeof(int), "",
1726                                 MappingType.Attribute));
1727                         dt1.Columns ["ID"].AllowDBNull = false;
1728
1729                         dt1.Columns.Add (new DataColumn ("Desc", typeof
1730                                 (string), "", MappingType.Attribute));
1731                         dt1.Columns ["Desc"].AllowDBNull = false;
1732
1733                         // Add related DataTables with ReadOnly columns
1734                         DataTable dt2 = new DataTable ("Dimension");
1735                         ds.Tables.Add (dt2);
1736                         dt2.Columns.Add (new DataColumn ("Number", typeof
1737                                 (int), "", MappingType.Attribute));
1738                         dt2.Columns ["Number"].AllowDBNull = false;
1739                         dt2.Columns ["Number"].ReadOnly = true;
1740
1741                         dt2.Columns.Add (new DataColumn ("Title", typeof
1742                                 (string), "", MappingType.Attribute));
1743                         dt2.Columns ["Title"].AllowDBNull = false;
1744
1745                         dt2.Constraints.Add ("PK_Dimension", dt2.Columns ["Number"], true);
1746
1747                         DataTable dt3 = new DataTable ("Element");
1748                         ds.Tables.Add(dt3);
1749
1750                         dt3.Columns.Add (new DataColumn ("Dimension", typeof
1751                                 (int), "", MappingType.Attribute));
1752                         dt3.Columns ["Dimension"].AllowDBNull = false;
1753                         dt3.Columns ["Dimension"].ReadOnly = true;
1754
1755                         dt3.Columns.Add (new DataColumn ("Number", typeof
1756                                 (int), "", MappingType.Attribute));
1757                         dt3.Columns ["Number"].AllowDBNull = false;
1758                         dt3.Columns ["Number"].ReadOnly = true;
1759
1760                         dt3.Columns.Add (new DataColumn ("Title", typeof
1761                                 (string), "", MappingType.Attribute));
1762                         dt3.Columns ["Title"].AllowDBNull = false;
1763
1764                         dt3.Constraints.Add ("PK_Element", new DataColumn[] {
1765                                 dt3.Columns ["Dimension"],
1766                                 dt3.Columns ["Number"] }, true);
1767
1768                         ds.Relations.Add ("FK_Element_To_Dimension",
1769                                 dt2.Columns ["Number"], dt3.Columns["Dimension"]);
1770
1771                         ds.AcceptChanges ();
1772
1773                         StringWriter sw = new StringWriter ();
1774                         ds.WriteXmlSchema (sw);
1775
1776                         string result = sw.ToString ();
1777
1778                         Assert.AreEqual (result.Replace ("\r\n", "\n"), xmlschema.Replace ("\r\n", "\n"));
1779                 }
1780
1781                 // bug #67793
1782                 [Test]
1783                 public void WriteXmlSchema6 ()
1784                 {
1785                         string xmlschema = @"<?xml version=""1.0"" encoding=""utf-16""?>
1786 <xs:schema id=""Example"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">
1787 "+
1788 #if NET_2_0
1789                           @"  <xs:element name=""Example"" msdata:IsDataSet=""true"" msdata:UseCurrentLocale=""true"""
1790 #else
1791                           @"  <xs:element name=""Example"" msdata:IsDataSet=""true"" msdata:Locale=""fi-FI"""
1792 #endif
1793                           + @">
1794     <xs:complexType>
1795       <xs:choice minOccurs=""0"" maxOccurs=""unbounded"">
1796         <xs:element name=""MyType"">
1797           <xs:complexType>
1798             <xs:attribute name=""Desc"">
1799               <xs:simpleType>
1800                 <xs:restriction base=""xs:string"">
1801                   <xs:maxLength value=""32"" />
1802                 </xs:restriction>
1803               </xs:simpleType>
1804             </xs:attribute>
1805           </xs:complexType>
1806         </xs:element>
1807       </xs:choice>
1808     </xs:complexType>
1809   </xs:element>
1810 </xs:schema>";
1811                         DataSet ds = new DataSet("Example");
1812
1813                         // Add MyType DataTable
1814                         ds.Tables.Add ("MyType");
1815
1816                         ds.Tables ["MyType"].Columns.Add (new DataColumn(
1817                                 "Desc", typeof (string), "", MappingType.Attribute));
1818                         ds.Tables ["MyType"].Columns ["Desc"].MaxLength = 32;
1819
1820                         ds.AcceptChanges ();
1821
1822                         StringWriter sw = new StringWriter ();
1823                         ds.WriteXmlSchema (sw);
1824
1825                         string result = sw.ToString ();
1826
1827                         Assert.AreEqual (result.Replace ("\r\n", "\n"), xmlschema.Replace ("\r\n", "\n"));
1828                 }
1829
1830                 // bug #68008
1831                 [Test]
1832                 public void WriteXmlSchema7 ()
1833                 {
1834                         DataSet ds = new DataSet ();
1835                         DataTable dt = new DataTable ("table");
1836                         dt.Columns.Add ("col1");
1837                         dt.Columns.Add ("col2");
1838                         ds.Tables.Add (dt);
1839                         dt.Rows.Add (new object [] {"foo", "bar"});
1840                         StringWriter sw = new StringWriter ();
1841                         ds.WriteXmlSchema (sw);
1842                         Assert.IsTrue (sw.ToString ().IndexOf ("xmlns=\"\"") > 0);
1843                 }
1844
1845                 // bug #61233
1846                 [Test]
1847                 public void WriteXmlExtendedProperties ()
1848                 {
1849                         string xml = @"<?xml version=""1.0"" encoding=""utf-16""?>
1850 <xs:schema id=""NewDataSet"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"" xmlns:msprop=""urn:schemas-microsoft-com:xml-msprop"">
1851 " +
1852 #if NET_2_0
1853 @"  <xs:element name=""NewDataSet"" msdata:IsDataSet=""true"" msdata:UseCurrentLocale=""true"" msprop:version=""version 2.1"">"
1854 #else
1855 @"  <xs:element name=""NewDataSet"" msdata:IsDataSet=""true"" msdata:Locale=""fi-FI"" msprop:version=""version 2.1"">"
1856 #endif
1857                           + @"
1858     <xs:complexType>
1859       <xs:choice minOccurs=""0"" maxOccurs=""unbounded"">
1860         <xs:element name=""Foo"">
1861           <xs:complexType>
1862             <xs:sequence>
1863               <xs:element name=""col1"" type=""xs:string"" minOccurs=""0"" />
1864             </xs:sequence>
1865           </xs:complexType>
1866         </xs:element>
1867       </xs:choice>
1868     </xs:complexType>
1869   </xs:element>
1870 </xs:schema>";
1871                         DataSet ds = new DataSet ();
1872                         ds.ExtendedProperties ["version"] = "version 2.1";
1873                         DataTable dt = new DataTable ("Foo");
1874                         dt.Columns.Add ("col1");
1875                         dt.Rows.Add (new object [] {"foo"});
1876                         ds.Tables.Add (dt);
1877
1878                         StringWriter sw = new StringWriter ();
1879                         ds.WriteXmlSchema (sw);
1880
1881                         string result = sw.ToString ();
1882
1883                         Assert.AreEqual (result.Replace ("\r\n", "\n"), xml.Replace ("\r\n", "\n"));
1884                 }
1885
1886                 [Test]
1887                 public void WriteXmlModeSchema ()
1888                 {
1889                         // This is the MS output of WriteXmlSchema().
1890
1891                         string xml = @"<Example>
1892   <xs:schema id=""Example"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">
1893 " +
1894 #if NET_2_0
1895 @"    <xs:element name=""Example"" msdata:IsDataSet=""true"" msdata:UseCurrentLocale=""true"">"
1896 #else
1897 @"    <xs:element name=""Example"" msdata:IsDataSet=""true"" msdata:Locale=""fi-FI"">"
1898 #endif
1899                           + @"
1900       <xs:complexType>
1901         <xs:choice minOccurs=""0"" maxOccurs=""unbounded"">
1902           <xs:element name=""Dimension"">
1903             <xs:complexType>
1904               <xs:sequence>
1905                 <xs:element name=""Number"" type=""xs:int"" />
1906               </xs:sequence>
1907             </xs:complexType>
1908           </xs:element>
1909           <xs:element name=""Element"">
1910             <xs:complexType>
1911               <xs:sequence>
1912                 <xs:element name=""Dimension"" type=""xs:int"" />
1913                 <xs:element name=""Number"" type=""xs:int"" />
1914               </xs:sequence>
1915             </xs:complexType>
1916           </xs:element>
1917         </xs:choice>
1918       </xs:complexType>
1919       <xs:unique name=""PK_Dimension"" msdata:PrimaryKey=""true"">
1920         <xs:selector xpath="".//Dimension"" />
1921         <xs:field xpath=""Number"" />
1922       </xs:unique>
1923       <xs:unique name=""PK_Element"" msdata:PrimaryKey=""true"">
1924         <xs:selector xpath="".//Element"" />
1925         <xs:field xpath=""Dimension"" />
1926         <xs:field xpath=""Number"" />
1927       </xs:unique>
1928       <xs:keyref name=""FK_Element_To_Dimension"" refer=""PK_Dimension"">
1929         <xs:selector xpath="".//Element"" />
1930         <xs:field xpath=""Dimension"" />
1931       </xs:keyref>
1932     </xs:element>
1933   </xs:schema>
1934   <Dimension>
1935     <Number>0</Number>
1936   </Dimension>
1937   <Dimension>
1938     <Number>1</Number>
1939   </Dimension>
1940   <Element>
1941     <Dimension>0</Dimension>
1942     <Number>0</Number>
1943   </Element>
1944   <Element>
1945     <Dimension>0</Dimension>
1946     <Number>1</Number>
1947   </Element>
1948   <Element>
1949     <Dimension>0</Dimension>
1950     <Number>2</Number>
1951   </Element>
1952   <Element>
1953     <Dimension>0</Dimension>
1954     <Number>3</Number>
1955   </Element>
1956   <Element>
1957     <Dimension>1</Dimension>
1958     <Number>0</Number>
1959   </Element>
1960   <Element>
1961     <Dimension>1</Dimension>
1962     <Number>1</Number>
1963   </Element>
1964 </Example>";
1965                         DataSet ds = new DataSet("Example");
1966
1967                         // Dimension DataTable
1968                         DataTable dt1 = new DataTable ("Dimension");
1969                         ds.Tables.Add (dt1);
1970
1971                         dt1.Columns.Add (new DataColumn ("Number", typeof (int)));
1972                         dt1.Columns ["Number"].AllowDBNull = false;
1973
1974                         dt1.Constraints.Add ("PK_Dimension", dt1.Columns ["Number"], true);
1975
1976                         // Element DataTable
1977                         DataTable dt2 = new DataTable ("Element");
1978                         ds.Tables.Add (dt2);
1979
1980                         dt2.Columns.Add (new DataColumn ("Dimension", typeof (int)));
1981                         dt2.Columns ["Dimension"].AllowDBNull = false;
1982
1983                         dt2.Columns.Add (new DataColumn ("Number", typeof (int)));
1984                         dt2.Columns ["Number"].AllowDBNull = false;
1985
1986                         dt2.Constraints.Add ("PK_Element", new DataColumn[] {
1987                                 dt2.Columns ["Dimension"],
1988                                 dt2.Columns ["Number"] },
1989                                 true);
1990
1991                         // Add DataRelations
1992                         ds.Relations.Add ("FK_Element_To_Dimension",
1993                                 dt1.Columns ["Number"],
1994                                 dt2.Columns ["Dimension"], true);
1995
1996                         // Add 2 Dimensions
1997                         for (int i = 0; i < 2; i++) {
1998                                 DataRow newRow = dt1.NewRow ();
1999                                 newRow ["Number"] = i;
2000                                 dt1.Rows.Add (newRow);
2001                         }
2002
2003                         // Dimension 0 => 4 Elements
2004                         for (int i = 0; i < 4; i++) {
2005                                 DataRow newRow = dt2.NewRow();
2006                                 newRow ["Dimension"] = 0;
2007                                 newRow ["Number"] = i;
2008                                 dt2.Rows.Add (newRow);
2009                         }
2010
2011                         // Dimension 1 => 2 Elements
2012                         for (int i = 0; i < 2; i++) {
2013                                 DataRow newRow = dt2.NewRow();
2014                                 newRow ["Dimension"] = 1;
2015                                 newRow ["Number"] = i;
2016                                 dt2.Rows.Add (newRow);
2017                         }
2018
2019                         ds.AcceptChanges ();
2020
2021                         StringWriter sw = new StringWriter ();
2022                         ds.WriteXml(sw, XmlWriteMode.WriteSchema);
2023
2024                         string result = sw.ToString ();
2025
2026                         Assert.AreEqual (result.Replace ("\r\n", "\n"), xml.Replace ("\r\n", "\n"));
2027                 }
2028
2029                 [Test]
2030                 public void WriteXmlModeSchema1 () {
2031                         string SerializedDataTable =
2032 @"<rdData>
2033   <MyDataTable CustomerID='VINET' CompanyName='Vins et alcools Chevalier' ContactName='Paul Henriot' />
2034 </rdData>";
2035                         string expected =
2036 @"<rdData>
2037   <xs:schema id=""rdData"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">
2038     <xs:element name=""rdData"" msdata:IsDataSet=""true"" " +
2039                           @"msdata:Locale=""en-US"">" +
2040 @"
2041       <xs:complexType>
2042         <xs:choice minOccurs=""0"" maxOccurs=""unbounded"">
2043           <xs:element name=""MyDataTable"">
2044             <xs:complexType>
2045               <xs:attribute name=""CustomerID"" type=""xs:string"" />
2046               <xs:attribute name=""CompanyName"" type=""xs:string"" />
2047               <xs:attribute name=""ContactName"" type=""xs:string"" />
2048             </xs:complexType>
2049           </xs:element>
2050         </xs:choice>
2051       </xs:complexType>
2052     </xs:element>
2053   </xs:schema>
2054   <MyDataTable CustomerID=""VINET"" CompanyName=""Vins et alcools Chevalier"" ContactName=""Paul Henriot"" />
2055 </rdData>";
2056                         DataSet set;
2057                         set = new DataSet ();
2058                         set.ReadXml (new StringReader (SerializedDataTable));
2059
2060                         StringWriter w = new StringWriter ();
2061                         set.WriteXml (w, XmlWriteMode.WriteSchema);
2062                         string result = w.ToString ();
2063                         Assert.AreEqual (expected.Replace ("\r", ""), result.Replace ("\r", ""));
2064                 }
2065
2066                 [Test]
2067                 public void DeserializeModifiedDataSet ()
2068                 {
2069                         // Serialization begins
2070                         DataSet prevDs = new DataSet ();
2071                         DataTable dt = prevDs.Tables.Add ();
2072                         dt.Columns.Add(new DataColumn("Id", typeof(string)));
2073
2074                         DataRow dr = dt.NewRow();
2075                         dr [0] = "a";
2076                         dt.Rows.Add (dr);
2077                         prevDs.AcceptChanges ();
2078                         dr = prevDs.Tables[0].Rows[0];
2079                         dr [0] = "b";
2080
2081                         XmlSerializer serializer = new XmlSerializer (typeof (DataSet));
2082                         StringWriter sw = new StringWriter ();
2083                         XmlTextWriter xw = new XmlTextWriter (sw);
2084                         xw.QuoteChar = '\'';
2085                         serializer.Serialize (xw, prevDs);
2086
2087                         // Deserialization begins
2088                         StringReader sr = new StringReader (sw.ToString ());
2089                         XmlTextReader reader = new XmlTextReader (sr);
2090                         XmlSerializer serializer1 = new XmlSerializer (typeof (DataSet));
2091                         DataSet ds = serializer1.Deserialize (reader) as DataSet;
2092                         Assert.AreEqual (
2093                                 prevDs.Tables[0].Rows [0][0,DataRowVersion.Original].ToString (),
2094                                 ds.Tables[0].Rows [0][0,DataRowVersion.Original].ToString (),
2095                                 "deserialization after modification does not give original values");
2096                         Assert.AreEqual (
2097                                 prevDs.Tables[0].Rows [0][0,DataRowVersion.Current].ToString (),
2098                                 ds.Tables[0].Rows [0][0,DataRowVersion.Current].ToString (),
2099                                 "deserialization after modification oes not give current values");
2100                 }
2101
2102                 [Test]
2103                 public void Bug420862 ()
2104                 {
2105                         DataSet ds = new DataSet ("d");
2106                         DataTable dt = ds.Tables.Add ("t");
2107                         dt.Columns.Add ("c", typeof (ushort));
2108
2109                         XmlSchema xs = XmlSchema.Read (new StringReader (ds.GetXmlSchema ()), null);
2110                         xs.Compile (null);
2111
2112                         // follow the nesting of the schema in the foreach
2113                         foreach (XmlSchemaElement d in xs.Items) {
2114                                 Assert.AreEqual ("d", d.Name);
2115                                 XmlSchemaChoice dsc = (XmlSchemaChoice) ((XmlSchemaComplexType) d.SchemaType).Particle;
2116                                 foreach (XmlSchemaElement t in dsc.Items) {
2117                                         Assert.AreEqual ("t", t.Name);
2118                                         XmlSchemaSequence tss = (XmlSchemaSequence) ((XmlSchemaComplexType) t.SchemaType).Particle;
2119                                         foreach (XmlSchemaElement c in tss.Items) {
2120                                                 Assert.AreEqual ("c", c.Name);
2121                                                 Assert.AreEqual ("unsignedShort", c.SchemaTypeName.Name);
2122                                                 return;
2123                                         }
2124                                 }
2125                         }
2126                         Assert.Fail ();
2127                 }
2128
2129                 /// <summary>
2130                 /// Test for testing DataSet.Clear method with foriegn key relations
2131                 /// This is expected to clear all the related datatable rows also
2132                 /// </summary>
2133                 [Test]
2134                 public void DataSetClearTest ()
2135                 {
2136                         DataSet ds = new DataSet ();
2137                         DataTable parent = ds.Tables.Add ("Parent");
2138                         DataTable child = ds.Tables.Add ("Child");
2139
2140                         parent.Columns.Add ("id", typeof (int));
2141                         child.Columns.Add ("ref_id", typeof(int));
2142
2143                         child.Constraints.Add (new ForeignKeyConstraint ("fk_constraint", parent.Columns [0], child.Columns [0]));
2144
2145                         DataRow dr = parent.NewRow ();
2146                         dr [0] = 1;
2147                         parent.Rows.Add (dr);
2148                         dr.AcceptChanges ();
2149
2150                         dr = child.NewRow ();
2151                         dr [0] = 1;
2152                         child.Rows.Add (dr);
2153                         dr.AcceptChanges ();
2154
2155                         try {
2156                                 ds.Clear (); // this should clear all the rows in parent & child tables
2157                         } catch (Exception e) {
2158                                 throw (new Exception ("Exception should not have been thrown at Clear method" + e.ToString ()));
2159                         }
2160                         Assert.AreEqual (0, parent.Rows.Count, "parent table rows should not exist!");
2161                         Assert.AreEqual (0, child.Rows.Count, "child table rows should not exist!");
2162                 }
2163
2164                 [Test]
2165                 public void CloneSubClassTest()
2166                 {
2167                         MyDataSet ds1 = new MyDataSet();
2168                         MyDataSet ds = (MyDataSet)(ds1.Clone());
2169                         Assert.AreEqual (2, MyDataSet.count, "A#01");
2170                 }
2171
2172                 #region DataSet.GetChanges Tests
2173                 public void GetChanges_Relations_DifferentRowStatesTest ()
2174                 {
2175                         DataSet ds = new DataSet ("ds");
2176                         DataTable parent = ds.Tables.Add ("parent");
2177                         DataTable child = ds.Tables.Add ("child");
2178
2179                         parent.Columns.Add ("id", typeof (int));
2180                         parent.Columns.Add ("name", typeof (string));
2181
2182
2183                         child.Columns.Add ("id", typeof (int));
2184                         child.Columns.Add ("parent", typeof (int));
2185                         child.Columns.Add ("name", typeof (string));
2186
2187                         parent.Rows.Add (new object [] { 1, "mono parent 1" } );
2188                         parent.Rows.Add (new object [] { 2, "mono parent 2" } );
2189                         parent.Rows.Add (new object [] { 3, "mono parent 3" } );
2190                         parent.Rows.Add (new object [] { 4, "mono parent 4" } );
2191                         parent.AcceptChanges ();
2192
2193                         child.Rows.Add (new object [] { 1, 1, "mono child 1" } );
2194                         child.Rows.Add (new object [] { 2, 2, "mono child 2" } );
2195                         child.Rows.Add (new object [] { 3, 3, "mono child 3" } );
2196                         child.AcceptChanges ();
2197
2198                         DataRelation relation = ds.Relations.Add ("parent_child",
2199                                                                   parent.Columns ["id"],
2200                                                                   child.Columns ["parent"]);
2201
2202                         // modify the parent and get changes
2203                         child.Rows [1]["parent"] = 4;
2204                         DataSet changes = ds.GetChanges ();
2205                         DataRow row = changes.Tables ["parent"].Rows[0];
2206                         Assert.AreEqual ((int) parent.Rows [3][0], (int) row [0], "#RT1");
2207                         Assert.AreEqual (1, changes.Tables ["parent"].Rows.Count, "#RT2 only get parent row with current version");
2208                         ds.RejectChanges ();
2209
2210                         // delete a child row and get changes.
2211                         child.Rows [0].Delete ();
2212                         changes = ds.GetChanges ();
2213
2214                         Assert.AreEqual (changes.Tables.Count, 2, "#RT3 Should import parent table as well");
2215                         Assert.AreEqual (1, changes.Tables ["parent"].Rows.Count, "#RT4 only get parent row with original version");
2216                         Assert.AreEqual (1, (int) changes.Tables ["parent"].Rows [0][0], "#RT5 parent row based on original version");
2217                 }
2218                 #endregion // DataSet.GetChanges Tests
2219
2220                 [Test]
2221                 public void RuleTest ()
2222                 {
2223                         DataSet ds = new DataSet ("testds");
2224                         DataTable parent = ds.Tables.Add ("parent");
2225                         DataTable child = ds.Tables.Add ("child");
2226
2227                         parent.Columns.Add ("id", typeof (int));
2228                         parent.Columns.Add ("name", typeof (string));
2229                         parent.PrimaryKey = new DataColumn [] {parent.Columns ["id"]} ;
2230
2231                         child.Columns.Add ("id", typeof (int));
2232                         child.Columns.Add ("parent", typeof (int));
2233                         child.Columns.Add ("name", typeof (string));
2234                         child.PrimaryKey = new DataColumn [] {child.Columns ["id"]} ;
2235
2236                         DataRelation relation = ds.Relations.Add ("parent_child",
2237                                                                   parent.Columns ["id"],
2238                                                                   child.Columns ["parent"]);
2239
2240                         parent.Rows.Add (new object [] {1, "mono test 1"});
2241                         parent.Rows.Add (new object [] {2, "mono test 2"});
2242                         parent.Rows.Add (new object [] {3, "mono test 3"});
2243
2244                         child.Rows.Add (new object [] {1, 1, "mono child test 1"});
2245                         child.Rows.Add (new object [] {2, 2, "mono child test 2"});
2246                         child.Rows.Add (new object [] {3, 3, "mono child test 3"});
2247
2248                         ds.AcceptChanges ();
2249
2250                         parent.Rows [0] ["name"] = "mono changed test 1";
2251
2252                         Assert.AreEqual (DataRowState.Unchanged, parent.Rows [0].GetChildRows (relation) [0].RowState,
2253                                          "#RT1 child should not be modified");
2254
2255                         ds.RejectChanges ();
2256                         parent.Rows [0] ["id"] = "4";
2257
2258                         DataRow childRow =  parent.Rows [0].GetChildRows (relation) [0];
2259                         Assert.AreEqual (DataRowState.Modified, childRow.RowState, "#RT2 child should be modified");
2260                         Assert.AreEqual (4, (int) childRow ["parent"], "#RT3 child should point to modified row");
2261                 }
2262
2263                 [Test] // from bug #76480
2264                 public void WriteXmlEscapeName ()
2265                 {
2266                         // create dataset
2267                         DataSet data = new DataSet();
2268
2269                         DataTable mainTable = data.Tables.Add ("main");
2270                         DataColumn mainkey = mainTable.Columns.Add ("mainkey", typeof(Guid));
2271                         mainTable.Columns.Add ("col.2<hi/>", typeof (string));
2272                         mainTable.Columns.Add ("#col3", typeof (string));
2273
2274                         // populate data
2275                         mainTable.Rows.Add (new object [] { Guid.NewGuid (), "hi there", "my friend" } );
2276                         mainTable.Rows.Add (new object [] { Guid.NewGuid (), "what is", "your name" } );
2277                         mainTable.Rows.Add (new object [] { Guid.NewGuid (), "I have", "a bean" } );
2278
2279                         // write xml
2280                         StringWriter writer = new StringWriter ();
2281                         data.WriteXml (writer, XmlWriteMode.WriteSchema);
2282                         string xml = writer.ToString ();
2283                         Assert.IsTrue (xml.IndexOf ("name=\"col.2_x003C_hi_x002F__x003E_\"") > 0, "#1");
2284                         Assert.IsTrue (xml.IndexOf ("name=\"_x0023_col3\"") > 0, "#2");
2285                         Assert.IsTrue (xml.IndexOf ("<col.2_x003C_hi_x002F__x003E_>hi there</col.2_x003C_hi_x002F__x003E_>") > 0, "#3");
2286
2287                         // read xml
2288                         DataSet data2 = new DataSet();
2289                         data2.ReadXml (new StringReader (
2290                                 writer.GetStringBuilder ().ToString ()));
2291                 }
2292
2293 #if NET_2_0
2294
2295                 // it is basically a test for XmlSerializer, but I need it
2296                 // here to not add dependency on sys.data.dll in sys.xml test.
2297                 [Test]
2298                 public void ReflectTypedDataSet ()
2299                 {
2300                         XmlReflectionImporter imp = new XmlReflectionImporter ();
2301                         // it used to cause "missing GetDataSetSchema" error.
2302                         imp.ImportTypeMapping (typeof (MonkeyDataSet));
2303                 }
2304
2305                 #region DataSet.CreateDataReader Tests and DataSet.Load Tests
2306
2307                 private DataSet ds;
2308                 private DataTable dt1, dt2;
2309
2310                 private void localSetup () {
2311                         ds = new DataSet ("test");
2312                         dt1 = new DataTable ("test1");
2313                         dt1.Columns.Add ("id1", typeof (int));
2314                         dt1.Columns.Add ("name1", typeof (string));
2315                         //dt1.PrimaryKey = new DataColumn[] { dt1.Columns["id"] };
2316                         dt1.Rows.Add (new object[] { 1, "mono 1" });
2317                         dt1.Rows.Add (new object[] { 2, "mono 2" });
2318                         dt1.Rows.Add (new object[] { 3, "mono 3" });
2319                         dt1.AcceptChanges ();
2320                         dt2 = new DataTable ("test2");
2321                         dt2.Columns.Add ("id2", typeof (int));
2322                         dt2.Columns.Add ("name2", typeof (string));
2323                         dt2.Columns.Add ("name3", typeof (string));
2324                         //dt2.PrimaryKey = new DataColumn[] { dt2.Columns["id"] };
2325                         dt2.Rows.Add (new object[] { 4, "mono 4", "four" });
2326                         dt2.Rows.Add (new object[] { 5, "mono 5", "five" });
2327                         dt2.Rows.Add (new object[] { 6, "mono 6", "six" });
2328                         dt2.AcceptChanges ();
2329                         ds.Tables.Add (dt1);
2330                         ds.Tables.Add (dt2);
2331                         ds.AcceptChanges ();
2332                 }
2333
2334                 [Test]
2335                 public void CreateDataReader1 () {
2336                         // For First CreateDataReader Overload
2337                         localSetup ();
2338                         DataTableReader dtr = ds.CreateDataReader ();
2339                         Assert.IsTrue (dtr.HasRows, "HasRows");
2340                         int ti = 0;
2341                         do {
2342                                 Assert.AreEqual (ds.Tables[ti].Columns.Count, dtr.FieldCount, "CountCols-" + ti);
2343                                 int ri = 0;
2344                                 while (dtr.Read ()) {
2345                                         for (int i = 0; i < dtr.FieldCount; i++)
2346                                                 Assert.AreEqual (ds.Tables[ti].Rows[ri][i], dtr[i], "RowData-"+ti+"-"+ri+"-"+i);
2347                                         ri++;
2348                                 }
2349                                 ti++;
2350                         } while (dtr.NextResult ());
2351                 }
2352
2353                 [Test]
2354                 public void CreateDataReader2 () {
2355                         // For Second CreateDataReader Overload -
2356                         // compare to ds.Tables
2357                         localSetup ();
2358                         DataTableReader dtr = ds.CreateDataReader (dt1, dt2);
2359                         Assert.IsTrue (dtr.HasRows, "HasRows");
2360                         int ti = 0;
2361                         do {
2362                                 Assert.AreEqual (ds.Tables[ti].Columns.Count, dtr.FieldCount, "CountCols-" + ti);
2363                                 int ri = 0;
2364                                 while (dtr.Read ()) {
2365                                         for (int i = 0; i < dtr.FieldCount; i++)
2366                                                 Assert.AreEqual (ds.Tables[ti].Rows[ri][i], dtr[i], "RowData-" + ti + "-" + ri + "-" + i);
2367                                         ri++;
2368                                 }
2369                                 ti++;
2370                         } while (dtr.NextResult ());
2371                 }
2372
2373                 [Test]
2374                 public void CreateDataReader3 () {
2375                         // For Second CreateDataReader Overload -
2376                         // compare to dt1 and dt2
2377                         localSetup ();
2378                         ds.Tables.Clear ();
2379                         DataTableReader dtr = ds.CreateDataReader (dt1, dt2);
2380                         Assert.IsTrue (dtr.HasRows, "HasRows");
2381                         string name = "dt1";
2382                         DataTable dtn = dt1;
2383                         do {
2384                                 Assert.AreEqual (dtn.Columns.Count, dtr.FieldCount, "CountCols-" + name);
2385                                 int ri = 0;
2386                                 while (dtr.Read ()) {
2387                                         for (int i = 0; i < dtr.FieldCount; i++)
2388                                                 Assert.AreEqual (dtn.Rows[ri][i], dtr[i], "RowData-" + name + "-" + ri + "-" + i);
2389                                         ri++;
2390                                 }
2391                                 if (dtn == dt1) {
2392                                         dtn = dt2;
2393                                         name = "dt2";
2394                                 } else {
2395                                         dtn = null;
2396                                         name = null;
2397                                 }
2398                         } while (dtr.NextResult ());
2399                 }
2400
2401                 [Test]
2402                 [ExpectedException (typeof (ArgumentException))]
2403                 public void CreateDataReaderNoTable () {
2404                         DataSet dsr = new DataSet ();
2405                         DataTableReader dtr = dsr.CreateDataReader ();
2406                 }
2407
2408                 internal struct fillErrorStruct {
2409                         internal string error;
2410                         internal string tableName;
2411                         internal int rowKey;
2412                         internal bool contFlag;
2413                         internal void init (string tbl, int row, bool cont, string err) {
2414                                 tableName = tbl;
2415                                 rowKey = row;
2416                                 contFlag = cont;
2417                                 error = err;
2418                         }
2419                 }
2420                 private fillErrorStruct[] fillErr = new fillErrorStruct[3];
2421                 private int fillErrCounter;
2422                 private void fillErrorHandler (object sender, FillErrorEventArgs e) {
2423                         e.Continue = fillErr[fillErrCounter].contFlag;
2424                         Assert.AreEqual (fillErr[fillErrCounter].tableName, e.DataTable.TableName, "fillErr-T");
2425                         Assert.AreEqual (fillErr[fillErrCounter].contFlag, e.Continue, "fillErr-C");
2426                         fillErrCounter++;
2427                 }
2428
2429                 [Test]
2430                 public void Load_Basic () {
2431                         localSetup ();
2432                         DataSet dsLoad = new DataSet ("LoadBasic");
2433                         DataTable table1 = new DataTable ();
2434                         dsLoad.Tables.Add (table1);
2435                         DataTable table2 = new DataTable ();
2436                         dsLoad.Tables.Add (table2);
2437                         DataTableReader dtr = ds.CreateDataReader ();
2438                         dsLoad.Load (dtr, LoadOption.OverwriteChanges, table1, table2);
2439                         CompareTables (dsLoad);
2440                 }
2441
2442                 [Test]
2443                 [ExpectedException (typeof (ArgumentException))]
2444                 public void Load_TableUnknown () {
2445                         localSetup ();
2446                         DataSet dsLoad = new DataSet ("LoadTableUnknown");
2447                         DataTable table1 = new DataTable ();
2448                         dsLoad.Tables.Add (table1);
2449                         DataTable table2 = new DataTable ();
2450                         // table2 is not added to dsLoad [dsLoad.Tables.Add (table2);]
2451                         DataTableReader dtr = ds.CreateDataReader ();
2452                         dsLoad.Load (dtr, LoadOption.OverwriteChanges, table1, table2);
2453                 }
2454
2455                 [Test]
2456                 public void Load_TableConflictT () {
2457                         fillErrCounter = 0;
2458                         fillErr[0].init ("Table1", 1, true,
2459                                 "Input string was not in a correct format.Couldn't store <mono 1> in name1 Column.  Expected type is Double.");
2460                         fillErr[1].init ("Table1", 2, true,
2461                                 "Input string was not in a correct format.Couldn't store <mono 2> in name1 Column.  Expected type is Double.");
2462                         fillErr[2].init ("Table1", 3, true,
2463                                 "Input string was not in a correct format.Couldn't store <mono 3> in name1 Column.  Expected type is Double.");
2464                         localSetup ();
2465                         DataSet dsLoad = new DataSet ("LoadTableConflict");
2466                         DataTable table1 = new DataTable ();
2467                         table1.Columns.Add ("name1", typeof (double));
2468                         dsLoad.Tables.Add (table1);
2469                         DataTable table2 = new DataTable ();
2470                         dsLoad.Tables.Add (table2);
2471                         DataTableReader dtr = ds.CreateDataReader ();
2472                         dsLoad.Load (dtr, LoadOption.PreserveChanges,
2473                                      fillErrorHandler, table1, table2);
2474                 }
2475                 [Test]
2476                 [ExpectedException (typeof (ArgumentException))]
2477                 public void Load_TableConflictF () {
2478                         fillErrCounter = 0;
2479                         fillErr[0].init ("Table1", 1, false,
2480                                 "Input string was not in a correct format.Couldn't store <mono 1> in name1 Column.  Expected type is Double.");
2481                         localSetup ();
2482                         DataSet dsLoad = new DataSet ("LoadTableConflict");
2483                         DataTable table1 = new DataTable ();
2484                         table1.Columns.Add ("name1", typeof (double));
2485                         dsLoad.Tables.Add (table1);
2486                         DataTable table2 = new DataTable ();
2487                         dsLoad.Tables.Add (table2);
2488                         DataTableReader dtr = ds.CreateDataReader ();
2489                         dsLoad.Load (dtr, LoadOption.Upsert,
2490                                      fillErrorHandler, table1, table2);
2491                 }
2492
2493                 [Test]
2494                 public void Load_StringsAsc () {
2495                         localSetup ();
2496                         DataSet dsLoad = new DataSet ("LoadStrings");
2497                         DataTable table1 = new DataTable ("First");
2498                         dsLoad.Tables.Add (table1);
2499                         DataTable table2 = new DataTable ("Second");
2500                         dsLoad.Tables.Add (table2);
2501                         DataTableReader dtr = ds.CreateDataReader ();
2502                         dsLoad.Load (dtr, LoadOption.OverwriteChanges, "First", "Second");
2503                         CompareTables (dsLoad);
2504                 }
2505
2506                 [Test]
2507                 public void Load_StringsDesc () {
2508                         localSetup ();
2509                         DataSet dsLoad = new DataSet ("LoadStrings");
2510                         DataTable table1 = new DataTable ("First");
2511                         dsLoad.Tables.Add (table1);
2512                         DataTable table2 = new DataTable ("Second");
2513                         dsLoad.Tables.Add (table2);
2514                         DataTableReader dtr = ds.CreateDataReader ();
2515                         dsLoad.Load (dtr, LoadOption.PreserveChanges, "Second", "First");
2516                         Assert.AreEqual (2, dsLoad.Tables.Count, "Tables");
2517                         Assert.AreEqual (3, dsLoad.Tables[0].Rows.Count, "T1-Rows");
2518                         Assert.AreEqual (3, dsLoad.Tables[0].Columns.Count, "T1-Columns");
2519                         Assert.AreEqual (3, dsLoad.Tables[1].Rows.Count, "T2-Rows");
2520                         Assert.AreEqual (2, dsLoad.Tables[1].Columns.Count, "T2-Columns");
2521                 }
2522
2523                 [Test]
2524                 public void Load_StringsNew () {
2525                         localSetup ();
2526                         DataSet dsLoad = new DataSet ("LoadStrings");
2527                         DataTable table1 = new DataTable ("First");
2528                         dsLoad.Tables.Add (table1);
2529                         DataTable table2 = new DataTable ("Second");
2530                         dsLoad.Tables.Add (table2);
2531                         DataTableReader dtr = ds.CreateDataReader ();
2532                         dsLoad.Load (dtr, LoadOption.Upsert, "Third", "Fourth");
2533                         Assert.AreEqual (4, dsLoad.Tables.Count, "Tables");
2534                         Assert.AreEqual ("First", dsLoad.Tables[0].TableName, "T1-Name");
2535                         Assert.AreEqual (0, dsLoad.Tables[0].Rows.Count, "T1-Rows");
2536                         Assert.AreEqual (0, dsLoad.Tables[0].Columns.Count, "T1-Columns");
2537                         Assert.AreEqual ("Second", dsLoad.Tables[1].TableName, "T2-Name");
2538                         Assert.AreEqual (0, dsLoad.Tables[1].Rows.Count, "T2-Rows");
2539                         Assert.AreEqual (0, dsLoad.Tables[1].Columns.Count, "T2-Columns");
2540                         Assert.AreEqual ("Third", dsLoad.Tables[2].TableName, "T3-Name");
2541                         Assert.AreEqual (3, dsLoad.Tables[2].Rows.Count, "T3-Rows");
2542                         Assert.AreEqual (2, dsLoad.Tables[2].Columns.Count, "T3-Columns");
2543                         Assert.AreEqual ("Fourth", dsLoad.Tables[3].TableName, "T4-Name");
2544                         Assert.AreEqual (3, dsLoad.Tables[3].Rows.Count, "T4-Rows");
2545                         Assert.AreEqual (3, dsLoad.Tables[3].Columns.Count, "T4-Columns");
2546                 }
2547
2548                 [Test]
2549                 public void Load_StringsNewMerge () {
2550                         localSetup ();
2551                         DataSet dsLoad = new DataSet ("LoadStrings");
2552                         DataTable table1 = new DataTable ("First");
2553                         table1.Columns.Add ("col1", typeof (string));
2554                         table1.Rows.Add (new object[] { "T1Row1" });
2555                         dsLoad.Tables.Add (table1);
2556                         DataTable table2 = new DataTable ("Second");
2557                         table2.Columns.Add ("col2", typeof (string));
2558                         table2.Rows.Add (new object[] { "T2Row1" });
2559                         table2.Rows.Add (new object[] { "T2Row2" });
2560                         dsLoad.Tables.Add (table2);
2561                         DataTableReader dtr = ds.CreateDataReader ();
2562                         dsLoad.Load (dtr, LoadOption.OverwriteChanges, "Third", "First");
2563                         Assert.AreEqual (3, dsLoad.Tables.Count, "Tables");
2564                         Assert.AreEqual ("First", dsLoad.Tables[0].TableName, "T1-Name");
2565                         Assert.AreEqual (4, dsLoad.Tables[0].Rows.Count, "T1-Rows");
2566                         Assert.AreEqual (4, dsLoad.Tables[0].Columns.Count, "T1-Columns");
2567                         Assert.AreEqual ("Second", dsLoad.Tables[1].TableName, "T2-Name");
2568                         Assert.AreEqual (2, dsLoad.Tables[1].Rows.Count, "T2-Rows");
2569                         Assert.AreEqual (1, dsLoad.Tables[1].Columns.Count, "T2-Columns");
2570                         Assert.AreEqual ("Third", dsLoad.Tables[2].TableName, "T3-Name");
2571                         Assert.AreEqual (3, dsLoad.Tables[2].Rows.Count, "T3-Rows");
2572                         Assert.AreEqual (2, dsLoad.Tables[2].Columns.Count, "T3-Columns");
2573                 }
2574
2575                 [Test]
2576                 public void ReadDiff ()
2577                 {
2578                         DataSet dsTest = new DataSet ("MonoTouchTest");
2579                         var dt = new DataTable ("123");
2580                         dt.Columns.Add (new DataColumn ("Value1"));
2581                         dt.Columns.Add (new DataColumn ("Value2"));
2582                         dsTest.Tables.Add (dt);
2583                         dsTest.ReadXml (new StringReader (@"
2584 <diffgr:diffgram
2585    xmlns:msdata='urn:schemas-microsoft-com:xml-msdata'
2586    xmlns:diffgr='urn:schemas-microsoft-com:xml-diffgram-v1'>
2587   <MonoTouchTest>
2588     <_x0031_23 diffgr:id='1231' msdata:rowOrder='0'>
2589       <Value1>Row1Value1</Value1>
2590       <Value2>Row1Value2</Value2>
2591     </_x0031_23>
2592   </MonoTouchTest>
2593 </diffgr:diffgram>
2594 "));
2595                         Assert.AreEqual ("123", dsTest.Tables [0].TableName, "#1");
2596                         Assert.AreEqual (1, dsTest.Tables [0].Rows.Count, "#2");
2597                 }
2598
2599                 private void CompareTables (DataSet dsLoad) {
2600                         Assert.AreEqual (ds.Tables.Count, dsLoad.Tables.Count, "NumTables");
2601                         for (int tc = 0; tc < dsLoad.Tables.Count; tc++) {
2602                                 Assert.AreEqual (ds.Tables[tc].Columns.Count, dsLoad.Tables[tc].Columns.Count, "Table" + tc + "-NumCols");
2603                                 Assert.AreEqual (ds.Tables[tc].Rows.Count, dsLoad.Tables[tc].Rows.Count, "Table" + tc + "-NumRows");
2604                                 for (int cc = 0; cc < dsLoad.Tables[tc].Columns.Count; cc++) {
2605                                         Assert.AreEqual (ds.Tables[tc].Columns[cc].ColumnName,
2606                                                          dsLoad.Tables[tc].Columns[cc].ColumnName,
2607                                                          "Table" + tc + "-" + "Col" + cc + "-Name");
2608                                 }
2609                                 for (int rc = 0; rc < dsLoad.Tables[tc].Rows.Count; rc++) {
2610                                         for (int cc = 0; cc < dsLoad.Tables[tc].Columns.Count; cc++) {
2611                                                 Assert.AreEqual (ds.Tables[tc].Rows[rc].ItemArray[cc],
2612                                                                  dsLoad.Tables[tc].Rows[rc].ItemArray[cc],
2613                                                                  "Table" + tc + "-Row" + rc + "-Col" + cc + "-Data");
2614                                         }
2615                                 }
2616                         }
2617                 }
2618
2619                 #endregion // DataSet.CreateDataReader Tests and DataSet.Load Tests
2620 #endif
2621
2622         }
2623
2624          public  class MyDataSet:DataSet {
2625
2626              public static int count = 0;
2627
2628              public MyDataSet() {
2629
2630                     count++;
2631              }
2632
2633          }
2634
2635
2636 }