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

   1 // Authors:
   2 //   Nagappan A <anagappan@novell.com>
   3 //
   4 // Copyright (c) 2007 Novell, Inc
   5 //
   6 // Permission is hereby granted, free of charge, to any person obtaining
   7 // a copy of this software and associated documentation files (the
   8 // "Software"), to deal in the Software without restriction, including
   9 // without limitation the rights to use, copy, modify, merge, publish,
  10 // distribute, sublicense, and/or sell copies of the Software, and to
  11 // permit persons to whom the Software is furnished to do so, subject to
  12 // the following conditions:
  13 //
  14 // The above copyright notice and this permission notice shall be
  15 // included in all copies or substantial portions of the Software.
  16 //
  17 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  18 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  19 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  20 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  21 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  22 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  23 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  24 //
  25
  26 #if NET_2_0
  27 using System;
  28 using System.Data;
  29 using System.Collections;
  30 using System.IO;
  31 using System.Xml;
  32 using NUnit.Framework;
  33
  34 namespace Monotests_System.Data
  35 {
  36         [TestFixture]
  37         public class DataTableTest4
  38         {
  39                 string tempFile;
  40                 DataSet dataSet;
  41                 DataTable dummyTable;
  42                 DataTable parentTable1;
  43                 DataTable childTable;
  44                 DataTable secondChildTable;
  45
  46                 [SetUp]
  47                 public void SetUp ()
  48                 {
  49                         tempFile = Path.GetTempFileName ();
  50                 }
  51
  52                 [TearDown]
  53                 public void TearDown ()
  54                 {
  55                         if (tempFile != null)
  56                                 File.Delete (tempFile);
  57                 }
  58
  59                 private void MakeParentTable1 ()
  60                 {
  61                         // Create a new Table
  62                         parentTable1 = new DataTable ("ParentTable");
  63                         dataSet = new DataSet ("XmlDataSet");
  64                         DataColumn column;
  65                         DataRow row;
  66
  67                         // Create new DataColumn, set DataType,
  68                         // ColumnName and add to Table.
  69                         column = new DataColumn ();
  70                         column.DataType = typeof (int);
  71                         column.ColumnName = "id";
  72                         column.Unique = true;
  73                         // Add the Column to the DataColumnCollection.
  74                         parentTable1.Columns.Add (column);
  75
  76                         // Create second column
  77                         column = new DataColumn ();
  78                         column.DataType = typeof (string);
  79                         column.ColumnName = "ParentItem";
  80                         column.AutoIncrement = false;
  81                         column.Caption = "ParentItem";
  82                         column.Unique = false;
  83                         // Add the column to the table
  84                         parentTable1.Columns.Add (column);
  85
  86                         // Create third column.
  87                         column = new DataColumn ();
  88                         column.DataType = typeof (int);
  89                         column.ColumnName = "DepartmentID";
  90                         column.Caption = "DepartmentID";
  91                         // Add the column to the table.
  92                         parentTable1.Columns.Add (column);
  93
  94                         // Make the ID column the primary key column.
  95                         DataColumn [] PrimaryKeyColumns = new DataColumn [2];
  96                         PrimaryKeyColumns [0] = parentTable1.Columns ["id"];
  97                         PrimaryKeyColumns [1] = parentTable1.Columns ["DepartmentID"];
  98                         parentTable1.PrimaryKey = PrimaryKeyColumns;
  99                         dataSet.Tables.Add (parentTable1);
 100
 101                         // Create three new DataRow objects and add
 102                         // them to the DataTable
 103                         for (int i = 0; i <= 2; i++) {
 104                                 row = parentTable1.NewRow ();
 105                                 row ["id"] = i + 1 ;
 106                                 row ["ParentItem"] = "ParentItem " + (i + 1);
 107                                 row ["DepartmentID"] = i + 1;
 108                                 parentTable1.Rows.Add (row);
 109                         }
 110                 }
 111
 112                 private void MakeDummyTable ()
 113                 {
 114                         // Create a new Table
 115                         dataSet = new DataSet ();
 116                         dummyTable = new DataTable ("DummyTable");
 117                         DataColumn column;
 118                         DataRow row;
 119
 120                         // Create new DataColumn, set DataType,
 121                         // ColumnName and add to Table.
 122                         column = new DataColumn ();
 123                         column.DataType = typeof (int);
 124                         column.ColumnName = "id";
 125                         column.Unique = true;
 126                         // Add the Column to the DataColumnCollection.
 127                         dummyTable.Columns.Add (column);
 128
 129                         // Create second column
 130                         column = new DataColumn ();
 131                         column.DataType = typeof (string);
 132                         column.ColumnName = "DummyItem";
 133                         column.AutoIncrement = false;
 134                         column.Caption = "DummyItem";
 135                         column.Unique = false;
 136                         // Add the column to the table
 137                         dummyTable.Columns.Add (column);
 138                         dataSet.Tables.Add (dummyTable);
 139
 140                         // Create three new DataRow objects and add
 141                         // them to the DataTable
 142                         for (int i=0; i<=2; i++) {
 143                                 row = dummyTable.NewRow ();
 144                                 row ["id"] = i + 1 ;
 145                                 row ["DummyItem"] = "DummyItem " + (i + 1);
 146                                 dummyTable.Rows.Add (row);
 147                         }
 148
 149                         DataRow row1 = dummyTable.Rows [1];
 150                         dummyTable.AcceptChanges ();
 151                         row1.BeginEdit ();
 152                         row1 [1] = "Changed_DummyItem " + 2;
 153                         row1.EndEdit ();
 154                 }
 155
 156                 private void MakeChildTable ()
 157                 {
 158                         // Create a new Table
 159                         childTable = new DataTable ("ChildTable");
 160                         DataColumn column;
 161                         DataRow row;
 162
 163                         // Create first column and add to the DataTable.
 164                         column = new DataColumn ();
 165                         column.DataType= typeof (int);
 166                         column.ColumnName = "ChildID";
 167                         column.AutoIncrement = true;
 168                         column.Caption = "ID";
 169                         column.Unique = true;
 170
 171                         // Add the column to the DataColumnCollection
 172                         childTable.Columns.Add (column);
 173
 174                         // Create second column
 175                         column = new DataColumn ();
 176                         column.DataType= typeof (string);
 177                         column.ColumnName = "ChildItem";
 178                         column.AutoIncrement = false;
 179                         column.Caption = "ChildItem";
 180                         column.Unique = false;
 181                         childTable.Columns.Add (column);
 182
 183                         //Create third column
 184                         column = new DataColumn ();
 185                         column.DataType= typeof (int);
 186                         column.ColumnName = "ParentID";
 187                         column.AutoIncrement = false;
 188                         column.Caption = "ParentID";
 189                         column.Unique = false;
 190                         childTable.Columns.Add (column);
 191                         dataSet.Tables.Add (childTable);
 192
 193                         // Create three sets of DataRow objects,
 194                         // five rows each, and add to DataTable.
 195                         for (int i = 0; i <= 1; i ++) {
 196                                 row = childTable.NewRow ();
 197                                 row ["childID"] = i + 1;
 198                                 row ["ChildItem"] = "ChildItem " + (i + 1);
 199                                 row ["ParentID"] = 1 ;
 200                                 childTable.Rows.Add (row);
 201                         }
 202
 203                         for (int i=0; i<=1; i ++) {
 204                                 row = childTable.NewRow ();
 205                                 row ["childID"] = i + 5;
 206                                 row ["ChildItem"] = "ChildItem " + (i + 1);
 207                                 row ["ParentID"] = 2 ;
 208                                 childTable.Rows.Add (row);
 209                         }
 210
 211                         for (int i = 0; i <= 1; i ++) {
 212                                 row = childTable.NewRow ();
 213                                 row ["childID"] = i + 10;
 214                                 row ["ChildItem"] = "ChildItem " + (i + 1);
 215                                 row ["ParentID"] = 3 ;
 216                                 childTable.Rows.Add (row);
 217                         }
 218                 }
 219
 220                 private void MakeSecondChildTable ()
 221                 {
 222                         // Create a new Table
 223                         secondChildTable = new DataTable ("SecondChildTable");
 224                         DataColumn column;
 225                         DataRow row;
 226
 227                         // Create first column and add to the DataTable.
 228                         column = new DataColumn ();
 229                         column.DataType= typeof (int);
 230                         column.ColumnName = "ChildID";
 231                         column.AutoIncrement = true;
 232                         column.Caption = "ID";
 233                         column.ReadOnly = true;
 234                         column.Unique = true;
 235
 236                         // Add the column to the DataColumnCollection.
 237                         secondChildTable.Columns.Add (column);
 238
 239                         // Create second column.
 240                         column = new DataColumn ();
 241                         column.DataType= typeof (string);
 242                         column.ColumnName = "ChildItem";
 243                         column.AutoIncrement = false;
 244                         column.Caption = "ChildItem";
 245                         column.ReadOnly = false;
 246                         column.Unique = false;
 247                         secondChildTable.Columns.Add (column);
 248
 249                         //Create third column.
 250                         column = new DataColumn ();
 251                         column.DataType= typeof (int);
 252                         column.ColumnName = "ParentID";
 253                         column.AutoIncrement = false;
 254                         column.Caption = "ParentID";
 255                         column.ReadOnly = false;
 256                         column.Unique = false;
 257                         secondChildTable.Columns.Add (column);
 258
 259                         //Create fourth column.
 260                         column = new DataColumn ();
 261                         column.DataType= typeof (int);
 262                         column.ColumnName = "DepartmentID";
 263                         column.Caption = "DepartmentID";
 264                         column.Unique = false;
 265                         secondChildTable.Columns.Add (column);
 266                         dataSet.Tables.Add (secondChildTable);
 267
 268                         // Create three sets of DataRow objects,
 269                         // five rows each, and add to DataTable.
 270                         for (int i = 0; i <= 1; i ++) {
 271                                 row = secondChildTable.NewRow ();
 272                                 row ["childID"] = i + 1;
 273                                 row ["ChildItem"] = "SecondChildItem " + (i + 1);
 274                                 row ["ParentID"] = 1 ;
 275                                 row ["DepartmentID"] = 1;
 276                                 secondChildTable.Rows.Add (row);
 277                         }
 278
 279                         for (int i = 0; i <= 1; i++) {
 280                                 row = secondChildTable.NewRow ();
 281                                 row ["childID"] = i + 5;
 282                                 row ["ChildItem"] = "SecondChildItem " + (i + 1);
 283                                 row ["ParentID"] = 2;
 284                                 row ["DepartmentID"] = 2;
 285                                 secondChildTable.Rows.Add (row);
 286                         }
 287
 288                         for (int i = 0; i <= 1; i++) {
 289                                 row = secondChildTable.NewRow ();
 290                                 row ["childID"] = i + 10;
 291                                 row ["ChildItem"] = "SecondChildItem " + (i + 1);
 292                                 row ["ParentID"] = 3 ;
 293                                 row ["DepartmentID"] = 3;
 294                                 secondChildTable.Rows.Add (row);
 295                         }
 296                 }
 297
 298                 private void MakeDataRelation ()
 299                 {
 300                         DataColumn parentColumn = dataSet.Tables ["ParentTable"].Columns ["id"];
 301                         DataColumn childColumn = dataSet.Tables ["ChildTable"].Columns ["ParentID"];
 302                         DataRelation relation = new DataRelation ("ParentChild_Relation1", parentColumn, childColumn);
 303                         dataSet.Tables ["ChildTable"].ParentRelations.Add (relation);
 304
 305                         DataColumn [] parentColumn1 = new DataColumn [2];
 306                         DataColumn [] childColumn1 = new DataColumn [2];
 307
 308                         parentColumn1 [0] = dataSet.Tables ["ParentTable"].Columns ["id"];
 309                         parentColumn1 [1] = dataSet.Tables ["ParentTable"].Columns ["DepartmentID"];
 310
 311                         childColumn1 [0] = dataSet.Tables ["SecondChildTable"].Columns ["ParentID"];
 312                         childColumn1 [1] = dataSet.Tables ["SecondChildTable"].Columns ["DepartmentID"];
 313
 314                         DataRelation secondRelation = new DataRelation("ParentChild_Relation2", parentColumn1, childColumn1);
 315                         dataSet.Tables ["SecondChildTable"].ParentRelations.Add (secondRelation);
 316                 }
 317
 318                 //Test properties of a table which does not belongs to a DataSet
 319                 private void VerifyTableSchema (DataTable table, string tableName, DataSet ds)
 320                 {
 321                         //Test Schema
 322                         //Check Properties of Table
 323                         Assert.AreEqual (string.Empty, table.Namespace, "#1");
 324                         Assert.AreEqual (ds, table.DataSet, "#2");
 325                         Assert.AreEqual (3, table.Columns.Count, "#3");
 326                         Assert.AreEqual (false, table.CaseSensitive, "#5");
 327                         Assert.AreEqual (tableName, table.TableName, "#6");
 328                         Assert.AreEqual (2, table.Constraints.Count, "#7");
 329                         Assert.AreEqual (string.Empty, table.Prefix, "#8");
 330                         Assert.AreEqual ("Constraint1", table.Constraints [0].ToString (), "#9");
 331                         Assert.AreEqual ("Constraint2", table.Constraints [1].ToString (), "#10");
 332                         Assert.AreEqual (typeof (UniqueConstraint), table.Constraints [0].GetType (), "#11");
 333                         Assert.AreEqual (typeof (UniqueConstraint), table.Constraints [1].GetType (), "#12");
 334                         Assert.AreEqual (2, table.PrimaryKey.Length, "#13");
 335                         Assert.AreEqual ("id", table.PrimaryKey [0].ToString (), "#14");
 336                         Assert.AreEqual ("DepartmentID", table.PrimaryKey [1].ToString (), "#15");
 337                         Assert.AreEqual (0, table.ParentRelations.Count, "#16");
 338                         Assert.AreEqual (0, table.ChildRelations.Count, "#17");
 339
 340                         //Check properties of each column
 341                         //First Column
 342                         DataColumn col = table.Columns [0];
 343                         Assert.AreEqual (false, col.AllowDBNull, "#18");
 344                         Assert.AreEqual (false, col.AutoIncrement, "#19");
 345                         Assert.AreEqual (0, col.AutoIncrementSeed, "#20");
 346                         Assert.AreEqual (1, col.AutoIncrementStep, "#21");
 347                         Assert.AreEqual ("Element", col.ColumnMapping.ToString (), "#22");
 348                         Assert.AreEqual ("id", col.Caption, "#23");
 349                         Assert.AreEqual ("id", col.ColumnName, "#24");
 350                         Assert.AreEqual ("System.Int32", col.DataType.ToString (), "#25");
 351                         Assert.AreEqual (string.Empty, col.DefaultValue.ToString (), "#26");
 352                         Assert.AreEqual (false, col.DesignMode, "#27");
 353                         Assert.AreEqual ("System.Data.PropertyCollection", col.ExtendedProperties.ToString (), "#28");
 354                         Assert.AreEqual (-1, col.MaxLength, "#29");
 355                         Assert.AreEqual (0, col.Ordinal, "#30");
 356                         Assert.AreEqual (string.Empty, col.Prefix, "#31");
 357                         Assert.AreEqual ("ParentTable", col.Table.ToString (), "#32");
 358                         Assert.AreEqual (true, col.Unique, "#33");
 359
 360                         //Second Column
 361                         col = table.Columns [1];
 362                         Assert.AreEqual (true, col.AllowDBNull, "#34");
 363                         Assert.AreEqual (false, col.AutoIncrement, "#35");
 364                         Assert.AreEqual (0, col.AutoIncrementSeed, "#36");
 365                         Assert.AreEqual (1, col.AutoIncrementStep, "#37");
 366                         Assert.AreEqual ("Element", col.ColumnMapping.ToString (), "#38");
 367                         Assert.AreEqual ("ParentItem", col.Caption, "#39");
 368                         Assert.AreEqual ("ParentItem", col.ColumnName, "#40");
 369                         Assert.AreEqual ("System.String", col.DataType.ToString (), "#41");
 370                         Assert.AreEqual (string.Empty, col.DefaultValue.ToString (), "#42");
 371                         Assert.AreEqual (false, col.DesignMode, "#43");
 372                         Assert.AreEqual ("System.Data.PropertyCollection", col.ExtendedProperties.ToString (), "#44");
 373                         Assert.AreEqual (-1, col.MaxLength, "#45");
 374                         Assert.AreEqual (1, col.Ordinal, "#46");
 375                         Assert.AreEqual (string.Empty, col.Prefix, "#47");
 376                         Assert.AreEqual ("ParentTable", col.Table.ToString (), "#48");
 377                         Assert.AreEqual (false, col.Unique, "#49");
 378
 379                         //Third Column
 380                         col = table.Columns [2];
 381                         Assert.AreEqual (false, col.AllowDBNull, "#50");
 382                         Assert.AreEqual (false, col.AutoIncrement, "#51");
 383                         Assert.AreEqual (0, col.AutoIncrementSeed, "#52");
 384                         Assert.AreEqual (1, col.AutoIncrementStep, "#53");
 385                         Assert.AreEqual ("Element", col.ColumnMapping.ToString (), "#54");
 386                         Assert.AreEqual ("DepartmentID", col.Caption, "#55");
 387                         Assert.AreEqual ("DepartmentID", col.ColumnName, "#56");
 388                         Assert.AreEqual ("System.Int32", col.DataType.ToString (), "#57");
 389                         Assert.AreEqual (string.Empty, col.DefaultValue.ToString (), "#58");
 390                         Assert.AreEqual (false, col.DesignMode, "#59");
 391                         Assert.AreEqual ("System.Data.PropertyCollection", col.ExtendedProperties.ToString (), "#60");
 392                         Assert.AreEqual (-1, col.MaxLength, "#61");
 393                         Assert.AreEqual (2, col.Ordinal, "#62");
 394                         Assert.AreEqual (string.Empty, col.Prefix, "#63");
 395                         Assert.AreEqual ("ParentTable", col.Table.ToString (), "#64");
 396                         Assert.AreEqual (false, col.Unique, "#65");
 397
 398                         //Test the Xml
 399                         Assert.AreEqual (3, table.Rows.Count, "#66");
 400                         //Test values of each row
 401                         DataRow row = table.Rows [0];
 402                         Assert.AreEqual (1, row ["id"], "#67");
 403                         Assert.AreEqual ("ParentItem 1", row ["ParentItem"], "#68");
 404                         Assert.AreEqual (1, row ["DepartmentID"], "#69");
 405
 406                         row = table.Rows [1];
 407                         Assert.AreEqual (2, row ["id"], "#70");
 408                         Assert.AreEqual ("ParentItem 2", row ["ParentItem"], "#71");
 409                         Assert.AreEqual (2, row ["DepartmentID"], "#72");
 410
 411                         row = table.Rows [2];
 412                         Assert.AreEqual (3, row ["id"], "#73");
 413                         Assert.AreEqual ("ParentItem 3", row ["ParentItem"], "#74");
 414                         Assert.AreEqual (3, row ["DepartmentID"], "#75");
 415                 }
 416
 417                 private void VerifyTable_WithChildren (DataTable table, string tableName, DataSet ds)
 418                 {
 419                         //Test Schema
 420                         //Check Properties of Table
 421                         Assert.AreEqual (string.Empty, table.Namespace, "#1");
 422                         Assert.AreEqual (ds.DataSetName, table.DataSet.DataSetName, "#2");
 423                         Assert.AreEqual (3, table.Columns.Count, "#3");
 424                         Assert.AreEqual (false, table.CaseSensitive, "#5");
 425                         Assert.AreEqual (tableName, table.TableName, "#6");
 426                         Assert.AreEqual (2, table.Constraints.Count, "#7");
 427                         Assert.AreEqual (string.Empty, table.Prefix, "#8");
 428                         Assert.AreEqual ("Constraint1", table.Constraints [0].ToString (), "#9");
 429                         Assert.AreEqual ("Constraint2", table.Constraints [1].ToString (), "#10");
 430                         Assert.AreEqual ("System.Data.UniqueConstraint", table.Constraints [0].GetType ().ToString (), "#11");
 431                         Assert.AreEqual ("System.Data.UniqueConstraint", table.Constraints [1].GetType ().ToString (), "#12");
 432                         Assert.AreEqual (2, table.PrimaryKey.Length, "#13");
 433                         Assert.AreEqual ("id", table.PrimaryKey [0].ToString (), "#14");
 434                         Assert.AreEqual ("DepartmentID", table.PrimaryKey [1].ToString (), "#15");
 435                         Assert.AreEqual (0, table.ParentRelations.Count, "#16");
 436                         Assert.AreEqual (2, table.ChildRelations.Count, "#17");
 437
 438                         //Check properties of each column
 439                         //First Column
 440                         DataColumn col = table.Columns [0];
 441                         Assert.AreEqual (false, col.AllowDBNull, "#18");
 442                         Assert.AreEqual (false, col.AutoIncrement, "#19");
 443                         Assert.AreEqual (0, col.AutoIncrementSeed, "#20");
 444                         Assert.AreEqual (1, col.AutoIncrementStep, "#21");
 445                         Assert.AreEqual ("Element", col.ColumnMapping.ToString (), "#22");
 446                         Assert.AreEqual ("id", col.Caption, "#23");
 447                         Assert.AreEqual ("id", col.ColumnName, "#24");
 448                         Assert.AreEqual (typeof (int), col.DataType, "#25");
 449                         Assert.AreEqual (string.Empty, col.DefaultValue.ToString (), "#26");
 450                         Assert.AreEqual (false, col.DesignMode, "#27");
 451                         Assert.AreEqual ("System.Data.PropertyCollection", col.ExtendedProperties.ToString (), "#28");
 452                         Assert.AreEqual (-1, col.MaxLength, "#29");
 453                         Assert.AreEqual (0, col.Ordinal, "#30");
 454                         Assert.AreEqual (string.Empty, col.Prefix, "#31");
 455                         Assert.AreEqual ("ParentTable", col.Table.ToString (), "#32");
 456                         Assert.AreEqual (true, col.Unique, "#33");
 457
 458                         //Second Column
 459                         col = table.Columns [1];
 460                         Assert.AreEqual (true, col.AllowDBNull, "#34");
 461                         Assert.AreEqual (false, col.AutoIncrement, "#35");
 462                         Assert.AreEqual (0, col.AutoIncrementSeed, "#36");
 463                         Assert.AreEqual (1, col.AutoIncrementStep, "#37");
 464                         Assert.AreEqual ("Element", col.ColumnMapping.ToString (), "#38");
 465                         Assert.AreEqual ("ParentItem", col.Caption, "#39");
 466                         Assert.AreEqual ("ParentItem", col.ColumnName, "#40");
 467                         Assert.AreEqual (typeof (string), col.DataType, "#41");
 468                         Assert.AreEqual (string.Empty, col.DefaultValue.ToString (), "#42");
 469                         Assert.AreEqual (false, col.DesignMode, "#43");
 470                         Assert.AreEqual ("System.Data.PropertyCollection", col.ExtendedProperties.ToString (), "#44");
 471                         Assert.AreEqual (-1, col.MaxLength, "#45");
 472                         Assert.AreEqual (1, col.Ordinal, "#46");
 473                         Assert.AreEqual (string.Empty, col.Prefix, "#47");
 474                         Assert.AreEqual ("ParentTable", col.Table.ToString (), "#48");
 475                         Assert.AreEqual (false, col.Unique, "#49");
 476
 477                         //Third Column
 478                         col = table.Columns [2];
 479                         Assert.AreEqual (false, col.AllowDBNull, "#50");
 480                         Assert.AreEqual (false, col.AutoIncrement, "#51");
 481                         Assert.AreEqual (0, col.AutoIncrementSeed, "#52");
 482                         Assert.AreEqual (1, col.AutoIncrementStep, "#53");
 483                         Assert.AreEqual ("Element", col.ColumnMapping.ToString (), "#54");
 484                         Assert.AreEqual ("DepartmentID", col.Caption, "#55");
 485                         Assert.AreEqual ("DepartmentID", col.ColumnName, "#56");
 486                         Assert.AreEqual (typeof (int), col.DataType, "#57");
 487                         Assert.AreEqual (string.Empty, col.DefaultValue.ToString (), "#58");
 488                         Assert.AreEqual (false, col.DesignMode, "#59");
 489                         Assert.AreEqual ("System.Data.PropertyCollection", col.ExtendedProperties.ToString (), "#60");
 490                         Assert.AreEqual (-1, col.MaxLength, "#61");
 491                         Assert.AreEqual (2, col.Ordinal, "#62");
 492                         Assert.AreEqual (string.Empty, col.Prefix, "#63");
 493                         Assert.AreEqual ("ParentTable", col.Table.ToString (), "#64");
 494                         Assert.AreEqual (false, col.Unique, "#65");
 495
 496                         //Test the Xml
 497                         Assert.AreEqual (3, table.Rows.Count, "#66");
 498                         //Test values of each row
 499                         DataRow row = table.Rows [0];
 500                         Assert.AreEqual (1, row ["id"], "#67");
 501                         Assert.AreEqual ("ParentItem 1", row ["ParentItem"], "#68");
 502                         Assert.AreEqual (1, row ["DepartmentID"], "#69");
 503
 504                         row = table.Rows [1];
 505                         Assert.AreEqual (2, row ["id"], "#70");
 506                         Assert.AreEqual ("ParentItem 2", row ["ParentItem"], "#71");
 507                         Assert.AreEqual (2, row ["DepartmentID"], "#72");
 508
 509                         row = table.Rows [2];
 510                         Assert.AreEqual (3, row ["id"], "#73");
 511                         Assert.AreEqual ("ParentItem 3", row ["ParentItem"], "#74");
 512                         Assert.AreEqual (3, row ["DepartmentID"], "#75");
 513                 }
 514
 515                 private void VerifyDiffGramElement1 (XmlReader reader)
 516                 {
 517                         //This method checks the properties of the <id> element
 518                         Assert.AreEqual (true, reader.IsStartElement (), "#1");
 519                         Assert.AreEqual (3, reader.Depth, "#2");
 520                         Assert.AreEqual (false, reader.HasAttributes, "#3");
 521                         Assert.AreEqual (false, reader.HasValue, "#4");
 522                         Assert.AreEqual (false, reader.IsDefault, "#5");
 523                         Assert.AreEqual (false, reader.IsEmptyElement, "#6");
 524                         Assert.AreEqual ("id", reader.Name, "#7");
 525                         Assert.AreEqual ("id", reader.LocalName, "#8");
 526                         Assert.AreEqual (XmlNodeType.Element, reader.NodeType, "#9");
 527                 }
 528
 529                 private void VerifyDiffGramElement3 (XmlReader reader)
 530                 {
 531                         //This method checks the property of </id> end elem
 532                         Assert.AreEqual (false, reader.IsStartElement (), "#1");
 533                         Assert.AreEqual ("id", reader.Name, "#2");
 534                         Assert.AreEqual ("id", reader.LocalName, "#3");
 535                         Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType, "#4");
 536                 }
 537
 538                 private void VerifyDiffGramElement2 (XmlReader reader)
 539                 {
 540                         //This method tests the properties of the <DummyItem> elemnent
 541                         Assert.AreEqual (true, reader.IsStartElement (), "#1");
 542                         Assert.AreEqual (3, reader.Depth, "#2");
 543                         Assert.AreEqual (false, reader.HasAttributes, "#3");
 544                         Assert.AreEqual (false, reader.HasValue, "#4");
 545                         Assert.AreEqual (false, reader.IsDefault, "#5");
 546                         Assert.AreEqual (false, reader.IsEmptyElement, "#6");
 547                         Assert.AreEqual ("DummyItem", reader.Name, "#7");
 548                         Assert.AreEqual ("DummyItem", reader.LocalName, "#8");
 549                         Assert.AreEqual (XmlNodeType.Element, reader.NodeType, "#9");
 550                 }
 551
 552                 private void VerifyDiffGramElement4 (XmlReader reader)
 553                 {
 554                         //This method checks the properties of </DummyItem> end element
 555                         Assert.AreEqual (false, reader.IsStartElement (), "#1");
 556                         Assert.AreEqual ("DummyItem", reader.Name, "#2");
 557                         Assert.AreEqual ("DummyItem", reader.LocalName, "#3");
 558                         Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType, "#4");
 559                 }
 560
 561                 private void VerifyDiffGramElement5 (XmlReader reader)
 562                 {
 563                         //This method check the properties of </DummyTable> end element
 564                         Assert.AreEqual (false, reader.IsStartElement (), "#1");
 565                         Assert.AreEqual ("DummyTable", reader.Name, "#2");
 566                         Assert.AreEqual ("DummyTable", reader.LocalName, "#3");
 567                         Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType, "#4");
 568                 }
 569
 570                 [Test]
 571                 public void XmlTest1 ()
 572                 {
 573                         MakeParentTable1 ();
 574                         dataSet.Tables.Remove (parentTable1);
 575
 576                         using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
 577                                 //Write the XML without any Schema information
 578                                 parentTable1.WriteXml (stream);
 579                         }
 580
 581                         DataTable table = new DataTable ();
 582
 583                         using (FileStream stream = new FileStream (tempFile, FileMode.Open)) {
 584                                 try {
 585                                         table.ReadXml (stream);
 586                                         //Should throw an exception if the Xml
 587                                         // File has no schema and target table
 588                                         // too does not define any schema
 589                                         Assert.Fail ("#1");
 590                                 } catch (InvalidOperationException ex) {
 591                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
 592                                         Assert.IsNull (ex.InnerException, "#3");
 593                                         Assert.IsNotNull (ex.Message, "#4");
 594                                 }
 595                         }
 596                 }
 597
 598                 [Test]
 599                 public void XmlTest2 ()
 600                 {
 601                         //Make a table without any relations
 602                         MakeParentTable1 ();
 603                         dataSet.Tables.Remove (parentTable1);
 604
 605                         using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
 606                                 //Write Xml along with the Schema
 607                                 parentTable1.WriteXml (stream, XmlWriteMode.WriteSchema);
 608                         }
 609
 610                         DataTable table = new DataTable ();
 611                         //Read the Xml and the Schema into a table which does not belongs to any DataSet
 612                         table.ReadXml (tempFile);
 613                         VerifyTableSchema (table, parentTable1.TableName, parentTable1.DataSet);
 614                 }
 615
 616                 [Test]
 617                 public void XmlTest3 ()
 618                 {
 619                         //Make a table without any Relations
 620                         MakeParentTable1 ();
 621                         dataSet.Tables.Remove (parentTable1);
 622
 623                         using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
 624                                 //Write the Xml and the Schema
 625                                 parentTable1.WriteXml (stream, XmlWriteMode.WriteSchema);
 626                         }
 627
 628                         DataTable table = new DataTable ();
 629                         dataSet.Tables.Add (table);
 630
 631                         //Read the Xml and the Schema into a table which already belongs to a DataSet
 632                         //and the table name does not match with the table ion the source XML
 633                         try {
 634                                 table.ReadXml (tempFile);
 635                                 Assert.Fail ("#1");
 636                         } catch (ArgumentException ex) {
 637                                 // DataTable 'Table1' does not match to any
 638                                 // DataTable in source
 639                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 640                                 Assert.IsNull (ex.InnerException, "#3");
 641                                 Assert.IsNotNull (ex.Message, "#4");
 642                                 Assert.IsTrue (ex.Message.IndexOf ("'Table1'") != -1, "#5");
 643                                 Assert.IsNull (ex.ParamName, "#6");
 644                         }
 645                 }
 646
 647                 [Test]
 648                 public void XmlTest4 ()
 649                 {
 650                         MakeParentTable1 ();
 651
 652                         using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
 653                                 //Here the table belong to a dataset
 654                                 //Write the Xml and the Schema
 655                                 parentTable1.WriteXml (stream, XmlWriteMode.WriteSchema);
 656                         }
 657
 658                         DataTable table = new DataTable ("ParentTable");
 659                         //Read the Xml and the Schema into a table which already belongs to a DataSet
 660                         //and the table name matches with the table in the source XML
 661                         table.ReadXml (tempFile);
 662                         VerifyTableSchema (table, parentTable1.TableName, null);
 663                 }
 664
 665                 [Test]
 666                 public void XmlTest5 ()
 667                 {
 668                         //Create a parent table and create child tables
 669                         MakeParentTable1 ();
 670                         MakeChildTable ();
 671                         MakeSecondChildTable ();
 672                         //Relate the parent and the children
 673                         MakeDataRelation ();
 674
 675                         using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
 676                                 parentTable1.WriteXml (stream, XmlWriteMode.WriteSchema, false);
 677                         }
 678
 679                         DataTable table = new DataTable ();
 680                         table.ReadXml (tempFile);
 681                         VerifyTableSchema (table, parentTable1.TableName, null);
 682                 }
 683
 684                 [Test]
 685                 public void XmlTest6 ()
 686                 {
 687                         //Create a parent table and create child tables
 688                         MakeParentTable1 ();
 689                         MakeChildTable ();
 690                         MakeSecondChildTable ();
 691                         //Relate the parent and the children
 692                         MakeDataRelation ();
 693
 694                         using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
 695                                 parentTable1.WriteXml (stream, XmlWriteMode.WriteSchema, true);
 696                         }
 697
 698                         DataTable table = new DataTable ();
 699                         table.ReadXml (tempFile);
 700
 701                         VerifyTable_WithChildren (table, parentTable1.TableName, parentTable1.DataSet);
 702
 703                         //Check Properties of First Child Table
 704                         DataTable firstChildTable = table.ChildRelations [0].ChildTable;
 705                         Assert.AreEqual (string.Empty, firstChildTable.Namespace, "#1");
 706                         Assert.AreEqual ("XmlDataSet", firstChildTable.DataSet.DataSetName, "#2");
 707                         Assert.AreEqual (3, firstChildTable.Columns.Count, "#3");
 708                         Assert.AreEqual (typeof (int), firstChildTable.Columns [0].DataType, "#4");
 709                         Assert.AreEqual (typeof (string), firstChildTable.Columns [1].DataType, "#5");
 710                         Assert.AreEqual (typeof (int), firstChildTable.Columns [2].DataType, "#6");
 711                         Assert.AreEqual (6, firstChildTable.Rows.Count, "#7");
 712                         Assert.AreEqual (false, firstChildTable.CaseSensitive, "#8");
 713                         Assert.AreEqual ("ChildTable", firstChildTable.TableName, "#9");
 714                         Assert.AreEqual (string.Empty, firstChildTable.Prefix, "#10");
 715                         Assert.AreEqual (2, firstChildTable.Constraints.Count, "#11");
 716                         Assert.AreEqual ("Constraint1", firstChildTable.Constraints [0].ToString (), "#12");
 717                         Assert.AreEqual ("ParentChild_Relation1", firstChildTable.Constraints [1].ToString (), "#13");
 718                         Assert.AreEqual (1, firstChildTable.ParentRelations.Count, "#14");
 719                         Assert.AreEqual ("ParentTable", firstChildTable.ParentRelations [0].ParentTable.TableName, "#15");
 720                         Assert.AreEqual (0, firstChildTable.ChildRelations.Count, "#16");
 721                         Assert.AreEqual (0, firstChildTable.PrimaryKey.Length, "#17");
 722
 723                         //Check Properties of Second Child Table
 724                         DataTable secondChildTable = table.ChildRelations [1].ChildTable;
 725                         Assert.AreEqual (string.Empty, secondChildTable.Namespace, "#18");
 726                         Assert.AreEqual ("XmlDataSet", secondChildTable.DataSet.DataSetName, "#19");
 727                         Assert.AreEqual (4, secondChildTable.Columns.Count, "#20");
 728                         Assert.AreEqual (typeof (int), secondChildTable.Columns [0].DataType, "#21");
 729                         Assert.AreEqual (typeof (string), secondChildTable.Columns [1].DataType, "#22");
 730                         Assert.AreEqual (typeof (int), secondChildTable.Columns [2].DataType, "#23");
 731                         Assert.AreEqual (typeof (int), secondChildTable.Columns [3].DataType, "#24");
 732                         Assert.AreEqual (6, secondChildTable.Rows.Count, "#25");
 733                         Assert.AreEqual (false, secondChildTable.CaseSensitive, "#26");
 734                         Assert.AreEqual ("SecondChildTable", secondChildTable.TableName, "#27");
 735                         Assert.AreEqual (string.Empty, secondChildTable.Prefix, "#28");
 736                         Assert.AreEqual (2, secondChildTable.Constraints.Count, "#29");
 737                         Assert.AreEqual ("Constraint1", secondChildTable.Constraints [0].ToString (), "#30");
 738                         Assert.AreEqual ("ParentChild_Relation2", secondChildTable.Constraints [1].ToString (), "#31");
 739                         Assert.AreEqual (1, secondChildTable.ParentRelations.Count, "#32");;
 740                         Assert.AreEqual ("ParentTable", secondChildTable.ParentRelations [0].ParentTable.TableName, "#33");
 741                         Assert.AreEqual (0, secondChildTable.ChildRelations.Count, "#34");
 742                         Assert.AreEqual (0, secondChildTable.PrimaryKey.Length, "#35");
 743                 }
 744
 745                 [Test]
 746                 public void XmlTest7 ()
 747                 {
 748                         //Create a parent table and create child tables
 749                         MakeParentTable1 ();
 750                         MakeChildTable ();
 751                         MakeSecondChildTable ();
 752                         //Relate the parent and the children
 753                         MakeDataRelation ();
 754
 755                         using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
 756                                 //WriteXml on any of the children
 757                                 childTable.WriteXml (stream, XmlWriteMode.WriteSchema, false);
 758                         }
 759
 760                         DataTable table = new DataTable ();
 761                         table.ReadXml (tempFile);
 762
 763                         //Test Schema
 764                         //Check Properties of Table
 765                         Assert.AreEqual (string.Empty, table.Namespace, "#1");
 766                         Assert.AreEqual (null, table.DataSet, "#2");
 767                         Assert.AreEqual (3, table.Columns.Count, "#3");
 768                         Assert.AreEqual (false, table.CaseSensitive, "#5");
 769                         Assert.AreEqual ("ChildTable", table.TableName, "#6");
 770                         Assert.AreEqual (string.Empty, table.Prefix, "#7");
 771                         Assert.AreEqual (1, table.Constraints.Count, "#8");
 772                         Assert.AreEqual ("Constraint1", table.Constraints [0].ToString (), "#9");
 773                         Assert.AreEqual (typeof (UniqueConstraint), table.Constraints [0].GetType (), "#10");
 774                         Assert.AreEqual (0, table.PrimaryKey.Length, "#11");
 775                         Assert.AreEqual (0, table.ParentRelations.Count, "#12");
 776                         Assert.AreEqual (0, table.ChildRelations.Count, "#13");
 777
 778
 779                         //Check properties of each column
 780                         //First Column
 781                         DataColumn col = table.Columns [0];
 782                         Assert.AreEqual (true, col.AllowDBNull, "#14");
 783                         Assert.AreEqual (0, col.AutoIncrementSeed, "#15");
 784                         Assert.AreEqual (1, col.AutoIncrementStep, "#16");
 785                         Assert.AreEqual ("Element", col.ColumnMapping.ToString (), "#17");
 786                         Assert.AreEqual ("ChildID", col.Caption, "#18");
 787                         Assert.AreEqual ("ChildID", col.ColumnName, "#19");
 788                         Assert.AreEqual (typeof (int), col.DataType, "#20");
 789                         Assert.AreEqual (string.Empty, col.DefaultValue.ToString (), "#21");
 790                         Assert.AreEqual (false, col.DesignMode, "#22");
 791                         Assert.AreEqual ("System.Data.PropertyCollection", col.ExtendedProperties.ToString (), "#23");
 792                         Assert.AreEqual (-1, col.MaxLength, "#24");
 793                         Assert.AreEqual (0, col.Ordinal, "#25");
 794                         Assert.AreEqual (string.Empty, col.Prefix, "#26");
 795                         Assert.AreEqual ("ChildTable", col.Table.ToString (), "#27");
 796                         Assert.AreEqual (true, col.Unique, "#28");
 797
 798                         //Second Column
 799                         col = table.Columns [1];
 800                         Assert.AreEqual (true, col.AllowDBNull, "#29");
 801                         Assert.AreEqual (0, col.AutoIncrementSeed, "#30");
 802                         Assert.AreEqual (1, col.AutoIncrementStep, "#31");
 803                         Assert.AreEqual ("Element", col.ColumnMapping.ToString (), "#32");
 804                         Assert.AreEqual ("ChildItem", col.Caption, "#33");
 805                         Assert.AreEqual ("ChildItem", col.ColumnName, "#34");
 806                         Assert.AreEqual (typeof (string), col.DataType, "#35");
 807                         Assert.AreEqual (string.Empty, col.DefaultValue.ToString (), "#36");
 808                         Assert.AreEqual (false, col.DesignMode, "#37");
 809                         Assert.AreEqual ("System.Data.PropertyCollection", col.ExtendedProperties.ToString (), "#38");
 810                         Assert.AreEqual (-1, col.MaxLength, "#39");
 811                         Assert.AreEqual (1, col.Ordinal, "#40");
 812                         Assert.AreEqual (string.Empty, col.Prefix, "#41");
 813                         Assert.AreEqual ("ChildTable", col.Table.ToString (), "#42");
 814                         Assert.AreEqual (false, col.Unique, "#43");
 815
 816                         //Third Column
 817                         col = table.Columns [2];
 818                         Assert.AreEqual (true, col.AllowDBNull, "#44");
 819                         Assert.AreEqual (false, col.AutoIncrement, "#45");
 820                         Assert.AreEqual (0, col.AutoIncrementSeed, "#46");
 821                         Assert.AreEqual (1, col.AutoIncrementStep, "#47");
 822                         Assert.AreEqual ("Element", col.ColumnMapping.ToString (), "#48");
 823                         Assert.AreEqual ("ParentID", col.Caption, "#49");
 824                         Assert.AreEqual ("ParentID", col.ColumnName, "#50");
 825                         Assert.AreEqual (typeof (int), col.DataType, "#51");
 826                         Assert.AreEqual (string.Empty, col.DefaultValue.ToString (), "#52");
 827                         Assert.AreEqual (false, col.DesignMode, "#53");
 828                         Assert.AreEqual ("System.Data.PropertyCollection", col.ExtendedProperties.ToString (), "#54");
 829                         Assert.AreEqual (-1, col.MaxLength, "#55");
 830                         Assert.AreEqual (2, col.Ordinal, "#56");
 831                         Assert.AreEqual (string.Empty, col.Prefix, "#57");
 832                         Assert.AreEqual ("ChildTable", col.Table.ToString (), "#58");
 833                         Assert.AreEqual (false, col.Unique, "#59");
 834
 835                         //Test the Xml
 836                         Assert.AreEqual (6, table.Rows.Count, "#60");
 837
 838                         //Test values of each row
 839                         DataRow row = table.Rows [0];
 840                         Assert.AreEqual (1, row ["ChildID"], "#61");
 841                         Assert.AreEqual ("ChildItem 1", row ["ChildItem"], "#62");
 842                         Assert.AreEqual (1, row ["ParentID"], "#63");
 843
 844                         row = table.Rows [1];
 845                         Assert.AreEqual (2, row ["ChildID"], "#64");
 846                         Assert.AreEqual ("ChildItem 2", row ["ChildItem"], "#65");
 847                         Assert.AreEqual (1, row ["ParentID"], "#66");
 848
 849                         row = table.Rows [2];
 850                         Assert.AreEqual (5, row ["ChildID"], "#67");
 851                         Assert.AreEqual ("ChildItem 1", row ["ChildItem"], "#68");
 852                         Assert.AreEqual (2, row ["ParentID"], "#69");
 853
 854                         row = table.Rows [3];
 855                         Assert.AreEqual (6, row ["ChildID"], "#70");
 856                         Assert.AreEqual ("ChildItem 2", row ["ChildItem"], "#71");
 857                         Assert.AreEqual (2, row ["ParentID"], "#72");
 858
 859                         row = table.Rows [4];
 860                         Assert.AreEqual (10, row ["ChildID"], "#73");
 861                         Assert.AreEqual ("ChildItem 1", row ["ChildItem"], "#74");
 862                         Assert.AreEqual (3, row ["ParentID"], "#75");
 863
 864                         row = table.Rows [5];
 865                         Assert.AreEqual (11, row ["ChildID"], "#75");
 866                         Assert.AreEqual ("ChildItem 2", row ["ChildItem"], "#76");
 867                         Assert.AreEqual (3, row ["ParentID"], "#77");
 868                 }
 869
 870                 [Test]
 871                 public void XmlTest8 ()
 872                 {
 873                         MakeParentTable1 ();
 874                         MakeChildTable ();
 875                         MakeSecondChildTable ();
 876                         //Relate the parent and the children
 877                         MakeDataRelation ();
 878
 879                         using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
 880                                 //Write only the Xml
 881                                 parentTable1.WriteXml (stream, XmlWriteMode.IgnoreSchema, false);
 882                         }
 883
 884                         DataSet ds = new DataSet ();
 885                         ds.ReadXml (tempFile);
 886
 887                         Assert.AreEqual (1, ds.Tables.Count, "#1");
 888                         Assert.AreEqual ("ParentTable", ds.Tables [0].TableName, "#2");
 889                         DataTable table = ds.Tables [0];
 890
 891                         Assert.AreEqual (3, table.Rows.Count, "#3");
 892                         //Test values of each row
 893                         DataRow row = table.Rows [0];
 894                         Assert.AreEqual ("1", row ["id"], "#4");
 895                         Assert.AreEqual ("ParentItem 1", row ["ParentItem"], "#5");
 896                         Assert.AreEqual ("1", row ["DepartmentID"], "#6");
 897
 898                         row = table.Rows [1];
 899                         Assert.AreEqual ("2", row ["id"], "#7");
 900                         Assert.AreEqual ("ParentItem 2", row ["ParentItem"], "#8");
 901                         Assert.AreEqual ("2", row ["DepartmentID"], "#9");
 902
 903                         row = table.Rows [2];
 904                         Assert.AreEqual ("3", row ["id"], "#10");
 905                         Assert.AreEqual ("ParentItem 3", row ["ParentItem"], "#11");
 906                         Assert.AreEqual ("3", row ["DepartmentID"], "#12");
 907                 }
 908
 909                 [Test]
 910                 public void XmlTest9 ()
 911                 {
 912                         MakeParentTable1 ();
 913                         MakeChildTable ();
 914                         MakeSecondChildTable ();
 915                         //Relate the parent and the children
 916                         MakeDataRelation ();
 917
 918                         using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
 919                                 //Write only the Xml
 920                                 parentTable1.WriteXml (stream, XmlWriteMode.IgnoreSchema, true);
 921                         }
 922
 923                         DataSet ds = new DataSet ();
 924                         ds.ReadXml (tempFile);
 925
 926                         Assert.AreEqual (3, ds.Tables.Count, "#1");
 927                         Assert.AreEqual ("ParentTable", ds.Tables [0].TableName, "#2");
 928                         Assert.AreEqual ("ChildTable", ds.Tables [1].TableName, "#3");
 929                         Assert.AreEqual ("SecondChildTable", ds.Tables [2].TableName, "#4");
 930
 931                         //get the first table
 932                         DataTable table = ds.Tables [0];
 933                         Assert.AreEqual (3, table.Rows.Count, "#5");
 934
 935                         DataRow row = table.Rows [0];
 936                         Assert.AreEqual ("1", row ["id"], "#6");
 937                         Assert.AreEqual ("ParentItem 1", row ["ParentItem"], "#7");
 938                         Assert.AreEqual ("1", row ["DepartmentID"], "#8");
 939
 940                         row = table.Rows [1];
 941                         Assert.AreEqual ("2", row ["id"], "#9");
 942                         Assert.AreEqual ("ParentItem 2", row ["ParentItem"], "#10");
 943                         Assert.AreEqual ("2", row ["DepartmentID"], "#11");
 944
 945                         row = table.Rows [2];
 946                         Assert.AreEqual ("3", row ["id"], "#12");
 947                         Assert.AreEqual ("ParentItem 3", row ["ParentItem"], "#13");
 948                         Assert.AreEqual ("3", row ["DepartmentID"], "#14");
 949
 950                         //get the second table
 951                         table = ds.Tables [1];
 952                         Assert.AreEqual (6, table.Rows.Count);
 953
 954                         row = table.Rows [0];
 955                         Assert.AreEqual ("1", row ["ChildID"], "#15");
 956                         Assert.AreEqual ("ChildItem 1", row ["ChildItem"], "#16");
 957                         Assert.AreEqual ("1", row ["ParentID"], "#17");
 958
 959                         row = table.Rows [1];
 960                         Assert.AreEqual ("2", row ["ChildID"], "#18");
 961                         Assert.AreEqual ("ChildItem 2", row ["ChildItem"], "#19");
 962                         Assert.AreEqual ("1", row ["ParentID"], "#20");
 963
 964                         row = table.Rows [2];
 965                         Assert.AreEqual ("5", row ["ChildID"], "#21");
 966                         Assert.AreEqual ("ChildItem 1", row ["ChildItem"], "#22");
 967                         Assert.AreEqual ("2", row ["ParentID"], "#23");
 968
 969                         row = table.Rows [3];
 970                         Assert.AreEqual ("6", row ["ChildID"], "#24");
 971                         Assert.AreEqual ("ChildItem 2", row ["ChildItem"], "#25");
 972                         Assert.AreEqual ("2", row ["ParentID"], "#26");
 973
 974                         row = table.Rows [4];
 975                         Assert.AreEqual ("10", row ["ChildID"], "#27");
 976                         Assert.AreEqual ("ChildItem 1", row ["ChildItem"], "#28");
 977                         Assert.AreEqual ("3", row ["ParentID"], "#29");
 978
 979                         row = table.Rows [5];
 980                         Assert.AreEqual ("11", row ["ChildID"], "#30");
 981                         Assert.AreEqual ("ChildItem 2", row ["ChildItem"], "#31");
 982                         Assert.AreEqual ("3", row ["ParentID"], "#32");
 983
 984                         //get the third table
 985                         table = ds.Tables [2];
 986                         Assert.AreEqual (6, table.Rows.Count);
 987
 988                         row = table.Rows [0];
 989                         Assert.AreEqual ("1", row ["ChildID"], "#33");
 990                         Assert.AreEqual ("SecondChildItem 1", row ["ChildItem"], "#34");
 991                         Assert.AreEqual ("1", row ["ParentID"], "#35");
 992                         Assert.AreEqual ("1", row ["DepartmentID"], "#36");
 993
 994                         row = table.Rows [1];
 995                         Assert.AreEqual ("2", row ["ChildID"], "#37");
 996                         Assert.AreEqual ("SecondChildItem 2", row ["ChildItem"], "#38");
 997                         Assert.AreEqual ("1", row ["ParentID"], "#39");
 998                         Assert.AreEqual ("1", row ["DepartmentID"], "#40");
 999
1000                         row = table.Rows [2];
1001                         Assert.AreEqual ("5", row ["ChildID"], "#41");
1002                         Assert.AreEqual ("SecondChildItem 1", row ["ChildItem"], "#42");
1003                         Assert.AreEqual ("2", row ["ParentID"], "#43");
1004                         Assert.AreEqual ("2", row ["DepartmentID"], "#44");
1005
1006                         row = table.Rows [3];
1007                         Assert.AreEqual ("6", row ["ChildID"], "#45");
1008                         Assert.AreEqual ("SecondChildItem 2", row ["ChildItem"], "#46");
1009                         Assert.AreEqual ("2", row ["ParentID"], "#47");
1010                         Assert.AreEqual ("2", row ["DepartmentID"], "#48");
1011
1012                         row = table.Rows [4];
1013                         Assert.AreEqual ("10", row ["ChildID"], "#49");
1014                         Assert.AreEqual ("SecondChildItem 1", row ["ChildItem"], "#50");
1015                         Assert.AreEqual ("3", row ["ParentID"], "#51");
1016                         Assert.AreEqual ("3", row ["DepartmentID"], "#52");
1017
1018                         row = table.Rows [5];
1019                         Assert.AreEqual ("11", row ["ChildID"], "#53");
1020                         Assert.AreEqual ("SecondChildItem 2", row ["ChildItem"], "#54");
1021                         Assert.AreEqual ("3", row ["ParentID"], "#55");
1022                         Assert.AreEqual ("3", row ["DepartmentID"], "#56");
1023                 }
1024
1025                 [Test]
1026                 public void XmlTest10 ()
1027                 {
1028                         MakeDummyTable ();
1029
1030                         using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
1031                                 dummyTable.WriteXml (stream, XmlWriteMode.DiffGram);
1032                         }
1033
1034                         using (FileStream stream = new FileStream (tempFile, FileMode.Open)) {
1035                                 XmlReaderSettings settings = new XmlReaderSettings ();
1036                                 settings.IgnoreWhitespace = true;
1037                                 XmlReader reader = XmlReader.Create (stream, settings);
1038
1039                                 reader.Read ();
1040                                 Assert.AreEqual (true, reader.IsStartElement (), "#1");
1041                                 Assert.AreEqual (0, reader.Depth, "#2");
1042                                 Assert.AreEqual (true, reader.HasAttributes, "#3");
1043                                 Assert.AreEqual (false, reader.HasValue, "#4");
1044                                 Assert.AreEqual (false, reader.IsDefault, "#5");
1045                                 Assert.AreEqual (false, reader.IsEmptyElement, "#6");
1046                                 Assert.AreEqual ("diffgr:diffgram", reader.Name, "#7");
1047                                 Assert.AreEqual ("diffgram", reader.LocalName, "#8");
1048                                 Assert.AreEqual (2, reader.AttributeCount, "#9");
1049                                 Assert.AreEqual ("urn:schemas-microsoft-com:xml-msdata", reader [0], "#10");
1050                                 Assert.AreEqual ("urn:schemas-microsoft-com:xml-diffgram-v1", reader [1], "#11");
1051                                 Assert.AreEqual ("urn:schemas-microsoft-com:xml-diffgram-v1", reader.NamespaceURI, "#12");
1052                                 Assert.AreEqual (XmlNodeType.Element, reader.NodeType, "#13");
1053
1054                                 reader.Read ();
1055                                 Assert.AreEqual (true, reader.IsStartElement (), "#14");
1056                                 Assert.AreEqual (1, reader.Depth, "#15");
1057                                 Assert.AreEqual (false, reader.HasAttributes, "#16");
1058                                 Assert.AreEqual (false, reader.HasValue, "#17");
1059                                 Assert.AreEqual (false, reader.IsDefault, "#18");
1060                                 Assert.AreEqual (false, reader.IsEmptyElement, "#19");
1061                                 Assert.AreEqual ("NewDataSet", reader.Name, "#20");
1062                                 Assert.AreEqual ("NewDataSet", reader.LocalName, "#21");
1063                                 Assert.AreEqual (XmlNodeType.Element, reader.NodeType, "#22");
1064
1065                                 reader.Read ();
1066                                 Assert.AreEqual (true, reader.IsStartElement (), "#23");
1067                                 Assert.AreEqual (2, reader.Depth, "#24");
1068                                 Assert.AreEqual (true, reader.HasAttributes, "#25");
1069                                 Assert.AreEqual (false, reader.HasValue, "#26");
1070                                 Assert.AreEqual (false, reader.IsDefault, "#27");
1071                                 Assert.AreEqual (false, reader.IsEmptyElement, "#28");
1072                                 Assert.AreEqual ("DummyTable", reader.Name, "#29");
1073                                 Assert.AreEqual ("DummyTable", reader.LocalName, "#30");
1074                                 Assert.AreEqual (2, reader.AttributeCount, "#31");
1075                                 Assert.AreEqual ("DummyTable1", reader [0], "#32");
1076                                 Assert.AreEqual ("0", reader [1], "#33");
1077                                 Assert.AreEqual (XmlNodeType.Element, reader.NodeType, "#34");
1078
1079                                 reader.Read ();
1080                                 VerifyDiffGramElement1 (reader);
1081
1082                                 reader.Read ();
1083                                 Assert.AreEqual (XmlNodeType.Text, reader.NodeType, "#35");
1084                                 Assert.AreEqual (true, reader.HasValue, "#36");
1085                                 Assert.AreEqual ("1", reader.Value, "#37");
1086
1087                                 reader.Read ();
1088                                 VerifyDiffGramElement3 (reader);
1089
1090                                 reader.Read ();
1091                                 VerifyDiffGramElement2 (reader);
1092
1093                                 reader.Read ();
1094                                 Assert.AreEqual (XmlNodeType.Text, reader.NodeType, "#38");
1095                                 Assert.AreEqual (true, reader.HasValue, "#39");
1096                                 Assert.AreEqual ("DummyItem 1", reader.Value, "#40");
1097
1098                                 reader.Read ();
1099                                 Assert.AreEqual (false, reader.IsStartElement (), "#41");
1100                                 Assert.AreEqual ("DummyItem", reader.Name, "#42");
1101                                 Assert.AreEqual ("DummyItem", reader.LocalName, "#43");
1102                                 Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType, "#44");
1103
1104                                 reader.Read ();
1105                                 Assert.AreEqual (false, reader.IsStartElement (), "#45");
1106                                 Assert.AreEqual ("DummyTable", reader.Name, "#46");
1107                                 Assert.AreEqual ("DummyTable", reader.LocalName, "#47");
1108                                 Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType, "#48");
1109
1110                                 reader.Read ();
1111                                 Assert.AreEqual (true, reader.IsStartElement (), "#49");
1112                                 Assert.AreEqual (2, reader.Depth, "#50");
1113                                 Assert.AreEqual (true, reader.HasAttributes, "#51");
1114                                 Assert.AreEqual (false, reader.HasValue, "#52");
1115                                 Assert.AreEqual (false, reader.IsDefault, "#53");
1116                                 Assert.AreEqual (false, reader.IsEmptyElement, "#54");
1117                                 Assert.AreEqual ("DummyTable", reader.Name, "#55");
1118                                 Assert.AreEqual ("DummyTable", reader.LocalName, "#56");
1119                                 Assert.AreEqual (3, reader.AttributeCount, "#57");
1120                                 Assert.AreEqual ("DummyTable2", reader [0], "#58");
1121                                 Assert.AreEqual ("1", reader [1], "#59");
1122                                 Assert.AreEqual ("modified", reader [2], "#60");
1123                                 Assert.AreEqual (XmlNodeType.Element, reader.NodeType, "#61");
1124
1125                                 reader.Read ();
1126                                 VerifyDiffGramElement1 (reader);
1127
1128                                 reader.Read ();
1129                                 Assert.AreEqual (XmlNodeType.Text, reader.NodeType, "#62");
1130                                 Assert.AreEqual (true, reader.HasValue, "#63");
1131                                 Assert.AreEqual ("2", reader.Value, "#64");
1132
1133                                 reader.Read ();
1134                                 VerifyDiffGramElement3 (reader);
1135
1136                                 reader.Read ();
1137                                 VerifyDiffGramElement2 (reader);
1138
1139                                 reader.Read ();
1140                                 Assert.AreEqual (XmlNodeType.Text, reader.NodeType, "#65");
1141                                 Assert.AreEqual (true, reader.HasValue, "#66");
1142                                 Assert.AreEqual ("Changed_DummyItem 2", reader.Value, "#67");
1143
1144                                 reader.Read ();
1145                                 VerifyDiffGramElement4 (reader);
1146
1147                                 reader.Read ();
1148                                 VerifyDiffGramElement5 (reader);
1149
1150                                 reader.Read ();
1151                                 Assert.AreEqual (true, reader.IsStartElement (), "#68");
1152                                 Assert.AreEqual (2, reader.Depth, "#69");
1153                                 Assert.AreEqual (true, reader.HasAttributes, "#70");
1154                                 Assert.AreEqual (false, reader.HasValue, "#71");
1155                                 Assert.AreEqual (false, reader.IsDefault, "#72");
1156                                 Assert.AreEqual (false, reader.IsEmptyElement, "#73");
1157                                 Assert.AreEqual ("DummyTable", reader.Name, "#74");
1158                                 Assert.AreEqual ("DummyTable", reader.LocalName, "#75");
1159                                 Assert.AreEqual (2, reader.AttributeCount, "#76");
1160                                 Assert.AreEqual ("DummyTable3", reader [0], "#77");
1161                                 Assert.AreEqual ("2", reader [1], "#78");
1162                                 Assert.AreEqual (XmlNodeType.Element, reader.NodeType, "#79");
1163
1164                                 reader.Read ();
1165                                 VerifyDiffGramElement1 (reader);
1166
1167                                 reader.Read ();
1168                                 Assert.AreEqual (XmlNodeType.Text, reader.NodeType, "#80");
1169                                 Assert.AreEqual (true, reader.HasValue, "#81");
1170                                 Assert.AreEqual ("3", reader.Value, "#82");
1171
1172                                 reader.Read ();
1173                                 VerifyDiffGramElement3 (reader);
1174
1175                                 reader.Read ();
1176                                 VerifyDiffGramElement2 (reader);
1177
1178
1179                                 reader.Read();
1180                                 Assert.AreEqual (XmlNodeType.Text, reader.NodeType, "#83");
1181                                 Assert.AreEqual (true, reader.HasValue, "#84");
1182                                 Assert.AreEqual ("DummyItem 3", reader.Value, "#85");
1183
1184                                 reader.Read ();
1185                                 VerifyDiffGramElement4 (reader);
1186
1187                                 reader.Read ();
1188                                 VerifyDiffGramElement5 (reader);
1189
1190                                 reader.Read ();
1191                                 Assert.AreEqual (false, reader.IsStartElement (), "#86");
1192                                 Assert.AreEqual ("NewDataSet", reader.Name, "#87");
1193                                 Assert.AreEqual ("NewDataSet", reader.LocalName, "#88");
1194                                 Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType, "#89");
1195
1196                                 reader.Read ();
1197                                 Assert.AreEqual (true, reader.IsStartElement (), "#90");
1198                                 Assert.AreEqual (1, reader.Depth, "#91");
1199                                 Assert.AreEqual (false, reader.HasAttributes, "#92");
1200                                 Assert.AreEqual (false, reader.HasValue, "#93");
1201                                 Assert.AreEqual (false, reader.IsDefault, "#94");
1202                                 Assert.AreEqual (false, reader.IsEmptyElement, "#95");
1203                                 Assert.AreEqual ("diffgr:before", reader.Name, "#96");
1204                                 Assert.AreEqual ("before", reader.LocalName, "#97");
1205                                 Assert.AreEqual (XmlNodeType.Element, reader.NodeType, "#98");
1206
1207                                 reader.Read ();
1208                                 Assert.AreEqual (true, reader.IsStartElement (), "#99");
1209                                 Assert.AreEqual (2, reader.Depth, "#100");
1210                                 Assert.AreEqual (true, reader.HasAttributes, "#101");
1211                                 Assert.AreEqual (false, reader.HasValue, "#102");
1212                                 Assert.AreEqual (false, reader.IsDefault, "#103");
1213                                 Assert.AreEqual (false, reader.IsEmptyElement, "#104");
1214                                 Assert.AreEqual ("DummyTable", reader.Name, "#105");
1215                                 Assert.AreEqual ("DummyTable", reader.LocalName, "#106");
1216                                 Assert.AreEqual (2, reader.AttributeCount, "#107");
1217                                 Assert.AreEqual ("DummyTable2", reader [0], "#108");
1218                                 Assert.AreEqual ("1", reader [1], "#109");
1219                                 Assert.AreEqual (XmlNodeType.Element, reader.NodeType, "#110");
1220
1221                                 reader.Read ();
1222                                 VerifyDiffGramElement1 (reader);
1223
1224                                 reader.Read ();
1225                                 Assert.AreEqual (XmlNodeType.Text, reader.NodeType, "#111");
1226                                 Assert.AreEqual (true, reader.HasValue, "#112");
1227                                 Assert.AreEqual ("2", reader.Value, "#113");
1228
1229                                 reader.Read ();
1230                                 VerifyDiffGramElement3 (reader);
1231
1232                                 reader.Read ();
1233                                 VerifyDiffGramElement2 (reader);
1234
1235                                 reader.Read ();
1236                                 Assert.AreEqual (XmlNodeType.Text, reader.NodeType, "#114");
1237                                 Assert.AreEqual (true, reader.HasValue, "#115");
1238                                 Assert.AreEqual ("DummyItem 2", reader.Value, "#116");
1239
1240                                 reader.Read ();
1241                                 VerifyDiffGramElement4 (reader);
1242
1243                                 reader.Read ();
1244                                 VerifyDiffGramElement5 (reader);
1245
1246                                 reader.Read ();
1247                                 Assert.AreEqual (false, reader.IsStartElement (), "#117");
1248                                 Assert.AreEqual ("diffgr:before", reader.Name, "#118");
1249                                 Assert.AreEqual ("before", reader.LocalName, "#119");
1250                                 Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType, "#120");
1251
1252                                 reader.Read ();
1253                                 Assert.AreEqual (false, reader.IsStartElement (), "#121");
1254                                 Assert.AreEqual ("diffgr:diffgram", reader.Name, "#122");
1255                                 Assert.AreEqual ("diffgram", reader.LocalName, "#123");
1256                                 Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType, "#124");
1257                         }
1258                 }
1259
1260                 [Test]
1261                 public void XmlTest11 ()
1262                 {
1263                         MakeParentTable1 ();
1264
1265                         using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
1266                                 parentTable1.WriteXml (stream, XmlWriteMode.IgnoreSchema);
1267                         }
1268
1269                         XmlReadMode mode = XmlReadMode.Auto;
1270                         DataTable table = new DataTable ();
1271                         table.Columns.Add (new DataColumn ("id", typeof (int)));
1272
1273                         using (FileStream stream = new FileStream (tempFile, FileMode.Open)) {
1274                                 //This should not read anything as table name is not set
1275                                 mode = table.ReadXml (stream);
1276                         }
1277
1278                         Assert.AreEqual (XmlReadMode.IgnoreSchema, mode, "#1");
1279                         Assert.AreEqual (String.Empty, table.TableName, "#2");
1280                         Assert.AreEqual (0, table.Rows.Count, "#3");
1281                         Assert.AreEqual (1, table.Columns.Count, "#4");
1282                         Assert.AreEqual (typeof (int), table.Columns [0].DataType, "#5");
1283                         Assert.IsNull (table.DataSet, "#6");
1284                 }
1285
1286                 [Test]
1287                 public void XmlTest12 ()
1288                 {
1289                         MakeParentTable1 ();
1290
1291                         using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
1292                                 parentTable1.WriteXml (stream, XmlWriteMode.IgnoreSchema);
1293                         }
1294
1295                         DataTable table = new DataTable ("Table1");
1296                         XmlReadMode mode = XmlReadMode.Auto;
1297                         table.Columns.Add (new DataColumn ("id", typeof (int)));
1298
1299                         using (FileStream stream = new FileStream (tempFile, FileMode.Open)) {
1300                                 //Same as last test. ReadXml does not read anything as table names dont match
1301                                 mode = table.ReadXml (stream);
1302                         }
1303
1304                         Assert.AreEqual (XmlReadMode.IgnoreSchema, mode, "#1");
1305                         Assert.AreEqual ("Table1", table.TableName, "#2");
1306                         Assert.AreEqual (0, table.Rows.Count, "#3");
1307                         Assert.AreEqual (1, table.Columns.Count, "#4");
1308                         Assert.AreEqual (typeof (int), table.Columns [0].DataType, "#5");
1309                         Assert.IsNull (table.DataSet, "#6");
1310                 }
1311
1312                 [Test]
1313                 public void XmlTest13 ()
1314                 {
1315                         MakeParentTable1 ();
1316
1317                         using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
1318                                 parentTable1.WriteXml (stream, XmlWriteMode.IgnoreSchema);
1319                         }
1320
1321                         DataTable table = new DataTable ("ParentTable");
1322                         XmlReadMode mode = XmlReadMode.Auto;
1323                         table.Columns.Add (new DataColumn ("id", typeof (string)));
1324
1325                         using (FileStream stream = new FileStream (tempFile, FileMode.Open)) {
1326                                 mode = table.ReadXml (stream);
1327                         }
1328
1329                         Assert.AreEqual (XmlReadMode.IgnoreSchema, mode, "#1");
1330                         Assert.AreEqual ("ParentTable", table.TableName, "#2");
1331                         Assert.AreEqual (3, table.Rows.Count, "#3");
1332                         Assert.AreEqual (1, table.Columns.Count, "#4");
1333                         Assert.AreEqual (typeof (string), table.Columns [0].DataType, "#5");
1334                         Assert.IsNull (table.DataSet, "#6");
1335
1336                         //Check Rows
1337                         DataRow row = table.Rows [0];
1338                         Assert.AreEqual ("1", row [0], "#7");
1339
1340                         row = table.Rows [1];
1341                         Assert.AreEqual ("2", row [0], "#8");
1342
1343                         row = table.Rows [2];
1344                         Assert.AreEqual ("3", row [0], "#9");
1345                 }
1346
1347                 [Test]
1348                 public void XmlTest14 ()
1349                 {
1350                         MakeParentTable1 ();
1351
1352                         using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
1353                                 parentTable1.WriteXml (stream, XmlWriteMode.IgnoreSchema);
1354                         }
1355
1356                         //Create a target table which has nomatching column(s) names
1357                         DataTable table = new DataTable ("ParentTable");
1358                         XmlReadMode mode = XmlReadMode.Auto;
1359                         table.Columns.Add (new DataColumn ("sid", typeof (string)));
1360
1361                         using (FileStream stream = new FileStream (tempFile, FileMode.Open)) {
1362                                 //ReadXml does not read anything as the column names are not matching
1363                                 mode = table.ReadXml (stream);
1364                         }
1365
1366                         Assert.AreEqual (XmlReadMode.IgnoreSchema, mode, "#1");
1367                         Assert.AreEqual ("ParentTable", table.TableName, "#2");
1368                         Assert.AreEqual (3, table.Rows.Count, "#3");
1369                         Assert.AreEqual (1, table.Columns.Count, "#4");
1370                         Assert.AreEqual ("sid", table.Columns [0].ColumnName, "#5");
1371                         Assert.AreEqual (typeof (string), table.Columns [0].DataType, "#6");
1372                         Assert.IsNull (table.DataSet, "#7");
1373
1374                         //Check the rows
1375                         foreach (DataRow row in table.Rows)
1376                                 Assert.IsNull (row [0], "#8");
1377                 }
1378
1379                 [Test]
1380                 public void XmlTest15 ()
1381                 {
1382                         MakeParentTable1 ();
1383
1384                         using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
1385                                 parentTable1.WriteXml (stream, XmlWriteMode.IgnoreSchema);
1386                         }
1387
1388                         //Create a target table which has matching column(s) name and an extra column
1389                         DataTable table = new DataTable ("ParentTable");
1390                         XmlReadMode mode = XmlReadMode.Auto;
1391                         table.Columns.Add (new DataColumn ("id", typeof (int)));
1392                         table.Columns.Add (new DataColumn ("ParentItem", typeof (string)));
1393                         table.Columns.Add (new DataColumn ("DepartmentID", typeof (int)));
1394                         table.Columns.Add (new DataColumn ("DummyColumn", typeof (string)));
1395
1396                         using (FileStream stream = new FileStream (tempFile, FileMode.Open)) {
1397                                 mode = table.ReadXml (stream);
1398                         }
1399
1400                         Assert.AreEqual (XmlReadMode.IgnoreSchema, mode, "#1");
1401                         Assert.AreEqual ("ParentTable", table.TableName, "#2");
1402                         Assert.AreEqual (3, table.Rows.Count, "#3");
1403                         Assert.AreEqual (4, table.Columns.Count, "#4");
1404                         Assert.IsNull (table.DataSet, "#5");
1405
1406                         //Check the Columns
1407                         Assert.AreEqual ("id", table.Columns [0].ColumnName, "#6");
1408                         Assert.AreEqual (typeof (int), table.Columns [0].DataType, "#7");
1409
1410                         Assert.AreEqual ("ParentItem", table.Columns [1].ColumnName, "#8");
1411                         Assert.AreEqual (typeof (string), table.Columns [1].DataType, "#9");
1412
1413                         Assert.AreEqual ("DepartmentID", table.Columns [2].ColumnName, "#10");
1414                         Assert.AreEqual (typeof (int), table.Columns [2].DataType, "#11");
1415
1416                         Assert.AreEqual ("DummyColumn", table.Columns [3].ColumnName, "#12");
1417                         Assert.AreEqual (typeof (string), table.Columns [3].DataType, "#13");
1418
1419                         //Check the rows
1420                         DataRow row = table.Rows [0];
1421                         Assert.AreEqual (1, row ["id"], "#14");
1422                         Assert.AreEqual ("ParentItem 1", row ["ParentItem"], "#15");
1423                         Assert.AreEqual (1, row ["DepartmentID"], "#16");
1424                         Assert.IsNull (row ["DummyColumn"], "#17");
1425
1426                         row = table.Rows [1];
1427                         Assert.AreEqual (2, row ["id"], "#18");
1428                         Assert.AreEqual ("ParentItem 2", row ["ParentItem"], "#19");
1429                         Assert.AreEqual (2, row ["DepartmentID"], "#20");
1430                         Assert.IsNull (row ["DummyColumn"], "#21");
1431
1432                         row = table.Rows [2];
1433                         Assert.AreEqual (3, row ["id"], "#22");
1434                         Assert.AreEqual ("ParentItem 3", row ["ParentItem"], "#23");
1435                         Assert.AreEqual (3, row ["DepartmentID"], "#24");
1436                         Assert.IsNull (row ["DummyColumn"], "#25");
1437                 }
1438
1439                 [Test]
1440                 public void XmlTest16 ()
1441                 {
1442                         MakeParentTable1 ();
1443
1444                         using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
1445                                 //Write the Xml with schema information
1446                                 parentTable1.WriteXml (stream, XmlWriteMode.WriteSchema);
1447                         }
1448
1449                         XmlReadMode mode = XmlReadMode.Auto ;
1450                         DataTable table = new DataTable ();
1451                         table.Columns.Add (new DataColumn ("id", typeof (int)));
1452
1453                         using (FileStream stream = new FileStream (tempFile, FileMode.Open)) {
1454                                 mode = table.ReadXml (stream);
1455                         }
1456
1457                         Assert.AreEqual (XmlReadMode.ReadSchema, mode, "#1");
1458                         Assert.AreEqual (String.Empty, table.TableName, "#2");
1459                         Assert.AreEqual (0, table.Rows.Count, "#3");
1460                         Assert.AreEqual (1, table.Columns.Count, "#4");
1461                         Assert.AreEqual (typeof (int), table.Columns [0].DataType, "#5");
1462                         Assert.IsNull (table.DataSet, "#6");
1463                 }
1464
1465                 [Test]
1466                 public void XmlTest17 ()
1467                 {
1468                         MakeParentTable1 ();
1469
1470                         using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
1471                                 parentTable1.WriteXml (stream, XmlWriteMode.WriteSchema);
1472                         }
1473
1474                         using (FileStream stream = new FileStream (tempFile, FileMode.Open)) {
1475                                 DataTable table = new DataTable ("Table1");
1476                                 table.Columns.Add (new DataColumn ("id", typeof (int)));
1477
1478                                 try {
1479                                         table.ReadXml (stream);
1480                                         Assert.Fail ("#1");
1481                                 } catch (ArgumentException ex) {
1482                                         // DataTable 'Table1' does not match to
1483                                         // any DataTable in source
1484                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1485                                         Assert.IsNull (ex.InnerException, "#3");
1486                                         Assert.IsNotNull (ex.Message, "#4");
1487                                         Assert.IsTrue (ex.Message.IndexOf ("'Table1'") != -1, "#5");
1488                                         Assert.IsNull (ex.ParamName, "#6");
1489                                 }
1490                         }
1491                 }
1492
1493                 [Test]
1494                 public void XmlTest18 ()
1495                 {
1496                         MakeParentTable1 ();
1497
1498                         using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
1499                                 parentTable1.WriteXml (stream, XmlWriteMode.WriteSchema);
1500                         }
1501
1502                         DataTable table = new DataTable ("ParentTable");
1503                         XmlReadMode mode = XmlReadMode.Auto;
1504                         table.Columns.Add (new DataColumn ("id", typeof (int)));
1505                         table.Columns.Add (new DataColumn ("DepartmentID", typeof (int)));
1506
1507                         using (FileStream stream = new FileStream (tempFile, FileMode.Open)) {
1508                                 mode = table.ReadXml (stream);
1509                         }
1510
1511                         Assert.AreEqual (XmlReadMode.ReadSchema, mode, "#1");
1512                         Assert.AreEqual ("ParentTable", table.TableName, "#2");
1513                         Assert.AreEqual (3, table.Rows.Count, "#3");
1514                         Assert.AreEqual (2, table.Columns.Count, "#4");
1515                         Assert.AreEqual (typeof (int), table.Columns [0].DataType, "#5");
1516                         Assert.AreEqual (typeof (int), table.Columns [1].DataType, "#6");
1517                         Assert.IsNull (table.DataSet, "#6");
1518
1519                         //Check rows
1520                         DataRow row = table.Rows [0];
1521                         Assert.AreEqual (1, row [0], "#7");
1522                         Assert.AreEqual (1, row [1], "#8");
1523
1524                         row = table.Rows [1];
1525                         Assert.AreEqual (2, row [0], "#9");
1526                         Assert.AreEqual (2, row [1], "#10");
1527
1528                         row = table.Rows [2];
1529                         Assert.AreEqual (3, row [0], "#11");
1530                         Assert.AreEqual (3, row [1], "#12");
1531                 }
1532
1533                 [Test]
1534                 public void XmlTest19 ()
1535                 {
1536                         MakeParentTable1 ();
1537
1538                         using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
1539                                 parentTable1.WriteXml (stream, XmlWriteMode.IgnoreSchema);
1540                         }
1541
1542                         DataSet ds = new DataSet ();
1543                         DataTable table = new DataTable ();
1544                         XmlReadMode mode = XmlReadMode.Auto;
1545                         table.Columns.Add (new DataColumn ("id", typeof (int)));
1546                         ds.Tables.Add (table);
1547
1548                         using (FileStream stream = new FileStream (tempFile, FileMode.Open)) {
1549                                 //ReadXml wont read anything as TableNames dont match
1550                                 mode = table.ReadXml (stream);
1551                         }
1552
1553                         Assert.AreEqual (XmlReadMode.IgnoreSchema, mode, "#1");
1554                         Assert.AreEqual ("Table1", table.TableName, "#2");
1555                         Assert.AreEqual (0, table.Rows.Count, "#3");
1556                         Assert.AreEqual (1, table.Columns.Count, "#4");
1557                         Assert.AreEqual (typeof (int), table.Columns [0].DataType, "#5");
1558                         Assert.AreEqual ("System.Data.DataSet", table.DataSet.ToString (), "#6");
1559                         Assert.AreEqual ("NewDataSet", table.DataSet.DataSetName, "#7");
1560                 }
1561
1562                 [Test]
1563                 public void XmlTest20 ()
1564                 {
1565                         MakeParentTable1 ();
1566
1567                         using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
1568                                 parentTable1.WriteXml (stream, XmlWriteMode.IgnoreSchema);
1569                         }
1570
1571                         DataSet ds = new DataSet ();
1572                         DataTable table = new DataTable ("HelloWorldTable");
1573                         XmlReadMode mode = XmlReadMode.Auto;
1574                         table.Columns.Add (new DataColumn ("id", typeof (int)));
1575                         ds.Tables.Add (table);
1576
1577                         using (FileStream stream = new FileStream (tempFile, FileMode.Open)) {
1578                                 //ReadXml wont read anything as TableNames dont match
1579                                 mode = table.ReadXml (stream);
1580                         }
1581
1582                         Assert.AreEqual (XmlReadMode.IgnoreSchema, mode, "#1");
1583                         Assert.AreEqual ("HelloWorldTable", table.TableName, "#2");
1584                         Assert.AreEqual (0, table.Rows.Count, "#3");
1585                         Assert.AreEqual (1, table.Columns.Count, "#4");
1586                         Assert.AreEqual (typeof (int), table.Columns [0].DataType, "#5");
1587                         Assert.AreEqual ("System.Data.DataSet", table.DataSet.ToString (), "#6");
1588                         Assert.AreEqual ("NewDataSet", table.DataSet.DataSetName, "#7");
1589                 }
1590
1591                 [Test]
1592                 public void XmlTest21 ()
1593                 {
1594                         MakeParentTable1 ();
1595
1596                         using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
1597                                 parentTable1.WriteXml (stream, XmlWriteMode.IgnoreSchema);
1598                         }
1599
1600                         DataSet ds = new DataSet ();
1601                         DataTable table = new DataTable ("ParentTable");
1602                         XmlReadMode mode = XmlReadMode.Auto;
1603                         table.Columns.Add (new DataColumn ("id", System.Type.GetType ("System.Int32")));
1604                         ds.Tables.Add (table);
1605
1606                         using (FileStream stream = new FileStream (tempFile, FileMode.Open)) {
1607                                 mode = table.ReadXml (stream);
1608                         }
1609
1610                         Assert.AreEqual (XmlReadMode.IgnoreSchema, mode, "#1");
1611                         Assert.AreEqual ("ParentTable", table.TableName, "#2");
1612                         Assert.AreEqual (3, table.Rows.Count, "#3");
1613                         Assert.AreEqual (1, table.Columns.Count, "#4");
1614                         Assert.AreEqual (typeof (int), table.Columns [0].DataType, "#5");
1615                         Assert.AreEqual ("System.Data.DataSet", table.DataSet.ToString (), "#6");
1616                         Assert.AreEqual ("NewDataSet", table.DataSet.DataSetName, "#7");
1617
1618                         //Check the rows
1619                         DataRow row = table.Rows [0];
1620                         Assert.AreEqual (1, row [0], "#8");
1621
1622                         row = table.Rows [1];
1623                         Assert.AreEqual (2, row [0], "#9");
1624
1625                         row = table.Rows [2];
1626                         Assert.AreEqual (3, row [0], "#10");
1627                 }
1628
1629                 [Test]
1630                 public void XmlTest22 ()
1631                 {
1632                         MakeParentTable1 ();
1633
1634                         using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
1635                                 parentTable1.WriteXml (stream, XmlWriteMode.WriteSchema);
1636                         }
1637
1638                         using (FileStream stream = new FileStream (tempFile, FileMode.Open)) {
1639                                 DataSet ds = new DataSet ();
1640                                 DataTable table = new DataTable ("Table1");
1641                                 table.Columns.Add (new DataColumn ("id", System.Type.GetType ("System.Int32")));
1642                                 ds.Tables.Add (table);
1643
1644                                 try {
1645                                         table.ReadXml (stream);
1646                                         Assert.Fail ("#1");
1647                                 } catch (ArgumentException ex) {
1648                                         // DataTable 'Table1' does not match to
1649                                         // any DataTable in source
1650                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1651                                         Assert.IsNull (ex.InnerException, "#3");
1652                                         Assert.IsNotNull (ex.Message, "#4");
1653                                         Assert.IsTrue (ex.Message.IndexOf ("'Table1'") != -1, "#5");
1654                                         Assert.IsNull (ex.ParamName, "#6");
1655                                 }
1656                         }
1657                 }
1658
1659                 [Test]
1660                 public void XmlTest23 ()
1661                 {
1662                         MakeParentTable1 ();
1663
1664                         using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
1665                                 parentTable1.WriteXml (stream, XmlWriteMode.WriteSchema);
1666                         }
1667
1668                         DataSet ds = new DataSet ();
1669                         DataTable table = new DataTable ("ParentTable");
1670                         XmlReadMode mode = XmlReadMode.Auto;
1671                         table.Columns.Add (new DataColumn ("id", typeof (int)));
1672                         table.Columns.Add (new DataColumn ("DepartmentID", typeof (string)));
1673                         ds.Tables.Add (table);
1674
1675                         using (FileStream stream = new FileStream (tempFile, FileMode.Open)) {
1676                                 mode = table.ReadXml (stream);
1677                         }
1678
1679                         Assert.AreEqual (XmlReadMode.ReadSchema, mode, "#1");
1680                         Assert.AreEqual ("ParentTable", table.TableName, "#2");
1681                         Assert.AreEqual ("NewDataSet", table.DataSet.DataSetName, "#3");
1682                         Assert.AreEqual (3, table.Rows.Count, "#4");
1683                         Assert.AreEqual (2, table.Columns.Count, "#5");
1684                         Assert.AreEqual (typeof (int), table.Columns [0].DataType, "#6");
1685                         Assert.AreEqual (typeof (string), table.Columns [1].DataType, "#7");
1686
1687                         //Check rows
1688                         DataRow row = table.Rows [0];
1689                         Assert.AreEqual (1, row [0], "#8");
1690                         Assert.AreEqual ("1", row [1], "#9");
1691
1692                         row = table.Rows [1];
1693                         Assert.AreEqual (2, row [0], "#10");
1694                         Assert.AreEqual ("2", row [1], "#11");
1695
1696                         row = table.Rows [2];
1697                         Assert.AreEqual (3, row [0], "#12");
1698                         Assert.AreEqual ("3", row [1], "#13");
1699                 }
1700
1701                 [Test]
1702                 public void XmlTest24 ()
1703                 {
1704                         MakeDummyTable ();
1705
1706                         using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
1707                                 dummyTable.WriteXml (stream, XmlWriteMode.DiffGram);
1708                         }
1709
1710                         //This test is the same for case when the table name is set but no schema is defined
1711
1712                         using (FileStream stream = new FileStream (tempFile, FileMode.Open)) {
1713                                 DataTable table = new DataTable ();
1714
1715                                 try {
1716                                         table.ReadXml (stream);
1717                                         Assert.Fail ("#1");
1718                                 } catch (InvalidOperationException ex) {
1719                                         Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
1720                                         Assert.IsNull (ex.InnerException, "#3");
1721                                         Assert.IsNotNull (ex.Message, "#4");
1722                                 }
1723                         }
1724                 }
1725
1726                 [Test]
1727                 public void XmlTest25 ()
1728                 {
1729                         MakeDummyTable ();
1730
1731                         using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
1732                                 dummyTable.WriteXml (stream, XmlWriteMode.DiffGram);
1733                         }
1734
1735                         XmlReadMode mode = XmlReadMode.Auto;
1736                         //Create a table but dont set the table name
1737                         DataTable table = new DataTable ();
1738                         //define the table schame partially
1739                         table.Columns.Add ("id", typeof (int));
1740
1741                         using (FileStream stream = new FileStream (tempFile, FileMode.Open)) {
1742                                 mode = table.ReadXml (stream);
1743                         }
1744
1745                         Assert.AreEqual (String.Empty, table.TableName, "#1");
1746                         Assert.AreEqual (1, table.Columns.Count, "#2");
1747                         Assert.AreEqual (0, table.Rows.Count, "#3");
1748                         Assert.AreEqual (XmlReadMode.DiffGram, mode, "#4");
1749                 }
1750
1751                 [Test]
1752                 public void XmlTest26 ()
1753                 {
1754                         MakeDummyTable ();
1755
1756                         using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
1757                                 dummyTable.WriteXml (stream, XmlWriteMode.DiffGram);
1758                         }
1759
1760                         //Create a table and set the table name
1761                         DataTable table = new DataTable ("DummyTable");
1762                         //define the table schame partially
1763                         table.Columns.Add (new DataColumn ("DummyItem", typeof (string)));
1764
1765                         XmlReadMode mode = XmlReadMode.Auto;
1766
1767                         using (FileStream stream = new FileStream (tempFile, FileMode.Open)) {
1768                                 mode = table.ReadXml (stream);
1769                         }
1770
1771                         Assert.AreEqual (XmlReadMode.DiffGram, mode, "#1");
1772                         Assert.AreEqual (null, table.DataSet, "#2");
1773                         Assert.AreEqual (1, table.Columns.Count, "#3");
1774                         Assert.AreEqual (typeof (string), table.Columns [0].DataType, "#4");
1775                         Assert.AreEqual (3, table.Rows.Count, "#5");
1776
1777                         //Check Rows
1778                         DataRow row = table.Rows [0];
1779                         Assert.AreEqual ("DummyItem 1", row [0], "#1");
1780                         Assert.AreEqual (DataRowState.Unchanged, row.RowState, "#2");
1781
1782                         row = table.Rows [1];
1783                         Assert.AreEqual ("Changed_DummyItem 2", row [0], "#3");
1784                         Assert.AreEqual (DataRowState.Modified, row.RowState, "#4");
1785
1786                         row = table.Rows [2];
1787                         Assert.AreEqual ("DummyItem 3", row [0], "#5");
1788                         Assert.AreEqual (DataRowState.Unchanged, row.RowState, "#6");
1789                 }
1790
1791                 [Test]
1792                 public void XmlTest27 ()
1793                 {
1794                         MakeDummyTable ();
1795
1796                         using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
1797                                 dummyTable.WriteXml (stream, XmlWriteMode.DiffGram);
1798                         }
1799
1800                         //Create a table and set the table name
1801                         DataTable table = new DataTable ("DummyTable");
1802                         //define the table and add an extra column in the table
1803                         table.Columns.Add (new DataColumn ("id", typeof (int)));
1804                         table.Columns.Add (new DataColumn ("DummyItem", typeof (string)));
1805                         //Add an extra column which does not match any column in the source diffram
1806                         table.Columns.Add (new DataColumn ("ExtraColumn", typeof (double)));
1807
1808                         XmlReadMode mode = XmlReadMode.Auto;
1809
1810                         using (FileStream stream = new FileStream (tempFile, FileMode.Open)) {
1811                                 mode = table.ReadXml (stream);
1812                         }
1813
1814                         Assert.AreEqual (XmlReadMode.DiffGram, mode, "#1");
1815                         Assert.IsNull (table.DataSet, "#2");
1816                         Assert.AreEqual (3, table.Columns.Count, "#3");
1817                         Assert.AreEqual (typeof (int), table.Columns [0].DataType, "#4");
1818                         Assert.AreEqual (typeof (string), table.Columns [1].DataType, "#5");
1819                         Assert.AreEqual (typeof (double), table.Columns [2].DataType, "#6");
1820                         Assert.AreEqual (3, table.Rows.Count, "#7");
1821
1822                         //Check Rows
1823                         DataRow row = table.Rows [0];
1824                         Assert.AreEqual (1, row [0], "#8");
1825                         Assert.AreEqual ("DummyItem 1", row [1], "#9");
1826                         Assert.AreSame (DBNull.Value, row [2], "#10");
1827                         Assert.AreEqual (DataRowState.Unchanged, row.RowState, "#11");
1828
1829                         row = table.Rows [1];
1830                         Assert.AreEqual (2, row [0], "#12");
1831                         Assert.AreEqual ("Changed_DummyItem 2", row [1], "#13");
1832                         Assert.AreSame (DBNull.Value, row [2], "#14");
1833                         Assert.AreEqual (DataRowState.Modified, row.RowState, "#15");
1834
1835                         row = table.Rows [2];
1836                         Assert.AreEqual (3, row [0], "#16");
1837                         Assert.AreEqual ("DummyItem 3", row [1], "#17");
1838                         Assert.AreSame (DBNull.Value, row [2], "#18");
1839                         Assert.AreEqual (DataRowState.Unchanged, row.RowState, "#19");
1840                 }
1841
1842                 [Test]
1843                 public void XmlTest28 ()
1844                 {
1845                         MakeDummyTable ();
1846
1847                         using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
1848                                 dummyTable.WriteXml (stream, XmlWriteMode.DiffGram);
1849                         }
1850
1851                         //Create a table and set the table name
1852                         DataTable table = new DataTable ("DummyTable");
1853                         //define the table schame partially with a column name which does not match with any
1854                         //table columns in the diffgram
1855                         table.Columns.Add (new DataColumn ("WrongColumnName", System.Type.GetType ("System.String")));
1856
1857                         XmlReadMode mode = XmlReadMode.Auto;
1858
1859                         using (FileStream stream = new FileStream (tempFile, FileMode.Open)) {
1860                                 mode = table.ReadXml (stream);
1861                         }
1862
1863                         Assert.AreEqual (XmlReadMode.DiffGram, mode, "#1");
1864                         Assert.IsNull (table.DataSet, "#2");
1865                         Assert.AreEqual ("DummyTable", table.TableName, "#3");
1866                         Assert.AreEqual (1, table.Columns.Count, "#4");
1867                         Assert.AreEqual (typeof (string), table.Columns [0].DataType, "#5");
1868
1869                         Assert.AreEqual (3, table.Rows.Count, "#6");
1870                         foreach (DataRow row in table.Rows)
1871                                 Assert.AreSame (DBNull.Value, row [0], "#7");
1872                 }
1873
1874                 [Test]
1875                 public void XmlTest29 ()
1876                 {
1877                         MakeParentTable1 ();
1878                         MakeChildTable ();
1879                         MakeSecondChildTable ();
1880                         MakeDataRelation ();
1881
1882                         using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
1883                                 parentTable1.WriteXml (stream, XmlWriteMode.DiffGram, true);
1884                         }
1885
1886                         DataTable table1 = new DataTable ("ParentTable");
1887                         table1.Columns.Add (new DataColumn (parentTable1.Columns [0].ColumnName, typeof (int)));
1888                         table1.Columns.Add (new DataColumn (parentTable1.Columns [1].ColumnName, typeof (string)));
1889                         table1.Columns.Add (new DataColumn (parentTable1.Columns [2].ColumnName, typeof (int)));
1890
1891                         //ReadXml on a DiffGram will never create any child relation
1892                         XmlReadMode mode = table1.ReadXml (tempFile);
1893
1894                         Assert.AreEqual (XmlReadMode.DiffGram, mode, "#1");
1895                         Assert.AreEqual (null, table1.DataSet, "#2");
1896                         Assert.AreEqual ("ParentTable", table1.TableName, "#3");
1897                         Assert.AreEqual (3, table1.Columns.Count, "#4");
1898                         Assert.AreEqual (typeof (int), table1.Columns [0].DataType, "#5");
1899                         Assert.AreEqual (typeof (string), table1.Columns [1].DataType, "#6");
1900                         Assert.AreEqual (typeof (int), table1.Columns [2].DataType, "#7");
1901                         Assert.AreEqual (0, table1.ChildRelations.Count, "#8");
1902
1903                         Assert.AreEqual (3, table1.Rows.Count, "#9");
1904                         //Check the row
1905                         DataRow row = table1.Rows [0];
1906                         Assert.AreEqual (1, row [0], "#10");
1907                         Assert.AreEqual ("ParentItem 1", row [1], "#11");
1908                         Assert.AreEqual (1, row [2], "#12");
1909
1910                         row = table1.Rows [1];
1911                         Assert.AreEqual (2, row [0], "#13");
1912                         Assert.AreEqual ("ParentItem 2", row [1], "#14");
1913                         Assert.AreEqual (2, row [2], "#15");
1914
1915                         row = table1.Rows [2];
1916                         Assert.AreEqual (3, row [0], "#16");
1917                         Assert.AreEqual ("ParentItem 3", row [1], "#17");
1918                         Assert.AreEqual (3, row [2], "#18");
1919                 }
1920
1921                 [Test]
1922                 public void XmlTest30 ()
1923                 {
1924                         MakeDummyTable ();
1925
1926                         using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
1927                                 dummyTable.WriteXml (stream, XmlWriteMode.DiffGram);
1928                         }
1929
1930                         Assert.AreEqual (3, dummyTable.Rows.Count, "#4b");
1931
1932                         DataSet dataSet = new DataSet ("HelloWorldDataSet");
1933                         DataTable table = new DataTable ("DummyTable");
1934                         table.Columns.Add (new DataColumn ("DummyItem", typeof (string)));
1935                         dataSet.Tables.Add (table);
1936
1937                         //Call ReadXml on a table which belong to a DataSet
1938                         table.ReadXml (tempFile);
1939
1940                         Assert.AreEqual ("HelloWorldDataSet", table.DataSet.DataSetName, "#1");
1941                         Assert.AreEqual (1, table.Columns.Count, "#2");
1942                         Assert.AreEqual (typeof (string), table.Columns [0].DataType, "#3");
1943                         Assert.AreEqual (3, table.Rows.Count, "#4");
1944
1945                         //Check Rows
1946                         DataRow row = table.Rows [0];
1947                         Assert.AreEqual ("DummyItem 1", row [0], "#5");
1948                         Assert.AreEqual (DataRowState.Unchanged, row.RowState, "#6");
1949
1950                         row = table.Rows [1];
1951                         Assert.AreEqual ("Changed_DummyItem 2", row [0], "#7");
1952                         Assert.AreEqual (DataRowState.Modified, row.RowState, "#8");
1953
1954                         row = table.Rows [2];
1955                         Assert.AreEqual ("DummyItem 3", row [0], "#9");
1956                         Assert.AreEqual (DataRowState.Unchanged, row.RowState, "#10");
1957                 }
1958
1959                 [Test]
1960                 public void XmlTest31 ()
1961                 {
1962                         DataSet ds = new DataSet ();
1963                         DataTable parent = new DataTable ("Parent");
1964                         parent.Columns.Add (new DataColumn ("col1", typeof (int)));
1965                         parent.Columns.Add (new DataColumn ("col2", typeof (string)));
1966                         parent.Columns [0].Unique = true;
1967
1968                         DataTable child1 = new DataTable ("Child1");
1969                         child1.Columns.Add (new DataColumn ("col3", typeof (int)));
1970                         child1.Columns.Add (new DataColumn ("col4", typeof (string)));
1971                         child1.Columns.Add (new DataColumn ("col5", typeof (int)));
1972                         child1.Columns [2].Unique = true;
1973
1974                         DataTable child2 = new DataTable ("Child2");
1975                         child2.Columns.Add (new DataColumn ("col6", typeof (int)));
1976                         child2.Columns.Add (new DataColumn ("col7"));
1977
1978                         parent.Rows.Add (new object [] {1, "P_"});
1979                         parent.Rows.Add (new object [] {2, "P_"});
1980
1981                         child1.Rows.Add (new object [] {1, "C1_", 3});
1982                         child1.Rows.Add (new object [] {1, "C1_", 4});
1983                         child1.Rows.Add (new object [] {2, "C1_", 5});
1984                         child1.Rows.Add (new object [] {2, "C1_", 6});
1985
1986                         child2.Rows.Add (new object [] {3, "C2_"});
1987                         child2.Rows.Add (new object [] {3, "C2_"});
1988                         child2.Rows.Add (new object [] {4, "C2_"});
1989                         child2.Rows.Add (new object [] {4, "C2_"});
1990                         child2.Rows.Add (new object [] {5, "C2_"});
1991                         child2.Rows.Add (new object [] {5, "C2_"});
1992                         child2.Rows.Add (new object [] {6, "C2_"});
1993                         child2.Rows.Add (new object [] {6, "C2_"});
1994
1995                         ds.Tables.Add (parent);
1996                         ds.Tables.Add (child1);
1997                         ds.Tables.Add (child2);
1998
1999                         DataRelation relation = new DataRelation ("Relation1", parent.Columns [0], child1.Columns [0]);
2000                         parent.ChildRelations.Add (relation);
2001
2002                         relation = new DataRelation ("Relation2", child1.Columns [2], child2.Columns [0]);
2003                         child1.ChildRelations.Add (relation);
2004
2005                         using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
2006                                 parent.WriteXml (stream, XmlWriteMode.WriteSchema, true);
2007                         }
2008
2009                         DataTable table = new DataTable ();
2010                         table.ReadXml (tempFile);
2011
2012                         Assert.AreEqual ("Parent", table.TableName, "#1");
2013                         Assert.AreEqual ("NewDataSet", table.DataSet.DataSetName, "#2");
2014                         Assert.AreEqual (2, table.Columns.Count, "#3");
2015                         Assert.AreEqual (2, table.Rows.Count, "#4");
2016                         Assert.AreEqual (typeof (System.Int32), table.Columns [0].DataType, "#5");
2017                         Assert.AreEqual (typeof (System.String), table.Columns [1].DataType, "#6");
2018                         Assert.AreEqual (1, table.Constraints.Count, "#7");
2019                         Assert.AreEqual (typeof (UniqueConstraint), table.Constraints [0].GetType (), "#8");
2020                         Assert.AreEqual (1, table.ChildRelations.Count, "#9");
2021                         Assert.AreEqual ("Relation1", table.ChildRelations [0].RelationName, "#10");
2022                         Assert.AreEqual ("Parent", table.ChildRelations [0].ParentTable.TableName, "#11");
2023                         Assert.AreEqual ("Child1", table.ChildRelations [0].ChildTable.TableName, "#12");
2024
2025                         DataTable table1 = table.ChildRelations [0].ChildTable;
2026                         Assert.AreEqual ("Child1", table1.TableName, "#13");
2027                         Assert.AreEqual ("NewDataSet", table1.DataSet.DataSetName, "#14");
2028                         Assert.AreEqual (3, table1.Columns.Count, "#15");
2029                         Assert.AreEqual (4, table1.Rows.Count, "#16");
2030                         Assert.AreEqual (typeof (System.Int32), table1.Columns [0].DataType, "#17");
2031                         Assert.AreEqual (typeof (System.String), table1.Columns [1].DataType, "#18");
2032                         Assert.AreEqual (typeof (System.Int32), table1.Columns [2].DataType, "#19");
2033                         Assert.AreEqual (2, table1.Constraints.Count, "#20");
2034                         Assert.AreEqual (typeof (UniqueConstraint), table1.Constraints [0].GetType (), "#21");
2035                         Assert.AreEqual (typeof (ForeignKeyConstraint), table1.Constraints [1].GetType (), "#22");
2036                         Assert.AreEqual (1, table1.ParentRelations.Count, "#23");
2037                         Assert.AreEqual (1, table1.ChildRelations.Count, "#24");
2038                         Assert.AreEqual ("Relation1", table1.ParentRelations [0].RelationName, "#25");
2039                         Assert.AreEqual ("Relation2", table1.ChildRelations [0].RelationName, "#26");
2040                         Assert.AreEqual ("Parent", table1.ParentRelations [0].ParentTable.TableName, "#27");
2041                         Assert.AreEqual ("Child2", table1.ChildRelations [0].ChildTable.TableName, "#28");
2042
2043                         table1 = table1.ChildRelations [0].ChildTable;
2044                         Assert.AreEqual ("Child2", table1.TableName, "#28");
2045                         Assert.AreEqual ("NewDataSet", table1.DataSet.DataSetName, "#29");
2046                         Assert.AreEqual (2, table1.Columns.Count, "#30");
2047                         Assert.AreEqual (8, table1.Rows.Count, "#31");
2048                         Assert.AreEqual (typeof (System.Int32), table1.Columns [0].DataType, "#32");
2049                         Assert.AreEqual (typeof (System.String), table1.Columns [1].DataType, "#33");
2050                         Assert.AreEqual (1, table1.Constraints.Count, "#34");
2051                         Assert.AreEqual (typeof (ForeignKeyConstraint), table1.Constraints [0].GetType (), "#35");
2052                         Assert.AreEqual (1, table1.ParentRelations.Count, "#36");
2053                         Assert.AreEqual (0, table1.ChildRelations.Count, "#37");
2054                         Assert.AreEqual ("Relation2", table1.ParentRelations [0].RelationName, "#38");
2055                         Assert.AreEqual ("Child1", table1.ParentRelations [0].ParentTable.TableName, "#39");
2056
2057                 }
2058         }
2059 }
2060 #endif