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