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

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