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