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

   1 // DataTableTest.cs - NUnit Test Cases for testing the DataTable
   2 //
   3 // Authors:
   4 //   Franklin Wise (gracenote@earthlink.net)
   5 //   Martin Willemoes Hansen (mwh@sysrq.dk)
   6 //   Hagit Yidov (hagity@mainsoft.com)
   7 //
   8 // (C) Franklin Wise
   9 // (C) 2003 Martin Willemoes Hansen
  10 // (C) 2005 Mainsoft Corporation (http://www.mainsoft.com)
  11
  12 //
  13 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
  14 //
  15 // Permission is hereby granted, free of charge, to any person obtaining
  16 // a copy of this software and associated documentation files (the
  17 // "Software"), to deal in the Software without restriction, including
  18 // without limitation the rights to use, copy, modify, merge, publish,
  19 // distribute, sublicense, and/or sell copies of the Software, and to
  20 // permit persons to whom the Software is furnished to do so, subject to
  21 // the following conditions:
  22 //
  23 // The above copyright notice and this permission notice shall be
  24 // included in all copies or substantial portions of the Software.
  25 //
  26 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  27 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  28 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  29 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  30 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  31 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  32 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  33 //
  34
  35 using NUnit.Framework;
  36 using System;
  37 using System.Data;
  38 using System.Data.SqlTypes;
  39 using System.Globalization;
  40 using System.IO;
  41 using System.Runtime.Serialization.Formatters.Binary;
  42 using System.Xml;
  43 using MonoTests.System.Data.Utils;
  44 using System.Collections;
  45 using System.Threading;
  46
  47 namespace MonoTests.System.Data
  48 {
  49         [TestFixture]
  50         public class DataTableTest :  DataSetAssertion
  51         {
  52                 string EOL = Environment.NewLine;
  53
  54                 [Test]
  55                 public void Ctor()
  56                 {
  57                         DataTable dt = new DataTable();
  58
  59                         Assert.IsFalse (dt.CaseSensitive, "CaseSensitive must be false.");
  60                         Assert.IsTrue (dt.Columns != null, "Col");
  61                         //Assert.IsTrue (dt.ChildRelations != null);
  62                         Assert.IsTrue (dt.Constraints != null, "Const");
  63                         Assert.IsTrue (dt.DataSet == null, "ds");
  64                         Assert.IsTrue (dt.DefaultView != null, "dv");
  65                         Assert.IsTrue (dt.DisplayExpression == "", "de");
  66                         Assert.IsTrue (dt.ExtendedProperties != null, "ep");
  67                         Assert.IsTrue (dt.HasErrors == false, "he");
  68                         Assert.IsTrue (dt.Locale != null, "lc");
  69                         Assert.IsTrue (dt.MinimumCapacity == 50, "mc"); //LAMESPEC:
  70                         Assert.IsTrue (dt.Namespace == "", "ns");
  71                         //Assert.IsTrue (dt.ParentRelations != null);
  72                         Assert.IsTrue (dt.Prefix == "", "pf");
  73                         Assert.IsTrue (dt.PrimaryKey != null, "pk");
  74                         Assert.IsTrue (dt.Rows != null, "rows");
  75                         Assert.IsTrue (dt.Site == null, "Site");
  76                         Assert.IsTrue (dt.TableName == "", "tname");
  77
  78                 }
  79
  80                 [Test]
  81                 public void Select ()
  82                 {
  83                         DataSet Set = new DataSet ();
  84                         DataTable Mom = new DataTable ("Mom");
  85                         DataTable Child = new DataTable ("Child");
  86                         Set.Tables.Add (Mom);
  87                         Set.Tables.Add (Child);
  88
  89                         DataColumn Col = new DataColumn ("Name");
  90                         DataColumn Col2 = new DataColumn ("ChildName");
  91                         Mom.Columns.Add (Col);
  92                         Mom.Columns.Add (Col2);
  93
  94                         DataColumn Col3 = new DataColumn ("Name");
  95                         DataColumn Col4 = new DataColumn ("Age");
  96                         Col4.DataType = Type.GetType ("System.Int16");
  97                         Child.Columns.Add (Col3);
  98                         Child.Columns.Add (Col4);
  99
 100                         DataRelation Relation = new DataRelation ("Rel", Mom.Columns [1], Child.Columns [0]);
 101                         Set.Relations.Add (Relation);
 102
 103                         DataRow Row = Mom.NewRow ();
 104                         Row [0] = "Laura";
 105                         Row [1] = "Nick";
 106                         Mom.Rows.Add (Row);
 107
 108                         Row = Mom.NewRow ();
 109                         Row [0] = "Laura";
 110                         Row [1] = "Dick";
 111                         Mom.Rows.Add (Row);
 112
 113                         Row = Mom.NewRow ();
 114                         Row [0] = "Laura";
 115                         Row [1] = "Mick";
 116                         Mom.Rows.Add (Row);
 117
 118                         Row = Mom.NewRow ();
 119                         Row [0] = "Teresa";
 120                         Row [1] = "Jack";
 121                         Mom.Rows.Add (Row);
 122
 123                         Row = Mom.NewRow ();
 124                         Row [0] = "Teresa";
 125                         Row [1] = "Mack";
 126                         Mom.Rows.Add (Row);
 127
 128                         Row = Mom.NewRow ();
 129                         Row [0] = "'Jhon O'' Collenal'";
 130                         Row [1] = "Pack";
 131                         Mom.Rows.Add (Row);
 132
 133                         Row = Child.NewRow ();
 134                         Row [0] = "Nick";
 135                         Row [1] = 15;
 136                         Child.Rows.Add (Row);
 137
 138                         Row = Child.NewRow ();
 139                         Row [0] = "Dick";
 140                         Row [1] = 25;
 141                         Child.Rows.Add (Row);
 142
 143                         Row = Child.NewRow ();
 144                         Row [0] = "Mick";
 145                         Row [1] = 35;
 146                         Child.Rows.Add (Row);
 147
 148                         Row = Child.NewRow ();
 149                         Row [0] = "Jack";
 150                         Row [1] = 10;
 151                         Child.Rows.Add (Row);
 152
 153                         Row = Child.NewRow ();
 154                         Row [0] = "Mack";
 155                         Row [1] = 19;
 156                         Child.Rows.Add (Row);
 157
 158                         Row = Child.NewRow ();
 159                         Row [0] = "Mack";
 160                         Row [1] = 99;
 161                         Child.Rows.Add (Row);
 162
 163                         Row = Child.NewRow ();
 164                         Row [0] = "Pack";
 165                         Row [1] = 66;
 166                         Child.Rows.Add (Row);
 167
 168                         DataRow [] Rows = Mom.Select ("Name = 'Teresa'");
 169                         Assert.AreEqual (2, Rows.Length, "test#01");
 170
 171                         // test with apos escaped
 172                         Rows = Mom.Select ("Name = '''Jhon O'''' Collenal'''");
 173                         Assert.AreEqual (1, Rows.Length, "test#01.1");
 174
 175                         Rows = Mom.Select ("Name = 'Teresa' and ChildName = 'Nick'");
 176                         Assert.AreEqual (0, Rows.Length, "test#02");
 177
 178                         Rows = Mom.Select ("Name = 'Teresa' and ChildName = 'Jack'");
 179                         Assert.AreEqual (1, Rows.Length, "test#03");
 180
 181                         Rows = Mom.Select ("Name = 'Teresa' and ChildName <> 'Jack'");
 182                         Assert.AreEqual ("Mack", Rows [0] [1], "test#04");
 183
 184                         Rows = Mom.Select ("Name = 'Teresa' or ChildName <> 'Jack'");
 185                         Assert.AreEqual (6, Rows.Length, "test#05");
 186
 187                         Rows = Child.Select ("age = 20 - 1");
 188                         Assert.AreEqual (1, Rows.Length, "test#06");
 189
 190                         Rows = Child.Select ("age <= 20");
 191                         Assert.AreEqual (3, Rows.Length, "test#07");
 192
 193                         Rows = Child.Select ("age >= 20");
 194                         Assert.AreEqual (4, Rows.Length, "test#08");
 195
 196                         Rows = Child.Select ("age >= 20 and name = 'Mack' or name = 'Nick'");
 197                         Assert.AreEqual (2, Rows.Length, "test#09");
 198
 199                         Rows = Child.Select ("age >= 20 and (name = 'Mack' or name = 'Nick')");
 200                         Assert.AreEqual (1, Rows.Length, "test#10");
 201                         Assert.AreEqual ("Mack", Rows [0] [0], "test#11");
 202
 203                         Rows = Child.Select ("not (Name = 'Jack')");
 204                         Assert.AreEqual (6, Rows.Length, "test#12");
 205                 }
 206
 207                 [Test]
 208                 public void Select2 ()
 209                 {
 210                         DataSet Set = new DataSet ();
 211                         DataTable Child = new DataTable ("Child");
 212
 213                         Set.Tables.Add (Child);
 214
 215                         DataColumn Col3 = new DataColumn ("Name");
 216                         DataColumn Col4 = new DataColumn ("Age");
 217                         Col4.DataType = Type.GetType ("System.Int16");
 218                         Child.Columns.Add (Col3);
 219                         Child.Columns.Add (Col4);
 220
 221                         DataRow Row = Child.NewRow ();
 222                         Row [0] = "Nick";
 223                         Row [1] = 15;
 224                         Child.Rows.Add (Row);
 225
 226                         Row = Child.NewRow ();
 227                         Row [0] = "Dick";
 228                         Row [1] = 25;
 229                         Child.Rows.Add (Row);
 230
 231                         Row = Child.NewRow ();
 232                         Row [0] = "Mick";
 233                         Row [1] = 35;
 234                         Child.Rows.Add (Row);
 235
 236                         Row = Child.NewRow ();
 237                         Row [0] = "Jack";
 238                         Row [1] = 10;
 239                         Child.Rows.Add (Row);
 240
 241                         Row = Child.NewRow ();
 242                         Row [0] = "Mack";
 243                         Row [1] = 19;
 244                         Child.Rows.Add (Row);
 245
 246                         Row = Child.NewRow ();
 247                         Row [0] = "Mack";
 248                         Row [1] = 99;
 249                         Child.Rows.Add (Row);
 250
 251                         DataRow [] Rows = Child.Select ("age >= 20", "age DESC");
 252                         Assert.AreEqual (3, Rows.Length, "test#01");
 253                         Assert.AreEqual ("Mack", Rows [0] [0], "test#02");
 254                         Assert.AreEqual ("Mick", Rows [1] [0], "test#03");
 255                         Assert.AreEqual ("Dick", Rows [2] [0], "test#04");
 256
 257                         Rows = Child.Select ("age >= 20", "age asc");
 258                         Assert.AreEqual (3, Rows.Length, "test#05");
 259                         Assert.AreEqual ("Dick", Rows [0] [0], "test#06");
 260                         Assert.AreEqual ("Mick", Rows [1] [0], "test#07");
 261                         Assert.AreEqual ("Mack", Rows [2] [0], "test#08");
 262
 263                         Rows = Child.Select ("age >= 20", "name asc");
 264                         Assert.AreEqual (3, Rows.Length, "test#09");
 265                         Assert.AreEqual ("Dick", Rows [0] [0], "test#10");
 266                         Assert.AreEqual ("Mack", Rows [1] [0], "test#11");
 267                         Assert.AreEqual ("Mick", Rows [2] [0], "test#12");
 268
 269                         Rows = Child.Select ("age >= 20", "name desc");
 270                         Assert.AreEqual (3, Rows.Length, "test#09");
 271                         Assert.AreEqual ("Mick", Rows [0] [0], "test#10");
 272                         Assert.AreEqual ("Mack", Rows [1] [0], "test#11");
 273                         Assert.AreEqual ("Dick", Rows [2] [0], "test#12");
 274
 275                 }
 276
 277                 [Test]
 278                 public void SelectParsing ()
 279                 {
 280                         DataTable T = new DataTable ("test");
 281                         DataColumn C = new DataColumn ("name");
 282                         T.Columns.Add (C);
 283                         C = new DataColumn ("age");
 284                         C.DataType = typeof (int);
 285                         T.Columns.Add (C);
 286                         C = new DataColumn ("id");
 287                         T.Columns.Add (C);
 288
 289                         DataSet Set = new DataSet ("TestSet");
 290                         Set.Tables.Add (T);
 291
 292                         DataRow Row = null;
 293                         for (int i = 0; i < 100; i++) {
 294                                 Row = T.NewRow ();
 295                                 Row [0] = "human" + i;
 296                                 Row [1] = i;
 297                                 Row [2] = i;
 298                                 T.Rows.Add (Row);
 299                         }
 300
 301                         Row = T.NewRow ();
 302                         Row [0] = "h*an";
 303                         Row [1] = 1;
 304                         Row [2] = 1;
 305                         T.Rows.Add (Row);
 306
 307                         Assert.AreEqual (12, T.Select ("age<=10").Length, "test#01");
 308
 309                         Assert.AreEqual (12, T.Select ("age\n\t<\n\t=\t\n10").Length, "test#02");
 310
 311                         try {
 312                                 T.Select ("name = 1human ");
 313                                 Assert.Fail ("test#03");
 314                         } catch (Exception e) {
 315
 316                                 // missing operand after 'human' operand
 317                                 Assert.AreEqual (typeof (SyntaxErrorException), e.GetType (), "test#04");
 318                         }
 319
 320                         try {
 321                                 T.Select ("name = 1");
 322                                 Assert.Fail ("test#05");
 323                         } catch (Exception e) {
 324
 325                                 // Cannot perform '=' operation between string and Int32
 326                                 Assert.AreEqual (typeof (EvaluateException), e.GetType (), "test#06");
 327                         }
 328
 329                         Assert.AreEqual (1, T.Select ("age = '13'").Length, "test#07");
 330
 331                 }
 332
 333                 [Test]
 334                 public void SelectEscaping () {
 335                         DataTable dt = new DataTable ();
 336                         dt.Columns.Add ("SomeCol");
 337                         dt.Rows.Add (new object [] {"\t"});
 338                         dt.Rows.Add (new object [] {"\\"});
 339
 340                         Assert.AreEqual (1, dt.Select (@"SomeCol='\t'").Length, "test#01");
 341                         Assert.AreEqual (1, dt.Select (@"SomeCol='\\'").Length, "test#02");
 342
 343                         try {
 344                                 dt.Select (@"SomeCol='\x'");
 345                                 Assert.Fail("test#03");
 346                         } catch (SyntaxErrorException) {}
 347                 }
 348
 349                 [Test]
 350                 public void SelectOperators ()
 351                 {
 352                         DataTable T = new DataTable ("test");
 353                         DataColumn C = new DataColumn ("name");
 354                         T.Columns.Add (C);
 355                         C = new DataColumn ("age");
 356                         C.DataType = typeof (int);
 357                         T.Columns.Add (C);
 358                         C = new DataColumn ("id");
 359                         T.Columns.Add (C);
 360
 361                         DataSet Set = new DataSet ("TestSet");
 362                         Set.Tables.Add (T);
 363
 364                         DataRow Row = null;
 365                         for (int i = 0; i < 100; i++) {
 366                                 Row = T.NewRow ();
 367                                 Row [0] = "human" + i;
 368                                 Row [1] = i;
 369                                 Row [2] = i;
 370                                 T.Rows.Add (Row);
 371                         }
 372
 373                         Row = T.NewRow ();
 374                         Row [0] = "h*an";
 375                         Row [1] = 1;
 376                         Row [2] = 1;
 377                         T.Rows.Add (Row);
 378
 379                         Assert.AreEqual (11, T.Select ("age < 10").Length, "test#01");
 380                         Assert.AreEqual (12, T.Select ("age <= 10").Length, "test#02");
 381                         Assert.AreEqual (12, T.Select ("age< =10").Length, "test#03");
 382                         Assert.AreEqual (89, T.Select ("age > 10").Length, "test#04");
 383                         Assert.AreEqual (90, T.Select ("age >= 10").Length, "test#05");
 384                         Assert.AreEqual (100, T.Select ("age <> 10").Length, "test#06");
 385                         Assert.AreEqual (3, T.Select ("name < 'human10'").Length, "test#07");
 386                         Assert.AreEqual (3, T.Select ("id < '10'").Length, "test#08");
 387                         // FIXME: Somebody explain how this can be possible.
 388                         // it seems that it is no matter between 10 - 30. The
 389                         // result is allways 25 :-P
 390                         //Assert.AreEqual (25, T.Select ("id < 10").Length, "test#09");
 391
 392                 }
 393
 394                 [Test]
 395                 public void SelectExceptions ()
 396                 {
 397                         DataTable T = new DataTable ("test");
 398                         DataColumn C = new DataColumn ("name");
 399                         T.Columns.Add (C);
 400                         C = new DataColumn ("age");
 401                         C.DataType = typeof (int);
 402                         T.Columns.Add (C);
 403                         C = new DataColumn ("id");
 404                         T.Columns.Add (C);
 405
 406                         for (int i = 0; i < 100; i++) {
 407                                 DataRow Row = T.NewRow ();
 408                                 Row [0] = "human" + i;
 409                                 Row [1] = i;
 410                                 Row [2] = i;
 411                                 T.Rows.Add (Row);
 412                         }
 413
 414                         try {
 415                                 T.Select ("name = human1");
 416                                 Assert.Fail ("test#01");
 417                         } catch (Exception e) {
 418
 419                                 // column name human not found
 420                                 Assert.AreEqual (typeof (EvaluateException), e.GetType (), "test#02");
 421                         }
 422
 423                         Assert.AreEqual (1, T.Select ("id = '12'").Length, "test#04");
 424                         Assert.AreEqual (1, T.Select ("id = 12").Length, "test#05");
 425
 426                         try {
 427                                 T.Select ("id = 1k3");
 428                                 Assert.Fail ("test#06");
 429                         } catch (Exception e) {
 430
 431                                 // no operands after k3 operator
 432                                 Assert.AreEqual (typeof (SyntaxErrorException), e.GetType (), "test#07");
 433                         }
 434                 }
 435
 436                 [Test]
 437                 public void SelectStringOperators ()
 438                 {
 439                         DataTable T = new DataTable ("test");
 440                         DataColumn C = new DataColumn ("name");
 441                         T.Columns.Add (C);
 442                         C = new DataColumn ("age");
 443                         C.DataType = typeof (int);
 444                         T.Columns.Add (C);
 445                         C = new DataColumn ("id");
 446                         T.Columns.Add (C);
 447
 448                         DataSet Set = new DataSet ("TestSet");
 449                         Set.Tables.Add (T);
 450
 451                         DataRow Row = null;
 452                         for (int i = 0; i < 100; i++) {
 453                                 Row = T.NewRow ();
 454                                 Row [0] = "human" + i;
 455                                 Row [1] = i;
 456                                 Row [2] = i;
 457                                 T.Rows.Add (Row);
 458                         }
 459                         Row = T.NewRow ();
 460                         Row [0] = "h*an";
 461                         Row [1] = 1;
 462                         Row [2] = 1;
 463                         T.Rows.Add (Row);
 464
 465                         Assert.AreEqual (1, T.Select ("name = 'human' + 1").Length, "test#01");
 466
 467                         Assert.AreEqual ("human1", T.Select ("name = 'human' + 1") [0] ["name"], "test#02");
 468                         Assert.AreEqual (1, T.Select ("name = 'human' + '1'").Length, "test#03");
 469                         Assert.AreEqual ("human1", T.Select ("name = 'human' + '1'") [0] ["name"], "test#04");
 470                         Assert.AreEqual (1, T.Select ("name = 'human' + 1 + 2").Length, "test#05");
 471                         Assert.AreEqual ("human12", T.Select ("name = 'human' + '1' + '2'") [0] ["name"], "test#06");
 472
 473                         Assert.AreEqual (1, T.Select ("name = 'huMAn' + 1").Length, "test#07");
 474
 475                         Set.CaseSensitive = true;
 476                         Assert.AreEqual (0, T.Select ("name = 'huMAn' + 1").Length, "test#08");
 477
 478                         T.CaseSensitive = false;
 479                         Assert.AreEqual (1, T.Select ("name = 'huMAn' + 1").Length, "test#09");
 480
 481                         T.CaseSensitive = true;
 482                         Assert.AreEqual (0, T.Select ("name = 'huMAn' + 1").Length, "test#10");
 483
 484                         Set.CaseSensitive = false;
 485                         Assert.AreEqual (0, T.Select ("name = 'huMAn' + 1").Length, "test#11");
 486
 487                         T.CaseSensitive = false;
 488                         Assert.AreEqual (1, T.Select ("name = 'huMAn' + 1").Length, "test#12");
 489
 490                         Assert.AreEqual (0, T.Select ("name = 'human1*'").Length, "test#13");
 491                         Assert.AreEqual (11, T.Select ("name like 'human1*'").Length, "test#14");
 492                         Assert.AreEqual (11, T.Select ("name like 'human1%'").Length, "test#15");
 493
 494                         try {
 495                                 Assert.AreEqual (11, T.Select ("name like 'h*an1'").Length, "test#16");
 496                                 Assert.Fail ("test#16");
 497                         } catch (Exception e) {
 498
 499                                 // 'h*an1' is invalid
 500                                 Assert.AreEqual (typeof (EvaluateException), e.GetType (), "test#17");
 501                         }
 502
 503                         try {
 504                                 Assert.AreEqual (11, T.Select ("name like 'h%an1'").Length, "test#18");
 505                                 Assert.Fail ("test#19");
 506                         } catch (Exception e) {
 507
 508                                 // 'h%an1' is invalid
 509                                 Assert.AreEqual (typeof (EvaluateException), e.GetType (), "test#20");
 510                         }
 511
 512                         Assert.AreEqual (0, T.Select ("name like 'h[%]an'").Length, "test#21");
 513                         Assert.AreEqual (1, T.Select ("name like 'h[*]an'").Length, "test#22");
 514
 515                 }
 516
 517                 [Test]
 518                 public void SelectAggregates ()
 519                 {
 520                         DataTable T = new DataTable ("test");
 521                         DataColumn C = new DataColumn ("name");
 522                         T.Columns.Add (C);
 523                         C = new DataColumn ("age");
 524                         C.DataType = typeof (int);
 525                         T.Columns.Add (C);
 526                         C = new DataColumn ("id");
 527                         T.Columns.Add (C);
 528                         DataRow Row = null;
 529
 530                         for (int i = 0; i < 1000; i++) {
 531                                 Row = T.NewRow ();
 532                                 Row [0] = "human" + i;
 533                                 Row [1] = i;
 534                                 Row [2] = i;
 535                                 T.Rows.Add (Row);
 536                         }
 537
 538                         Assert.AreEqual (1000, T.Select ("Sum(age) > 10").Length, "test#01");
 539                         Assert.AreEqual (1000, T.Select ("avg(age) = 499").Length, "test#02");
 540                         Assert.AreEqual (1000, T.Select ("min(age) = 0").Length, "test#03");
 541                         Assert.AreEqual (1000, T.Select ("max(age) = 999").Length, "test#04");
 542                         Assert.AreEqual (1000, T.Select ("count(age) = 1000").Length, "test#05");
 543                         Assert.AreEqual (1000, T.Select ("stdev(age) > 287 and stdev(age) < 289").Length, "test#06");
 544                         Assert.AreEqual (1000, T.Select ("var(age) < 83417 and var(age) > 83416").Length, "test#07");
 545                 }
 546
 547                 [Test]
 548                 public void SelectFunctions ()
 549                 {
 550                         DataTable T = new DataTable ("test");
 551                         DataColumn C = new DataColumn ("name");
 552                         T.Columns.Add (C);
 553                         C = new DataColumn ("age");
 554                         C.DataType = typeof (int);
 555                         T.Columns.Add (C);
 556                         C = new DataColumn ("id");
 557                         T.Columns.Add (C);
 558                         DataRow Row = null;
 559
 560                         for (int i = 0; i < 1000; i++) {
 561                                 Row = T.NewRow ();
 562                                 Row [0] = "human" + i;
 563                                 Row [1] = i;
 564                                 Row [2] = i;
 565                                 T.Rows.Add (Row);
 566                         }
 567
 568                         Row = T.NewRow ();
 569                         Row [0] = "human" + "test";
 570                         Row [1] = DBNull.Value;
 571                         Row [2] = DBNull.Value;
 572                         T.Rows.Add (Row);
 573
 574                         //TODO: How to test Convert-function
 575                         Assert.AreEqual (25, T.Select ("age = 5*5") [0]["age"], "test#01");
 576                         Assert.AreEqual (901, T.Select ("len(name) > 7").Length, "test#02");
 577                         Assert.AreEqual (125, T.Select ("age = 5*5*5 AND len(name)>7") [0]["age"], "test#03");
 578                         Assert.AreEqual (1, T.Select ("isnull(id, 'test') = 'test'").Length, "test#04");
 579                         Assert.AreEqual (1000, T.Select ("iif(id = '56', 'test', 'false') = 'false'").Length, "test#05");
 580                         Assert.AreEqual (1, T.Select ("iif(id = '56', 'test', 'false') = 'test'").Length, "test#06");
 581                         Assert.AreEqual (9, T.Select ("substring(id, 2, 3) = '23'").Length, "test#07");
 582                         Assert.AreEqual ("123", T.Select ("substring(id, 2, 3) = '23'") [0] ["id"], "test#08");
 583                         Assert.AreEqual ("423", T.Select ("substring(id, 2, 3) = '23'") [3] ["id"], "test#09");
 584                         Assert.AreEqual ("923", T.Select ("substring(id, 2, 3) = '23'") [8] ["id"], "test#10");
 585
 586                 }
 587
 588                 [Test]
 589                 public void SelectRelations ()
 590                 {
 591                         DataSet Set = new DataSet ();
 592                         DataTable Mom = new DataTable ("Mom");
 593                         DataTable Child = new DataTable ("Child");
 594
 595                         Set.Tables.Add (Mom);
 596                         Set.Tables.Add (Child);
 597
 598                         DataColumn Col = new DataColumn ("Name");
 599                         DataColumn Col2 = new DataColumn ("ChildName");
 600                         Mom.Columns.Add (Col);
 601                         Mom.Columns.Add (Col2);
 602
 603                         DataColumn Col3 = new DataColumn ("Name");
 604                         DataColumn Col4 = new DataColumn ("Age");
 605                         Col4.DataType = Type.GetType ("System.Int16");
 606                         Child.Columns.Add (Col3);
 607                         Child.Columns.Add (Col4);
 608
 609                         DataRelation Relation = new DataRelation ("Rel", Mom.Columns [1], Child.Columns [0]);
 610                         Set.Relations.Add (Relation);
 611
 612                         DataRow Row = Mom.NewRow ();
 613                         Row [0] = "Laura";
 614                         Row [1] = "Nick";
 615                         Mom.Rows.Add (Row);
 616
 617                         Row = Mom.NewRow ();
 618                         Row [0] = "Laura";
 619                         Row [1] = "Dick";
 620                         Mom.Rows.Add (Row);
 621
 622                         Row = Mom.NewRow ();
 623                         Row [0] = "Laura";
 624                         Row [1] = "Mick";
 625                         Mom.Rows.Add (Row);
 626
 627                         Row = Mom.NewRow ();
 628                         Row [0] = "Teresa";
 629                         Row [1] = "Jack";
 630                         Mom.Rows.Add (Row);
 631
 632                         Row = Mom.NewRow ();
 633                         Row [0] = "Teresa";
 634                         Row [1] = "Mack";
 635                         Mom.Rows.Add (Row);
 636
 637                         Row = Child.NewRow ();
 638                         Row [0] = "Nick";
 639                         Row [1] = 15;
 640                         Child.Rows.Add (Row);
 641
 642                         Row = Child.NewRow ();
 643                         Row [0] = "Dick";
 644                         Row [1] = 25;
 645                         Child.Rows.Add (Row);
 646
 647                         Row = Child.NewRow ();
 648                         Row [0] = "Mick";
 649                         Row [1] = 35;
 650                         Child.Rows.Add (Row);
 651
 652                         Row = Child.NewRow ();
 653                         Row [0] = "Jack";
 654                         Row [1] = 10;
 655                         Child.Rows.Add (Row);
 656
 657                         Row = Child.NewRow ();
 658                         Row [0] = "Mack";
 659                         Row [1] = 19;
 660                         Child.Rows.Add (Row);
 661
 662                         Row = Child.NewRow ();
 663                         Row [0] = "Mack";
 664                         Row [1] = 99;
 665                         Child.Rows.Add (Row);
 666
 667                         DataRow [] Rows = Child.Select ("name = Parent.Childname");
 668                         Assert.AreEqual (6, Rows.Length, "test#01");
 669                         Rows = Child.Select ("Parent.childname = 'Jack'");
 670                         Assert.AreEqual (1, Rows.Length, "test#02");
 671
 672                         /*
 673                         try {
 674                                 // FIXME: LAMESPEC: Why the exception is thrown why... why...
 675                                 Mom.Select ("Child.Name = 'Jack'");
 676                                 Assert.Fail ("test#03");
 677                         } catch (Exception e) {
 678                                 Assert.AreEqual (typeof (SyntaxErrorException), e.GetType (), "test#04");
 679                                 Assert.AreEqual ("Cannot interpret token 'Child' at position 1.", e.Message, "test#05");
 680                         }
 681                         */
 682
 683                         Rows = Child.Select ("Parent.name = 'Laura'");
 684                         Assert.AreEqual (3, Rows.Length, "test#06");
 685
 686                         DataTable Parent2 = new DataTable ("Parent2");
 687                         Col = new DataColumn ("Name");
 688                         Col2 = new DataColumn ("ChildName");
 689
 690                         Parent2.Columns.Add (Col);
 691                         Parent2.Columns.Add (Col2);
 692                         Set.Tables.Add (Parent2);
 693
 694                         Row = Parent2.NewRow ();
 695                         Row [0] = "Laura";
 696                         Row [1] = "Nick";
 697                         Parent2.Rows.Add (Row);
 698
 699                         Row = Parent2.NewRow ();
 700                         Row [0] = "Laura";
 701                         Row [1] = "Dick";
 702                         Parent2.Rows.Add (Row);
 703
 704                         Row = Parent2.NewRow ();
 705                         Row [0] = "Laura";
 706                         Row [1] = "Mick";
 707                         Parent2.Rows.Add (Row);
 708
 709                         Row = Parent2.NewRow ();
 710                         Row [0] = "Teresa";
 711                         Row [1] = "Jack";
 712                         Parent2.Rows.Add (Row);
 713
 714                         Row = Parent2.NewRow ();
 715                         Row [0] = "Teresa";
 716                         Row [1] = "Mack";
 717                         Parent2.Rows.Add (Row);
 718
 719                         Relation = new DataRelation ("Rel2", Parent2.Columns [1], Child.Columns [0]);
 720                         Set.Relations.Add (Relation);
 721
 722                         try {
 723                                 Rows = Child.Select ("Parent.ChildName = 'Jack'");
 724                                 Assert.Fail ("test#07");
 725                         } catch (Exception e) {
 726                                 Assert.AreEqual (typeof (EvaluateException), e.GetType (), "test#08");
 727                                 //Assert.AreEqual ("The table [Child] involved in more than one relation. You must explicitly mention a relation name in the expression 'parent.[ChildName]'.", e.Message, "test#09");
 728                         }
 729
 730                         Rows = Child.Select ("Parent(rel).ChildName = 'Jack'");
 731                         Assert.AreEqual (1, Rows.Length, "test#10");
 732
 733                         Rows = Child.Select ("Parent(Rel2).ChildName = 'Jack'");
 734                         Assert.AreEqual (1, Rows.Length, "test#10");
 735
 736                         try {
 737                                 Mom.Select ("Parent.name  = 'John'");
 738                         } catch (Exception e) {
 739                                 Assert.AreEqual (typeof (IndexOutOfRangeException), e.GetType (), "test#11");
 740                                 Assert.AreEqual ("Cannot find relation 0.", e.Message, "test#12");
 741                         }
 742
 743                 }
 744
 745                 [Test]
 746                 public void SelectRowState()
 747                 {
 748                         DataTable d = new DataTable();
 749                         d.Columns.Add (new DataColumn ("aaa"));
 750                         DataRow [] rows = d.Select (null, null, DataViewRowState.Deleted);
 751                         Assert.AreEqual (0, rows.Length);
 752                         d.Rows.Add (new object [] {"bbb"});
 753                         d.Rows.Add (new object [] {"bbb"});
 754                         rows = d.Select (null, null, DataViewRowState.Deleted);
 755                         Assert.AreEqual (0, rows.Length);
 756                 }
 757
 758                 [Test]
 759                 public void ToStringTest()
 760                 {
 761                         DataTable dt = new DataTable();
 762                         dt.Columns.Add("Col1",typeof(int));
 763
 764                         dt.TableName = "Mytable";
 765                         dt.DisplayExpression = "Col1";
 766
 767
 768                         string cmpr = dt.TableName + " + " + dt.DisplayExpression;
 769                         Assert.AreEqual (cmpr, dt.ToString());
 770                 }
 771
 772                 [Test]
 773                 public void PrimaryKey ()
 774                 {
 775                         DataTable dt = new DataTable ();
 776                         DataColumn Col = new DataColumn ();
 777                         Col.AllowDBNull = false;
 778                         Col.DataType = typeof (int);
 779                         dt.Columns.Add (Col);
 780                         dt.Columns.Add ();
 781                         dt.Columns.Add ();
 782                         dt.Columns.Add ();
 783
 784                         Assert.AreEqual (0, dt.PrimaryKey.Length, "test#01");
 785
 786                         dt.PrimaryKey = new DataColumn [] {dt.Columns [0]};
 787                         Assert.AreEqual (1, dt.PrimaryKey.Length, "test#02");
 788                         Assert.AreEqual ("Column1", dt.PrimaryKey [0].ColumnName, "test#03");
 789
 790                         dt.PrimaryKey = null;
 791                         Assert.AreEqual (0, dt.PrimaryKey.Length, "test#04");
 792
 793                         Col = new DataColumn ("failed");
 794
 795                         try {
 796                                 dt.PrimaryKey = new DataColumn [] {Col};
 797                                 Assert.Fail ("test#05");
 798                         } catch (Exception e) {
 799                                 Assert.AreEqual (typeof (ArgumentException), e.GetType (), "test#06");
 800                                 Assert.AreEqual ("Column must belong to a table.", e.Message, "test#07");
 801                         }
 802
 803                         DataTable dt2 = new DataTable ();
 804                         dt2.Columns.Add ();
 805
 806                         try {
 807                                 dt.PrimaryKey = new DataColumn [] {dt2.Columns [0]};
 808                                 Assert.Fail ("test#08");
 809                         } catch (Exception e) {
 810                                 Assert.AreEqual (typeof (ArgumentException), e.GetType (), "test#09");
 811                                 Assert.AreEqual ("PrimaryKey columns do not belong to this table.", e.Message, "test#10");
 812                         }
 813
 814
 815                         Assert.AreEqual (0, dt.Constraints.Count, "test#11");
 816
 817                         dt.PrimaryKey = new DataColumn [] {dt.Columns [0], dt.Columns [1]};
 818                         Assert.AreEqual (2, dt.PrimaryKey.Length, "test#12");
 819                         Assert.AreEqual (1, dt.Constraints.Count, "test#13");
 820                         Assert.IsTrue (dt.Constraints [0] is UniqueConstraint, "test#14");
 821                         Assert.AreEqual ("Column1", dt.PrimaryKey [0].ColumnName, "test#15");
 822                         Assert.AreEqual ("Column2", dt.PrimaryKey [1].ColumnName, "test#16");
 823
 824                 }
 825
 826                 [Test]
 827                 public void PropertyExceptions ()
 828                 {
 829                         DataSet set = new DataSet ();
 830                         DataTable table = new DataTable ();
 831                         DataTable table1 =  new DataTable ();
 832                         set.Tables.Add (table);
 833                         set.Tables.Add (table1);
 834
 835                         DataColumn col = new DataColumn ();
 836                         col.ColumnName = "Id";
 837                         col.DataType = Type.GetType ("System.Int32");
 838                         table.Columns.Add (col);
 839                         UniqueConstraint uc = new UniqueConstraint ("UK1", table.Columns[0] );
 840                         table.Constraints.Add (uc);
 841                         table.CaseSensitive = false;
 842
 843                         col = new DataColumn ();
 844                         col.ColumnName = "Name";
 845                         col.DataType = Type.GetType ("System.String");
 846                         table.Columns.Add (col);
 847
 848                         col = new DataColumn ();
 849                         col.ColumnName = "Id";
 850                         col.DataType = Type.GetType ("System.Int32");
 851                         table1.Columns.Add (col);
 852                         col = new DataColumn ();
 853                         col.ColumnName = "Name";
 854                         col.DataType = Type.GetType ("System.String");
 855                         table1.Columns.Add (col);
 856
 857                         DataRelation dr = new DataRelation ("DR", table.Columns[0], table1.Columns[0]);
 858                         set.Relations.Add (dr);
 859
 860                         try {
 861                                 table.CaseSensitive = true;
 862                                 table1.CaseSensitive = true;
 863                                 Assert.Fail ("#A01");
 864                         }
 865                         catch (Exception e) {
 866                                 if (e.GetType () != typeof (AssertionException))
 867                                         Assert.AreEqual ("Cannot change CaseSensitive or Locale property. This change would lead to at least one DataRelation or Constraint to have different Locale or CaseSensitive settings between its related tables.", e.Message, "#A02");
 868                                 else
 869                                         Console.WriteLine (e);
 870                         }
 871                         try {
 872                                 CultureInfo cultureInfo = new CultureInfo ("en-gb");
 873                                 table.Locale = cultureInfo;
 874                                 table1.Locale = cultureInfo;
 875                                 Assert.Fail ("#A03");
 876                         }
 877                         catch (Exception e) {
 878                                  if (e.GetType () != typeof (AssertionException))
 879                                         Assert.AreEqual ("Cannot change CaseSensitive or Locale property. This change would lead to at least one DataRelation or Constraint to have different Locale or CaseSensitive settings between its related tables.", e.Message, "#A04");
 880                                 else
 881                                         Console.WriteLine (e);
 882                         }
 883                         try {
 884                                 table.Prefix = "Prefix#1";
 885                                 Assert.Fail ("#A05");
 886                         }
 887                         catch (Exception e){
 888                                 if (e.GetType () != typeof (AssertionException))
 889                                         Assert.AreEqual ("Prefix 'Prefix#1' is not valid, because it contains special characters.",e.Message, "#A06");
 890                                 else
 891                                         Console.WriteLine (e);
 892
 893                         }
 894                 }
 895
 896                 [Test]
 897                 public void GetErrors ()
 898                 {
 899                         DataTable table = new DataTable ();
 900
 901                         DataColumn col = new DataColumn ();
 902                         col.ColumnName = "Id";
 903                         col.DataType = Type.GetType ("System.Int32");
 904                         table.Columns.Add (col);
 905
 906                         col = new DataColumn ();
 907                         col.ColumnName = "Name";
 908                         col.DataType = Type.GetType ("System.String");
 909                         table.Columns.Add (col);
 910
 911                         DataRow row = table.NewRow ();
 912                         row ["Id"] = 147;
 913                         row ["name"] = "Abc";
 914                         row.RowError = "Error#1";
 915                         table.Rows.Add (row);
 916
 917                         Assert.AreEqual (1, table.GetErrors ().Length, "#A01");
 918                         Assert.AreEqual ("Error#1", (table.GetErrors ())[0].RowError, "#A02");
 919                 }
 920 #if NET_2_0
 921                 [Test]
 922                 public void NewRowAddedTest ()
 923                 {
 924                         DataTable table = new DataTable ();
 925
 926                         DataColumn col = new DataColumn ();
 927                         col.ColumnName = "Id";
 928                         col.DataType = Type.GetType ("System.Int32");
 929                         table.Columns.Add (col);
 930
 931                         col = new DataColumn ();
 932                         col.ColumnName = "Name";
 933                         col.DataType = Type.GetType ("System.String");
 934                         table.Columns.Add (col);
 935
 936                         _tableNewRowAddedEventFired = false;
 937                         table.TableNewRow += new DataTableNewRowEventHandler (OnTableNewRowAdded);
 938                         DataRow row = table.NewRow ();
 939                         row ["Id"] = 147;
 940                         row ["name"] = "Abc";
 941                         table.Rows.Add (row);
 942
 943                         Assert.IsTrue (_tableNewRowAddedEventFired, "#NewRowAdded Event #01");
 944                 }
 945 #endif
 946                 [Test]
 947                 public void CloneCopyTest ()
 948                 {
 949                         DataTable table = new DataTable ();
 950                         table.TableName = "Table#1";
 951                         DataTable table1 = new DataTable ();
 952                         table1.TableName = "Table#2";
 953
 954                         table.AcceptChanges ();
 955
 956                         DataSet set = new DataSet ("Data Set#1");
 957                         set.DataSetName = "Dataset#1";
 958                         set.Tables.Add (table);
 959                         set.Tables.Add (table1);
 960
 961                         DataColumn col = new DataColumn ();
 962                         col.ColumnName = "Id";
 963                         col.DataType = Type.GetType ("System.Int32");
 964                         table.Columns.Add (col);
 965                         UniqueConstraint uc = new UniqueConstraint ("UK1", table.Columns[0] );
 966                         table.Constraints.Add (uc);
 967
 968                         col = new DataColumn ();
 969                         col.ColumnName = "Id";
 970                         col.DataType = Type.GetType ("System.Int32");
 971                         table1.Columns.Add (col);
 972
 973                         col = new DataColumn ();
 974                         col.ColumnName = "Name";
 975                         col.DataType = Type.GetType ("System.String");
 976                         table.Columns.Add (col);
 977
 978                         col = new DataColumn ();
 979                         col.ColumnName = "Name";
 980                         col.DataType = Type.GetType ("System.String");
 981                         table1.Columns.Add (col);
 982                         DataRow row = table.NewRow ();
 983                         row ["Id"] = 147;
 984                         row ["name"] = "Abc";
 985                         row.RowError = "Error#1";
 986                         table.Rows.Add (row);
 987
 988                         row = table.NewRow ();
 989                         row ["Id"] = 47;
 990                         row ["name"] = "Efg";
 991                         table.Rows.Add (row);
 992                         table.AcceptChanges ();
 993
 994                         table.CaseSensitive = true;
 995                         table1.CaseSensitive = true;
 996                         table.MinimumCapacity = 100;
 997                         table.Prefix = "PrefixNo:1";
 998                         table.Namespace = "Namespace#1";
 999                         table.DisplayExpression = "Id / Name + (Id * Id)";
1000                         DataColumn[] colArray = {table.Columns[0]};
1001                         table.PrimaryKey = colArray;
1002                         table.ExtendedProperties.Add ("TimeStamp", DateTime.Now);
1003 #if NET_1_1 // This prevents further tests after .NET 1.1.
1004 #else
1005                         CultureInfo cultureInfo = new CultureInfo ("en-gb");
1006                         table.Locale = cultureInfo;
1007 #endif
1008
1009                         row = table1.NewRow ();
1010                         row ["Name"] = "Abc";
1011                         row ["Id"] = 147;
1012                         table1.Rows.Add (row);
1013
1014                         row = table1.NewRow ();
1015                         row ["Id"] = 47;
1016                         row ["Name"] = "Efg";
1017                         table1.Rows.Add (row);
1018
1019                         DataRelation dr = new DataRelation ("DR", table.Columns[0], table1.Columns[0]);
1020                         set.Relations.Add (dr);
1021
1022                         //Testing properties of clone
1023                         DataTable cloneTable = table.Clone ();
1024                         Assert.IsTrue (cloneTable.CaseSensitive, "#A01");
1025                         Assert.AreEqual (0 , cloneTable.ChildRelations.Count, "#A02");
1026                         Assert.AreEqual (0 , cloneTable.ParentRelations.Count, "#A03");
1027                         Assert.AreEqual (2,  cloneTable.Columns.Count, "#A04");
1028                         Assert.AreEqual (1, cloneTable.Constraints.Count, "#A05");
1029                         Assert.AreEqual ("Id / Name + (Id * Id)", cloneTable.DisplayExpression, "#A06");
1030                         Assert.AreEqual (1, cloneTable.ExtendedProperties.Count, "#A07");
1031                         Assert.IsFalse (cloneTable.HasErrors, "#A08");
1032 #if NET_1_1
1033 #else
1034                         Assert.AreEqual (2057, cloneTable.Locale.LCID, "#A09");
1035 #endif
1036                         Assert.AreEqual (100, cloneTable.MinimumCapacity, "#A10");
1037                         Assert.AreEqual ("Namespace#1", cloneTable.Namespace, "#A11");
1038                         Assert.AreEqual ("PrefixNo:1", cloneTable.Prefix, "#A12");
1039                         Assert.AreEqual ("Id",  cloneTable.PrimaryKey[0].ColumnName, "#A13");
1040                         Assert.AreEqual (0, cloneTable.Rows.Count , "#A14");
1041                         Assert.AreEqual ("Table#1", cloneTable.TableName, "#A15");
1042
1043                         //Testing properties of copy
1044                         DataTable copyTable = table.Copy ();
1045                         Assert.IsTrue (copyTable.CaseSensitive, "#A16");
1046                         Assert.AreEqual (0 , copyTable.ChildRelations.Count, "#A17");
1047                         Assert.AreEqual (0 , copyTable.ParentRelations.Count, "#A18");
1048                         Assert.AreEqual (2,  copyTable.Columns.Count, "#A19");
1049                         Assert.AreEqual (1, copyTable.Constraints.Count, "#A20");
1050                         Assert.AreEqual ("Id / Name + (Id * Id)", copyTable.DisplayExpression, "#A21");
1051                         Assert.AreEqual (1, copyTable.ExtendedProperties.Count, "#A22");
1052                         Assert.IsTrue (copyTable.HasErrors, "#A23");
1053 #if NET_1_1
1054 #else
1055                         Assert.AreEqual (2057, copyTable.Locale.LCID, "#A24");
1056 #endif
1057                         Assert.AreEqual (100, copyTable.MinimumCapacity, "#A25");
1058                         Assert.AreEqual ("Namespace#1", copyTable.Namespace, "#A26");
1059                         Assert.AreEqual ("PrefixNo:1", copyTable.Prefix, "#A27");
1060                         Assert.AreEqual ("Id",  copyTable.PrimaryKey[0].ColumnName, "#A28");
1061                         Assert.AreEqual (2, copyTable.Rows.Count, "#A29");
1062                         Assert.AreEqual ("Table#1", copyTable.TableName, "#A30");
1063                 }
1064
1065                 [Test]
1066                 public void LoadDataException ()
1067                 {
1068                         DataTable table = new DataTable ();
1069                         DataColumn col = new DataColumn ();
1070                         col.ColumnName = "Id";
1071                         col.DataType = Type.GetType ("System.Int32");
1072                         col.DefaultValue = 47;
1073                         table.Columns.Add (col);
1074                         UniqueConstraint uc = new UniqueConstraint ("UK1", table.Columns[0] );
1075                         table.Constraints.Add (uc);
1076
1077                         col = new DataColumn ();
1078                         col.ColumnName = "Name";
1079                         col.DataType = Type.GetType ("System.String");
1080                         col.DefaultValue = "Hello";
1081                         table.Columns.Add (col);
1082
1083                         table.BeginLoadData();
1084                         object[] row = {147, "Abc"};
1085                         DataRow newRow = table.LoadDataRow (row, true);
1086
1087                         object[] row1 = {147, "Efg"};
1088                         DataRow newRow1 = table.LoadDataRow (row1, true);
1089
1090                         object[] row2 = {143, "Hij"};
1091                         DataRow newRow2 = table.LoadDataRow (row2, true);
1092
1093                         try {
1094                                 table.EndLoadData ();
1095                                 Assert.Fail ("#A01");
1096                         }
1097                         catch (ConstraintException) {
1098                         }
1099                 }
1100                 [Test]
1101                 public void Changes () //To test GetChanges and RejectChanges
1102                 {
1103                         DataTable table = new DataTable ();
1104
1105                         DataColumn col = new DataColumn ();
1106                         col.ColumnName = "Id";
1107                         col.DataType = Type.GetType ("System.Int32");
1108                         table.Columns.Add (col);
1109                         UniqueConstraint uc = new UniqueConstraint ("UK1", table.Columns[0] );
1110                         table.Constraints.Add (uc);
1111
1112                         col = new DataColumn ();
1113                         col.ColumnName = "Name";
1114                         col.DataType = Type.GetType ("System.String");
1115                         table.Columns.Add (col);
1116
1117                         DataRow row = table.NewRow ();
1118                         row ["Id"] = 147;
1119                         row ["name"] = "Abc";
1120                         table.Rows.Add (row);
1121                         table.AcceptChanges ();
1122
1123                         row = table.NewRow ();
1124                         row ["Id"] = 47;
1125                         row ["name"] = "Efg";
1126                         table.Rows.Add (row);
1127
1128                         //Testing GetChanges
1129                         DataTable changesTable = table.GetChanges ();
1130                         Assert.AreEqual (1, changesTable.Rows.Count, "#A01");
1131                         Assert.AreEqual ("Efg", changesTable.Rows[0]["Name"], "#A02");
1132                         table.AcceptChanges ();
1133                         changesTable = table.GetChanges ();
1134                         try {
1135                                 int cnt = changesTable.Rows.Count;
1136                         }
1137                         catch(Exception e) {
1138                                 if (e.GetType () != typeof (AssertionException))
1139                                         Assert.AreEqual (typeof(NullReferenceException), e.GetType (), "#A03");
1140                                 else
1141                                         Console.WriteLine (e);
1142                         }
1143
1144                         //Testing RejectChanges
1145                         row = table.NewRow ();
1146                         row ["Id"] = 247;
1147                         row ["name"] = "Hij";
1148                         table.Rows.Add (row);
1149
1150                         (table.Rows [0])["Name"] = "AaBbCc";
1151                         table.RejectChanges ();
1152                         Assert.AreEqual ("Abc" , (table.Rows [0]) ["Name"], "#A03");
1153                         Assert.AreEqual (2, table.Rows.Count, "#A04");
1154                 }
1155
1156                 [Test]
1157                 public void ImportRowTest ()
1158                 {
1159                         // build source table
1160                         DataTable src = new DataTable ();
1161                         src.Columns.Add ("id", typeof (int));
1162                         src.Columns.Add ("name", typeof (string));
1163
1164                         src.PrimaryKey = new DataColumn [] {src.Columns [0]} ;
1165
1166                         src.Rows.Add (new object [] { 1, "mono 1" });
1167                         src.Rows.Add (new object [] { 2, "mono 2" });
1168                         src.Rows.Add (new object [] { 3, "mono 3" });
1169                         src.AcceptChanges ();
1170
1171                         src.Rows [0] [1] = "mono changed 1";  // modify 1st row
1172                         src.Rows [1].Delete ();              // delete 2nd row
1173                         // 3rd row is unchanged
1174                         src.Rows.Add (new object [] { 4, "mono 4" }); // add 4th row
1175
1176                         // build target table
1177                         DataTable target = new DataTable ();
1178                         target.Columns.Add ("id", typeof (int));
1179                         target.Columns.Add ("name", typeof (string));
1180
1181                         target.PrimaryKey = new DataColumn [] {target.Columns [0]} ;
1182
1183                         // import all rows
1184                         target.ImportRow (src.Rows [0]);     // import 1st row
1185                         target.ImportRow (src.Rows [1]);     // import 2nd row
1186                         target.ImportRow (src.Rows [2]);     // import 3rd row
1187                         target.ImportRow (src.Rows [3]);     // import 4th row
1188
1189                         try {
1190                                 target.ImportRow (src.Rows [2]); // import 3rd row again
1191                                 Assert.Fail ("#AA1 Should have thrown exception violativ PK");
1192                         } catch (ConstraintException e) {}
1193
1194                         // check row states
1195                         Assert.AreEqual (src.Rows [0].RowState, target.Rows [0].RowState, "#A1");
1196                         Assert.AreEqual (src.Rows [1].RowState, target.Rows [1].RowState, "#A2");
1197                         Assert.AreEqual (src.Rows [2].RowState, target.Rows [2].RowState, "#A3");
1198                         Assert.AreEqual (src.Rows [3].RowState, target.Rows [3].RowState, "#A4");
1199
1200                         // check for modified row (1st row)
1201                         Assert.AreEqual ((string) src.Rows [0] [1], (string) target.Rows [0] [1], "#B1");
1202                         Assert.AreEqual ((string) src.Rows [0] [1, DataRowVersion.Default], (string) target.Rows [0] [1, DataRowVersion.Default], "#B2");
1203                         Assert.AreEqual ((string) src.Rows [0] [1, DataRowVersion.Original], (string) target.Rows [0] [1, DataRowVersion.Original], "#B3");
1204                         Assert.AreEqual ((string) src.Rows [0] [1, DataRowVersion.Current], (string) target.Rows [0] [1, DataRowVersion.Current], "#B4");
1205                         Assert.IsFalse (target.Rows [0].HasVersion(DataRowVersion.Proposed), "#B5");
1206
1207                         // check for deleted row (2nd row)
1208                         Assert.AreEqual ((string) src.Rows [1] [1, DataRowVersion.Original], (string) target.Rows [1] [1, DataRowVersion.Original], "#C1");
1209
1210                         // check for unchanged row (3rd row)
1211                         Assert.AreEqual ((string) src.Rows [2] [1], (string) target.Rows [2] [1], "#D1");
1212                         Assert.AreEqual ((string) src.Rows [2] [1, DataRowVersion.Default], (string) target.Rows [2] [1, DataRowVersion.Default], "#D2");
1213                         Assert.AreEqual ((string) src.Rows [2] [1, DataRowVersion.Original], (string) target.Rows [2] [1, DataRowVersion.Original], "#D3");
1214                         Assert.AreEqual ((string) src.Rows [2] [1, DataRowVersion.Current], (string) target.Rows [2] [1, DataRowVersion.Current], "#D4");
1215
1216                         // check for newly added row (4th row)
1217                         Assert.AreEqual ((string) src.Rows [3] [1], (string) target.Rows [3] [1], "#E1");
1218                         Assert.AreEqual ((string) src.Rows [3] [1, DataRowVersion.Default], (string) target.Rows [3] [1, DataRowVersion.Default], "#E2");
1219                         Assert.AreEqual ((string) src.Rows [3] [1, DataRowVersion.Current], (string) target.Rows [3] [1, DataRowVersion.Current], "#E3");
1220                 }
1221
1222                 [Test]
1223                 public void ImportRowDetachedTest ()
1224                 {
1225                         DataTable table = new DataTable ();
1226                         DataColumn col = new DataColumn ();
1227                         col.ColumnName = "Id";
1228                         col.DataType = Type.GetType ("System.Int32");
1229                         table.Columns.Add (col);
1230
1231                         table.PrimaryKey = new DataColumn [] {col};
1232
1233                         col = new DataColumn ();
1234                         col.ColumnName = "Name";
1235                         col.DataType = Type.GetType ("System.String");
1236                         table.Columns.Add (col);
1237
1238                         DataRow row = table.NewRow ();
1239                         row ["Id"] = 147;
1240                         row ["name"] = "Abc";
1241
1242                         // keep silent as ms.net ;-), though this is not useful.
1243                         table.ImportRow (row);
1244
1245                         //if RowState is detached, then dont import the row.
1246                         Assert.AreEqual (0, table.Rows.Count, "#1");
1247                 }
1248
1249                 [Test]
1250                 public void ImportRowDeletedTest ()
1251                 {
1252                         DataTable table = new DataTable ();
1253                         table.Columns.Add ("col", typeof (int));
1254                         table.Columns.Add ("col1", typeof (int));
1255
1256                         DataRow row = table.Rows.Add (new object[] {1,2});
1257                         table.PrimaryKey = new DataColumn[] {table.Columns[0]};
1258                         table.AcceptChanges ();
1259
1260                         // If row is in Deleted state, then ImportRow loads the
1261                         // row.
1262                         row.Delete ();
1263                         table.ImportRow (row);
1264                         Assert.AreEqual (2, table.Rows.Count, "#1");
1265
1266                         // Both the deleted rows shud be now gone
1267                         table.AcceptChanges ();
1268                         Assert.AreEqual (0, table.Rows.Count, "#2");
1269
1270                         //just add another row
1271                         row = table.Rows.Add (new object[] {1,2});
1272                         // no exception shud be thrown
1273                         table.AcceptChanges ();
1274
1275                         // If row is in Deleted state, then ImportRow loads the
1276                         // row and validate only on RejectChanges
1277                         row.Delete ();
1278                         table.ImportRow (row);
1279                         Assert.AreEqual (2, table.Rows.Count, "#3");
1280                         Assert.AreEqual (DataRowState.Deleted, table.Rows[1].RowState, "#4");
1281
1282                         try {
1283                                 table.RejectChanges ();
1284                                 Assert.Fail ("#5");
1285                         } catch (ConstraintException e) {
1286                         }
1287                 }
1288
1289                 [Test]
1290                 public void ClearReset () //To test Clear and Reset methods
1291                 {
1292                         DataTable table = new DataTable ("table");
1293                         DataTable table1 = new DataTable ("table1");
1294
1295                         DataSet set = new DataSet ();
1296                         set.Tables.Add (table);
1297                         set.Tables.Add (table1);
1298
1299                         table.Columns.Add ("Id", typeof (int));
1300                         table.Columns.Add ("Name", typeof (string));
1301                         table.Constraints.Add (new UniqueConstraint ("UK1", table.Columns [0]));
1302                         table.CaseSensitive = false;
1303
1304                         table1.Columns.Add ("Id", typeof (int));
1305                         table1.Columns.Add ("Name", typeof (string));
1306
1307                         DataRelation dr = new DataRelation ("DR", table.Columns[0], table1.Columns[0]);
1308                         set.Relations.Add (dr);
1309
1310                         DataRow row = table.NewRow ();
1311                         row ["Id"] = 147;
1312                         row ["name"] = "Roopa";
1313                         table.Rows.Add (row);
1314
1315                         row = table.NewRow ();
1316                         row ["Id"] = 47;
1317                         row ["Name"] = "roopa";
1318                         table.Rows.Add (row);
1319
1320                         Assert.AreEqual (2, table.Rows.Count);
1321                         Assert.AreEqual (1, table.ChildRelations.Count);
1322                         try {
1323                                 table.Reset ();
1324                                 Assert.Fail ("#A01, should have thrown ArgumentException");
1325                         }
1326                         catch (ArgumentException) {
1327                         }
1328                         Assert.AreEqual (0, table.Rows.Count, "#CT01");
1329                         Assert.AreEqual (0, table.ChildRelations.Count, "#CT02");
1330                         Assert.AreEqual (0, table.ParentRelations.Count, "#CT03");
1331                         Assert.AreEqual (0, table.Constraints.Count, "#CT04");
1332
1333                         table1.Reset ();
1334                         Assert.AreEqual (0, table1.Rows.Count, "#A05");
1335                         Assert.AreEqual (0, table1.Constraints.Count, "#A06");
1336                         Assert.AreEqual (0, table1.ParentRelations.Count, "#A07");
1337
1338                         // clear test
1339                         table.Clear ();
1340                         Assert.AreEqual (0, table.Rows.Count, "#A08");
1341 #if NET_1_1
1342                         Assert.AreEqual (0, table.Constraints.Count, "#A09");
1343 #else
1344                         Assert.AreEqual (1, table.Constraints.Count, "#A09");
1345 #endif
1346                         Assert.AreEqual (0, table.ChildRelations.Count, "#A10");
1347
1348                 }
1349
1350                 [Test]
1351                 public void ClearTest ()
1352                 {
1353                         DataTable table = new DataTable ("test");
1354                         table.Columns.Add ("id", typeof (int));
1355                         table.Columns.Add ("name", typeof (string));
1356
1357                         table.PrimaryKey = new DataColumn [] { table.Columns [0] } ;
1358
1359                         table.Rows.Add (new object [] { 1, "mono 1" });
1360                         table.Rows.Add (new object [] { 2, "mono 2" });
1361                         table.Rows.Add (new object [] { 3, "mono 3" });
1362                         table.Rows.Add (new object [] { 4, "mono 4" });
1363
1364                         table.AcceptChanges ();
1365 #if NET_2_0
1366                         _tableClearedEventFired = false;
1367                         table.TableCleared += new DataTableClearEventHandler (OnTableCleared);
1368                         _tableClearingEventFired = false;
1369                         table.TableClearing += new DataTableClearEventHandler (OnTableClearing);
1370 #endif // NET_2_0
1371
1372                         table.Clear ();
1373 #if NET_2_0
1374                         Assert.IsTrue (_tableClearingEventFired, "#3 should have fired cleared event");
1375                         Assert.IsTrue (_tableClearedEventFired, "#0 should have fired cleared event");
1376 #endif // NET_2_0
1377
1378                         DataRow r = table.Rows.Find (1);
1379                         Assert.IsTrue (r == null, "#1 should have cleared");
1380
1381                         // try adding new row. indexes should have cleared
1382                         table.Rows.Add (new object [] { 2, "mono 2" });
1383                         Assert.AreEqual (1, table.Rows.Count, "#2 should add row");
1384                 }
1385 #if NET_2_0
1386                 private bool _tableClearedEventFired = false;
1387                 private void OnTableCleared (object src, DataTableClearEventArgs args)
1388                 {
1389                         _tableClearedEventFired = true;
1390                 }
1391                 private bool _tableClearingEventFired = false;
1392                 private void OnTableClearing (object src, DataTableClearEventArgs args)
1393                 {
1394                         _tableClearingEventFired = true;
1395                 }
1396                 private bool _tableNewRowAddedEventFired = false;
1397                 private void OnTableNewRowAdded (object src, DataTableNewRowEventArgs args)
1398                 {
1399                         _tableNewRowAddedEventFired = true;
1400                 }
1401 #endif // NET_2_0
1402
1403
1404 #if NET_2_0
1405                 [Test]
1406                 public void TestWriteXmlSchema1 ()
1407                 {
1408                         DataTable dt = new DataTable("TestWriteXmlSchema");
1409                         dt.Columns.Add("Col1", typeof(int));
1410                         dt.Columns.Add("Col2", typeof(int));
1411                         DataRow dr = dt.NewRow();
1412                         dr[0] = 10;
1413                         dr[1] = 20;
1414                         dt.Rows.Add (dr);
1415                         DataTable dt1 = new DataTable("HelloWorld");
1416                         dt1.Columns.Add("T1", typeof(int));
1417                         dt1.Columns.Add("T2", typeof(int));
1418                         DataRow dr1 = dt1.NewRow();
1419                         dr1[0] = 10;
1420                         dr1[1] = 20;
1421                         dt1.Rows.Add(dr1);
1422                         TextWriter writer = new StringWriter ();
1423                         dt.WriteXmlSchema (writer);
1424                         string TextString = writer.ToString ();
1425                         string substring = TextString.Substring (0, TextString.IndexOf(EOL));
1426                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1427                         Assert.AreEqual ("<?xml version=\"1.0\" encoding=\"utf-16\"?>", substring, "test#01");
1428
1429                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1430                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1431                         Assert.AreEqual ("<xs:schema id=\"NewDataSet\" xmlns=\"\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\">", substring, "test#02");
1432                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1433                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1434                         Assert.AreEqual ("  <xs:element name=\"NewDataSet\" msdata:IsDataSet=\"true\" msdata:MainDataTable=\"TestWriteXmlSchema\" msdata:UseCurrentLocale=\"true\">", substring, "test#03");
1435                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1436                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1437                         Assert.AreEqual ("    <xs:complexType>", substring, "test#04");
1438
1439                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1440                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1441                         Assert.AreEqual ("      <xs:choice minOccurs=\"0\" maxOccurs=\"unbounded\">", substring, "test#05");
1442
1443                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1444                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1445                         Assert.AreEqual ("        <xs:element name=\"TestWriteXmlSchema\">", substring, "test#06");
1446
1447                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1448                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1449                         Assert.AreEqual ("          <xs:complexType>", substring, "test#07");
1450
1451                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1452                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1453                         Assert.AreEqual ("            <xs:sequence>", substring, "test#08");
1454
1455                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1456                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1457                         Assert.AreEqual ("              <xs:element name=\"Col1\" type=\"xs:int\" minOccurs=\"0\" />", substring, "test#09");
1458
1459                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1460                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1461                         Assert.AreEqual ("              <xs:element name=\"Col2\" type=\"xs:int\" minOccurs=\"0\" />", substring, "test#10");
1462
1463                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1464                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1465                         Assert.AreEqual ("            </xs:sequence>", substring, "test#11");
1466
1467                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1468                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1469                         Assert.AreEqual ("          </xs:complexType>", substring, "test#12");
1470
1471                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1472                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1473                         Assert.AreEqual ("        </xs:element>", substring, "test#13");
1474
1475
1476                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1477                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1478                         Assert.AreEqual ("      </xs:choice>", substring, "test#14");
1479
1480                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1481                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1482                         Assert.AreEqual ("    </xs:complexType>", substring, "test#15");
1483
1484                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1485                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1486                         Assert.AreEqual ("  </xs:element>", substring, "test#16");
1487                         Assert.AreEqual ("</xs:schema>", TextString, "test#17");
1488                 }
1489                 [Test]
1490                 public void TestWriteXmlSchema2()
1491                 {
1492                         DataTable dt = new DataTable("TestWriteXmlSchema");
1493                         dt.Columns.Add("Col1", typeof(int));
1494                         dt.Columns.Add("Col2", typeof(int));
1495                         DataRow dr = dt.NewRow();
1496                         dr[0] = 10;
1497                         dr[1] = 20;
1498                         dt.Rows.Add (dr);
1499                         DataTable dt1 = new DataTable("HelloWorld");
1500                         dt1.Columns.Add("T1", typeof(int));
1501                         dt1.Columns.Add("T2", typeof(int));
1502                         DataRow dr1 = dt1.NewRow();
1503                         dr1[0] = 10;
1504                         dr1[1] = 20;
1505                         dt1.Rows.Add(dr1);
1506                         DataSet ds = new DataSet();
1507                         ds.Tables.Add(dt);
1508                         ds.Tables.Add(dt1);
1509                         DataRelation rel = new DataRelation("Relation1", dt.Columns["Col1"], dt1.Columns["T1"]);
1510                         ds.Relations.Add(rel);
1511                         TextWriter writer = new StringWriter ();
1512                         dt.WriteXmlSchema (writer);
1513                         string TextString = writer.ToString ();
1514                         string substring = TextString.Substring (0, TextString.IndexOf(EOL));
1515                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1516                         Assert.AreEqual ("<?xml version=\"1.0\" encoding=\"utf-16\"?>", substring, "test#01");
1517
1518                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1519                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1520                         Assert.AreEqual ("<xs:schema id=\"NewDataSet\" xmlns=\"\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\">", substring, "test#02");
1521                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1522                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1523                         Assert.AreEqual ("  <xs:element name=\"NewDataSet\" msdata:IsDataSet=\"true\" msdata:MainDataTable=\"TestWriteXmlSchema\" msdata:UseCurrentLocale=\"true\">", substring, "test#03");
1524                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1525                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1526                         Assert.AreEqual ("    <xs:complexType>", substring, "test#04");
1527
1528                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1529                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1530                         Assert.AreEqual ("      <xs:choice minOccurs=\"0\" maxOccurs=\"unbounded\">", substring, "test#05");
1531
1532                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1533                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1534                         Assert.AreEqual ("        <xs:element name=\"TestWriteXmlSchema\">", substring, "test#06");
1535
1536                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1537                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1538                         Assert.AreEqual ("          <xs:complexType>", substring, "test#07");
1539
1540                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1541                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1542                         Assert.AreEqual ("            <xs:sequence>", substring, "test#08");
1543
1544                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1545                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1546                         Assert.AreEqual ("              <xs:element name=\"Col1\" type=\"xs:int\" minOccurs=\"0\" />", substring, "test#09");
1547
1548                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1549                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1550                         Assert.AreEqual ("              <xs:element name=\"Col2\" type=\"xs:int\" minOccurs=\"0\" />", substring, "test#10");
1551
1552                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1553                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1554                         Assert.AreEqual ("            </xs:sequence>", substring, "test#11");
1555
1556                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1557                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1558                         Assert.AreEqual ("          </xs:complexType>", substring, "test#12");
1559
1560                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1561                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1562                         Assert.AreEqual ("        </xs:element>", substring, "test#13");
1563
1564                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1565                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1566                         Assert.AreEqual ("      </xs:choice>", substring, "test#14");
1567
1568                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1569                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1570                         Assert.AreEqual ("    </xs:complexType>", substring, "test#15");
1571
1572                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1573                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1574                         Assert.AreEqual ("    <xs:unique name=\"Constraint1\">", substring, "test#16");
1575
1576                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1577                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1578                         Assert.AreEqual ("      <xs:selector xpath=\".//TestWriteXmlSchema\" />", substring, "test#17");
1579
1580                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1581                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1582                         Assert.AreEqual ("      <xs:field xpath=\"Col1\" />", substring, "test#18");
1583
1584                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1585                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1586                         Assert.AreEqual ("    </xs:unique>", substring, "test#19");
1587
1588                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1589                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1590                         Assert.AreEqual ("  </xs:element>", substring, "test#20");
1591                         Assert.AreEqual ("</xs:schema>", TextString, "test#21");
1592                 }
1593                 [Test]
1594                 public void TestWriteXmlSchema3()
1595                 {
1596                         DataTable dt = new DataTable("TestWriteXmlSchema");
1597                         dt.Columns.Add("Col1", typeof(int));
1598                         dt.Columns.Add("Col2", typeof(int));
1599                         DataRow dr = dt.NewRow();
1600                         dr[0] = 10;
1601                         dr[1] = 20;
1602                         dt.Rows.Add (dr);
1603                         DataTable dt1 = new DataTable("HelloWorld");
1604                         dt1.Columns.Add("T1", typeof(int));
1605                         dt1.Columns.Add("T2", typeof(int));
1606                         DataRow dr1 = dt1.NewRow();
1607                         dr1[0] = 10;
1608                         dr1[1] = 20;
1609                         dt1.Rows.Add(dr1);
1610                         DataSet ds = new DataSet();
1611                         ds.Tables.Add(dt);
1612                         ds.Tables.Add(dt1);
1613                         DataRelation rel = new DataRelation("Relation1", dt.Columns["Col1"], dt1.Columns["T1"]);
1614                         ds.Relations.Add(rel);
1615                         TextWriter writer = new StringWriter ();
1616                         dt.WriteXmlSchema (writer, true);
1617                         string TextString = writer.ToString ();
1618                         string substring = TextString.Substring (0, TextString.IndexOf(EOL));
1619                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1620                         Assert.AreEqual ("<?xml version=\"1.0\" encoding=\"utf-16\"?>", substring, "test#01");
1621
1622                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1623                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1624                         Assert.AreEqual ("<xs:schema id=\"NewDataSet\" xmlns=\"\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\">", substring, "test#02");
1625                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1626                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1627                         Assert.AreEqual ("  <xs:element name=\"NewDataSet\" msdata:IsDataSet=\"true\" msdata:MainDataTable=\"TestWriteXmlSchema\" msdata:UseCurrentLocale=\"true\">", substring, "test#03");
1628                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1629                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1630                         Assert.AreEqual ("    <xs:complexType>", substring, "test#04");
1631
1632                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1633                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1634                         Assert.AreEqual ("      <xs:choice minOccurs=\"0\" maxOccurs=\"unbounded\">", substring, "test#05");
1635
1636                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1637                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1638                         Assert.AreEqual ("        <xs:element name=\"TestWriteXmlSchema\">", substring, "test#06");
1639
1640                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1641                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1642                         Assert.AreEqual ("          <xs:complexType>", substring, "test#07");
1643
1644                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1645                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1646                         Assert.AreEqual ("            <xs:sequence>", substring, "test#08");
1647
1648                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1649                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1650                         Assert.AreEqual ("              <xs:element name=\"Col1\" type=\"xs:int\" minOccurs=\"0\" />", substring, "test#09");
1651
1652                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1653                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1654                         Assert.AreEqual ("              <xs:element name=\"Col2\" type=\"xs:int\" minOccurs=\"0\" />", substring, "test#10");
1655
1656                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1657                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1658                         Assert.AreEqual ("            </xs:sequence>", substring, "test#11");
1659
1660                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1661                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1662                         Assert.AreEqual ("          </xs:complexType>", substring, "test#12");
1663
1664                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1665                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1666                         Assert.AreEqual ("        </xs:element>", substring, "test#13");
1667
1668                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1669                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1670                         Assert.AreEqual ("        <xs:element name=\"HelloWorld\">", substring, "test#14");
1671
1672                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1673                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1674                         Assert.AreEqual ("          <xs:complexType>", substring, "test#15");
1675
1676                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1677                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1678                         Assert.AreEqual ("            <xs:sequence>", substring, "test#16");
1679
1680                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1681                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1682                         Assert.AreEqual ("              <xs:element name=\"T1\" type=\"xs:int\" minOccurs=\"0\" />", substring, "test#17");
1683
1684                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1685                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1686                         Assert.AreEqual ("              <xs:element name=\"T2\" type=\"xs:int\" minOccurs=\"0\" />", substring, "test#18");
1687
1688                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1689                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1690                         Assert.AreEqual ("            </xs:sequence>", substring, "test#19");
1691
1692                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1693                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1694                         Assert.AreEqual ("          </xs:complexType>", substring, "test#20");
1695
1696                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1697                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1698                         Assert.AreEqual ("        </xs:element>", substring, "test#21");
1699
1700                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1701                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1702                         Assert.AreEqual ("      </xs:choice>", substring, "test#22");
1703
1704                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1705                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1706                         Assert.AreEqual ("    </xs:complexType>", substring, "test#23");
1707
1708                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1709                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1710                         Assert.AreEqual ("    <xs:unique name=\"Constraint1\">", substring, "test#24");
1711
1712                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1713                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1714                         Assert.AreEqual ("      <xs:selector xpath=\".//TestWriteXmlSchema\" />", substring, "test#25");
1715
1716                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1717                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1718                         Assert.AreEqual ("      <xs:field xpath=\"Col1\" />", substring, "test#26");
1719
1720                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1721                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1722                         Assert.AreEqual ("    </xs:unique>", substring, "test#27");
1723
1724                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1725                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1726                         Assert.AreEqual ("    <xs:keyref name=\"Relation1\" refer=\"Constraint1\">", substring, "test#28");
1727
1728                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1729                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1730                         Assert.AreEqual ("      <xs:selector xpath=\".//HelloWorld\" />", substring, "test#29");
1731
1732                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1733                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1734                         Assert.AreEqual ("      <xs:field xpath=\"T1\" />", substring, "test#30");
1735
1736                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1737                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1738                         Assert.AreEqual ("    </xs:keyref>", substring, "test#31");
1739
1740                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1741                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1742                         Assert.AreEqual ("  </xs:element>", substring, "test#32");
1743                         Assert.AreEqual ("</xs:schema>", TextString, "test#33");
1744                 }
1745 #endif
1746                 [Test]
1747                 public void Serialize ()
1748                 {
1749                         MemoryStream fs = new MemoryStream ();
1750
1751                         // Construct a BinaryFormatter and use it
1752                         // to serialize the data to the stream.
1753                         BinaryFormatter formatter = new BinaryFormatter();
1754
1755                         // Create an array with multiple elements refering to
1756                         // the one Singleton object.
1757                         DataTable dt = new DataTable();
1758
1759
1760                         dt.Columns.Add(new DataColumn("Id", typeof(string)));
1761                         dt.Columns.Add(new DataColumn("ContactName", typeof(string)));
1762                         dt.Columns.Add(new DataColumn("ContactTitle", typeof(string)));
1763                         dt.Columns.Add(new DataColumn("ContactAreaCode", typeof(string)));
1764                         dt.Columns.Add(new DataColumn("ContactPhone", typeof(string)));
1765
1766                         DataRow loRowToAdd;
1767                         loRowToAdd = dt.NewRow();
1768                         loRowToAdd[0] = "a";
1769                         loRowToAdd[1] = "b";
1770                         loRowToAdd[2] = "c";
1771                         loRowToAdd[3] = "d";
1772                         loRowToAdd[4] = "e";
1773
1774                         dt.Rows.Add(loRowToAdd);
1775
1776                         DataTable[] dtarr = new DataTable[] {dt};
1777
1778                         // Serialize the array elements.
1779                         formatter.Serialize(fs, dtarr);
1780
1781                         // Deserialize the array elements.
1782                         fs.Position = 0;
1783                         DataTable[] a2 = (DataTable[]) formatter.Deserialize(fs);
1784
1785                         DataSet ds = new DataSet();
1786                         ds.Tables.Add(a2[0]);
1787
1788                         StringWriter sw = new StringWriter ();
1789                         ds.WriteXml(sw);
1790                         XmlDocument doc = new XmlDocument ();
1791                         doc.LoadXml (sw.ToString ());
1792                         Assert.AreEqual (5, doc.DocumentElement.FirstChild.ChildNodes.Count);
1793                 }
1794
1795                 [Test]
1796                 [ExpectedException (typeof (DataException))]
1797                 public void SetPrimaryKeyAssertsNonNull ()
1798                 {
1799                         DataTable dt = new DataTable ("table");
1800                         dt.Columns.Add ("col1");
1801                         dt.Columns.Add ("col2");
1802                         dt.Constraints.Add (new UniqueConstraint (dt.Columns [0]));
1803                         dt.Rows.Add (new object [] {1, 3});
1804                         dt.Rows.Add (new object [] {DBNull.Value, 3});
1805
1806                         dt.PrimaryKey = new DataColumn [] {dt.Columns [0]};
1807                 }
1808
1809                 [Test]
1810                 [ExpectedException (typeof (NoNullAllowedException))]
1811                 public void PrimaryKeyColumnChecksNonNull ()
1812                 {
1813                         DataTable dt = new DataTable ("table");
1814                         dt.Columns.Add ("col1");
1815                         dt.Columns.Add ("col2");
1816                         dt.Constraints.Add (new UniqueConstraint (dt.Columns [0]));
1817                         dt.PrimaryKey = new DataColumn [] {dt.Columns [0]};
1818                         dt.Rows.Add (new object [] {1, 3});
1819                         dt.Rows.Add (new object [] {DBNull.Value, 3});
1820                 }
1821
1822                 [Test]
1823                 public void PrimaryKey_CheckSetsAllowDBNull ()
1824                 {
1825                         DataTable table = new DataTable ();
1826                         DataColumn col1 = table.Columns.Add ("col1", typeof (int));
1827                         DataColumn col2 = table.Columns.Add ("col2", typeof (int));
1828
1829                         Assert.IsTrue (col1.AllowDBNull, "#1" );
1830                         Assert.IsTrue (col2.AllowDBNull, "#2" );
1831                         Assert.IsFalse (col2.Unique, "#3" );
1832                         Assert.IsFalse (col2.Unique, "#4" );
1833
1834                         table.PrimaryKey = new DataColumn[] {col1,col2};
1835                         Assert.IsFalse (col1.AllowDBNull, "#5" );
1836                         Assert.IsFalse (col2.AllowDBNull, "#6" );
1837                         // LAMESPEC or bug ??
1838                         Assert.IsFalse (col1.Unique, "#7" );
1839                         Assert.IsFalse (col2.Unique, "#8" );
1840                 }
1841
1842                 void RowChanging (object o, DataRowChangeEventArgs e)
1843                 {
1844                         Assert.AreEqual (rowChangingExpectedAction, e.Action, "changing.Action");
1845                         rowChangingRowChanging = true;
1846                 }
1847
1848                 void RowChanged (object o, DataRowChangeEventArgs e)
1849                 {
1850                         Assert.AreEqual (rowChangingExpectedAction, e.Action, "changed.Action");
1851                         rowChangingRowChanged = true;
1852                 }
1853
1854                 bool rowChangingRowChanging, rowChangingRowChanged;
1855                 DataRowAction rowChangingExpectedAction;
1856
1857                 [Test]
1858                 public void RowChanging ()
1859                 {
1860                         DataTable dt = new DataTable ("table");
1861                         dt.Columns.Add ("col1");
1862                         dt.Columns.Add ("col2");
1863                         dt.RowChanging += new DataRowChangeEventHandler (RowChanging);
1864                         dt.RowChanged += new DataRowChangeEventHandler (RowChanged);
1865                         rowChangingExpectedAction = DataRowAction.Add;
1866                         dt.Rows.Add (new object [] {1, 2});
1867                         Assert.IsTrue (rowChangingRowChanging, "changing,Added");
1868                         Assert.IsTrue (rowChangingRowChanged, "changed,Added");
1869                         rowChangingExpectedAction = DataRowAction.Change;
1870                         dt.Rows [0] [0] = 2;
1871                         Assert.IsTrue (rowChangingRowChanging, "changing,Changed");
1872                         Assert.IsTrue (rowChangingRowChanged, "changed,Changed");
1873                 }
1874
1875                  [Test]
1876                 public void CloneSubClassTest()
1877                 {
1878                         MyDataTable dt1 = new MyDataTable();
1879                         MyDataTable dt = (MyDataTable)(dt1.Clone());
1880                         Assert.AreEqual (2, MyDataTable.count, "A#01");
1881                 }
1882
1883                 DataRowAction rowActionChanging = DataRowAction.Nothing;
1884                 DataRowAction rowActionChanged  = DataRowAction.Nothing;
1885                 [Test]
1886                 public void AcceptChangesTest ()
1887                 {
1888                         DataTable dt = new DataTable ("test");
1889                         dt.Columns.Add ("id", typeof (int));
1890                         dt.Columns.Add ("name", typeof (string));
1891
1892                         dt.Rows.Add (new object [] { 1, "mono 1" });
1893
1894                         dt.RowChanged  += new DataRowChangeEventHandler (OnRowChanged);
1895                         dt.RowChanging += new DataRowChangeEventHandler (OnRowChanging);
1896
1897                         try {
1898                                 rowActionChanged = rowActionChanging = DataRowAction.Nothing;
1899                                 dt.AcceptChanges ();
1900
1901                                 Assert.AreEqual (DataRowAction.Commit, rowActionChanging,
1902                                                  "#1 should have fired event and set action to commit");
1903                                 Assert.AreEqual (DataRowAction.Commit, rowActionChanged,
1904                                                  "#2 should have fired event and set action to commit");
1905
1906                         } finally {
1907                                 dt.RowChanged  -= new DataRowChangeEventHandler (OnRowChanged);
1908                                 dt.RowChanging -= new DataRowChangeEventHandler (OnRowChanging);
1909
1910                         }
1911                 }
1912
1913                 [Test]
1914                 public void ColumnObjectTypeTest() {
1915                         DataTable dt = new DataTable();
1916                         dt.Columns.Add("Series Label", typeof(SqlInt32));
1917                         dt.Rows.Add(new object[] {"sss"});
1918                         Assert.AreEqual (1, dt.Rows.Count);
1919                 }
1920
1921 #if NET_2_0
1922                 private bool tableInitialized;
1923                 [Test]
1924                 public void TableInitializedEventTest1 () {
1925                         DataTable dt = new DataTable();
1926                         tableInitialized = false;
1927                         dt.Initialized += new EventHandler (OnTableInitialized);
1928                         dt.Columns.Add("Series Label", typeof(SqlInt32));
1929                         dt.Rows.Add(new object[] {"sss"});
1930                         Assert.IsFalse (tableInitialized, "TableInitialized #01");
1931                         dt.Initialized -= new EventHandler (OnTableInitialized);
1932                 }
1933                 [Test]
1934                 public void TableInitializedEventTest2 () {
1935                         DataTable dt = new DataTable();
1936                         dt.BeginInit ();
1937                         tableInitialized = false;
1938                         dt.Initialized += new EventHandler (OnTableInitialized);
1939                         dt.Columns.Add("Series Label", typeof(SqlInt32));
1940                         dt.Rows.Add(new object[] {"sss"});
1941                         dt.EndInit ();
1942                         dt.Initialized -= new EventHandler (OnTableInitialized);
1943                         Assert.IsTrue (tableInitialized, "TableInitialized #02");
1944                 }
1945                 [Test]
1946                 public void TableInitializedEventTest3 () {
1947                         DataTable dt = new DataTable();
1948                         tableInitialized = true;
1949                         dt.Initialized += new EventHandler (OnTableInitialized);
1950                         dt.Columns.Add("Series Label", typeof(SqlInt32));
1951                         dt.Rows.Add(new object[] {"sss"});
1952                         Assert.AreEqual (tableInitialized, dt.IsInitialized, "TableInitialized #03");
1953                         dt.Initialized -= new EventHandler (OnTableInitialized);
1954                 }
1955                 [Test]
1956                 public void TableInitializedEventTest4 () {
1957                         DataTable dt = new DataTable();
1958                         Assert.IsTrue (dt.IsInitialized, "TableInitialized #04");
1959                         dt.BeginInit ();
1960                         tableInitialized = false;
1961                         dt.Initialized += new EventHandler (OnTableInitialized);
1962                         dt.Columns.Add("Series Label", typeof(SqlInt32));
1963                         dt.Rows.Add(new object[] {"sss"});
1964                         Assert.IsFalse (dt.IsInitialized, "TableInitialized #05");
1965                         dt.EndInit ();
1966                         Assert.IsTrue (dt.IsInitialized, "TableInitialized #06");
1967                         Assert.IsTrue (tableInitialized, "TableInitialized #07");
1968                         dt.Initialized -= new EventHandler (OnTableInitialized);
1969                 }
1970
1971                 private void OnTableInitialized (object src, EventArgs args)
1972                 {
1973                         tableInitialized = true;
1974                 }
1975
1976 #endif
1977
1978                 public void OnRowChanging (object src, DataRowChangeEventArgs args)
1979                 {
1980                         rowActionChanging = args.Action;
1981                 }
1982
1983                 public void OnRowChanged (object src, DataRowChangeEventArgs args)
1984                 {
1985                         rowActionChanged = args.Action;
1986                 }
1987
1988 #if NET_2_0
1989                 private DataTable dt;
1990                 private void localSetup () {
1991                         dt = new DataTable ("test");
1992                         dt.Columns.Add ("id", typeof (int));
1993                         dt.Columns.Add ("name", typeof (string));
1994                         dt.PrimaryKey = new DataColumn[] { dt.Columns["id"] };
1995
1996                         dt.Rows.Add (new object[] { 1, "mono 1" });
1997                         dt.Rows.Add (new object[] { 2, "mono 2" });
1998                         dt.Rows.Add (new object[] { 3, "mono 3" });
1999
2000                         dt.AcceptChanges ();
2001                 }
2002
2003                 #region DataTable.CreateDataReader Tests
2004
2005                 [Test]
2006                 public void CreateDataReader1 () {
2007                         localSetup ();
2008                         DataTableReader dtr = dt.CreateDataReader ();
2009                         Assert.IsTrue (dtr.HasRows, "HasRows");
2010                         Assert.AreEqual (dt.Columns.Count, dtr.FieldCount, "CountCols");
2011                         int ri = 0;
2012                         while (dtr.Read ()) {
2013                                 for (int i = 0; i < dtr.FieldCount; i++) {
2014                                         Assert.AreEqual (dt.Rows[ri][i], dtr[i], "RowData-" + ri + "-" + i);
2015                                 }
2016                                 ri++;
2017                         }
2018                 }
2019
2020                 [Test]
2021                 public void CreateDataReader2 () {
2022                         localSetup ();
2023                         DataTableReader dtr = dt.CreateDataReader ();
2024                         Assert.IsTrue (dtr.HasRows, "HasRows");
2025                         Assert.AreEqual (dt.Columns.Count, dtr.FieldCount, "CountCols");
2026                         dtr.Read ();
2027                         Assert.AreEqual (1, dtr[0], "RowData0-0");
2028                         Assert.AreEqual ("mono 1", dtr[1], "RowData0-1");
2029                         dtr.Read ();
2030                         Assert.AreEqual (2, dtr[0], "RowData1-0");
2031                         Assert.AreEqual ("mono 2", dtr[1], "RowData1-1");
2032                         dtr.Read ();
2033                         Assert.AreEqual (3, dtr[0], "RowData2-0");
2034                         Assert.AreEqual ("mono 3", dtr[1], "RowData2-1");
2035                 }
2036
2037                 #endregion // DataTable.CreateDataReader Tests
2038
2039                 #region DataTable.Load Tests
2040
2041                 [Test]
2042                 public void Load_Basic () {
2043                         localSetup ();
2044                         DataTable dtLoad = new DataTable ("LoadBasic");
2045                         dtLoad.Columns.Add ("id", typeof (int));
2046                         dtLoad.Columns.Add ("name", typeof (string));
2047                         dtLoad.Columns["id"].ReadOnly = true;
2048                         dtLoad.Columns["name"].ReadOnly = true;
2049                         dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2050                         dtLoad.Rows.Add (new object[] { 1, "load 1" });
2051                         dtLoad.Rows.Add (new object[] { 2, "load 2" });
2052                         dtLoad.Rows.Add (new object[] { 3, "load 3" });
2053                         dtLoad.AcceptChanges ();
2054                         DataTableReader dtr = dt.CreateDataReader ();
2055                         dtLoad.Load (dtr);
2056                         Assert.AreEqual (2, dtLoad.Columns.Count, "NColumns");
2057                         Assert.AreEqual (3, dtLoad.Rows.Count, "NRows");
2058                         Assert.AreEqual (1, dtLoad.Rows[0][0], "RowData0-0");
2059                         Assert.AreEqual ("mono 1", dtLoad.Rows[0][1], "RowData0-1");
2060                         Assert.AreEqual (2, dtLoad.Rows[1][0], "RowData1-0");
2061                         Assert.AreEqual ("mono 2", dtLoad.Rows[1][1], "RowData1-1");
2062                         Assert.AreEqual (3, dtLoad.Rows[2][0], "RowData2-0");
2063                         Assert.AreEqual ("mono 3", dtLoad.Rows[2][1], "RowData2-1");
2064                 }
2065
2066                 [Test]
2067                 public void Load_NoSchema () {
2068                         localSetup ();
2069                         DataTable dtLoad = new DataTable ("LoadNoSchema");
2070                         DataTableReader dtr = dt.CreateDataReader ();
2071                         dtLoad.Load (dtr);
2072                         Assert.AreEqual (2, dtLoad.Columns.Count, "NColumns");
2073                         Assert.AreEqual (3, dtLoad.Rows.Count, "NRows");
2074                         Assert.AreEqual (1, dtLoad.Rows[0][0], "RowData0-0");
2075                         Assert.AreEqual ("mono 1", dtLoad.Rows[0][1], "RowData0-1");
2076                         Assert.AreEqual (2, dtLoad.Rows[1][0], "RowData1-0");
2077                         Assert.AreEqual ("mono 2", dtLoad.Rows[1][1], "RowData1-1");
2078                         Assert.AreEqual (3, dtLoad.Rows[2][0], "RowData2-0");
2079                         Assert.AreEqual ("mono 3", dtLoad.Rows[2][1], "RowData2-1");
2080                 }
2081
2082                 internal struct fillErrorStruct {
2083                         internal string error;
2084                         internal string tableName;
2085                         internal int rowKey;
2086                         internal bool contFlag;
2087                         internal void init (string tbl, int row, bool cont, string err) {
2088                                 tableName = tbl;
2089                                 rowKey = row;
2090                                 contFlag = cont;
2091                                 error = err;
2092                         }
2093                 }
2094                 private fillErrorStruct[] fillErr = new fillErrorStruct[3];
2095                 private int fillErrCounter;
2096                 private void fillErrorHandler (object sender, FillErrorEventArgs e) {
2097                         e.Continue = fillErr[fillErrCounter].contFlag;
2098                         Assert.AreEqual (fillErr[fillErrCounter].tableName, e.DataTable.TableName, "fillErr-T");
2099                         //Assert.AreEqual (fillErr[fillErrCounter].rowKey, e.Values[0], "fillErr-R");
2100                         Assert.AreEqual (fillErr[fillErrCounter].contFlag, e.Continue, "fillErr-C");
2101                         //Assert.AreEqual (fillErr[fillErrCounter].error, e.Errors.Message, "fillErr-E");
2102                         fillErrCounter++;
2103                 }
2104
2105                 [Test]
2106                 [ExpectedException (typeof (ArgumentException))]
2107                 public void Load_Incompatible () {
2108                         localSetup ();
2109                         DataTable dtLoad = new DataTable ("LoadIncompatible");
2110                         dtLoad.Columns.Add ("name", typeof (double));
2111                         DataTableReader dtr = dt.CreateDataReader ();
2112                         dtLoad.Load (dtr);
2113                 }
2114                 [Test]
2115                 // Load doesn't have a third overload in System.Data
2116                 // and is commented-out below
2117                 public void Load_IncompatibleEHandlerT () {
2118                         fillErrCounter = 0;
2119                         fillErr[0].init ("LoadIncompatible", 1, true,
2120                                  "Input string was not in a correct format.Couldn't store <mono 1> in name Column.  Expected type is Double.");
2121                         fillErr[1].init ("LoadIncompatible", 2, true,
2122                                 "Input string was not in a correct format.Couldn't store <mono 2> in name Column.  Expected type is Double.");
2123                         fillErr[2].init ("LoadIncompatible", 3, true,
2124                                 "Input string was not in a correct format.Couldn't store <mono 3> in name Column.  Expected type is Double.");
2125                         localSetup ();
2126                         DataTable dtLoad = new DataTable ("LoadIncompatible");
2127                         dtLoad.Columns.Add ("name", typeof (double));
2128                         DataTableReader dtr = dt.CreateDataReader ();
2129                         dtLoad.Load (dtr,LoadOption.PreserveChanges,fillErrorHandler);
2130                 }
2131                 [Test]
2132                 // Load doesn't have a third overload in System.Data
2133                 // and is commented-out below
2134                 [ExpectedException (typeof (ArgumentException))]
2135                 public void Load_IncompatibleEHandlerF () {
2136                         fillErrCounter = 0;
2137                         fillErr[0].init ("LoadIncompatible", 1, false,
2138                                 "Input string was not in a correct format.Couldn't store <mono 1> in name Column.  Expected type is Double.");
2139                         localSetup ();
2140                         DataTable dtLoad = new DataTable ("LoadIncompatible");
2141                         dtLoad.Columns.Add ("name", typeof (double));
2142                         DataTableReader dtr = dt.CreateDataReader ();
2143                         dtLoad.Load (dtr, LoadOption.PreserveChanges, fillErrorHandler);
2144                 }
2145
2146                 [Test]
2147                 public void Load_ExtraColsEqualVal () {
2148                         localSetup ();
2149                         DataTable dtLoad = new DataTable ("LoadExtraCols");
2150                         dtLoad.Columns.Add ("id", typeof (int));
2151                         dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2152                         dtLoad.Rows.Add (new object[] { 1 });
2153                         dtLoad.Rows.Add (new object[] { 2 });
2154                         dtLoad.Rows.Add (new object[] { 3 });
2155                         dtLoad.AcceptChanges ();
2156                         DataTableReader dtr = dt.CreateDataReader ();
2157                         dtLoad.Load (dtr);
2158                         Assert.AreEqual (2, dtLoad.Columns.Count, "NColumns");
2159                         Assert.AreEqual (3, dtLoad.Rows.Count, "NRows");
2160                         Assert.AreEqual (1, dtLoad.Rows[0][0], "RowData0-0");
2161                         Assert.AreEqual ("mono 1", dtLoad.Rows[0][1], "RowData0-1");
2162                         Assert.AreEqual (2, dtLoad.Rows[1][0], "RowData1-0");
2163                         Assert.AreEqual ("mono 2", dtLoad.Rows[1][1], "RowData1-1");
2164                         Assert.AreEqual (3, dtLoad.Rows[2][0], "RowData2-0");
2165                         Assert.AreEqual ("mono 3", dtLoad.Rows[2][1], "RowData2-1");
2166                 }
2167
2168                 [Test]
2169                 public void Load_ExtraColsNonEqualVal () {
2170                         localSetup ();
2171                         DataTable dtLoad = new DataTable ("LoadExtraCols");
2172                         dtLoad.Columns.Add ("id", typeof (int));
2173                         dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2174                         dtLoad.Rows.Add (new object[] { 4 });
2175                         dtLoad.Rows.Add (new object[] { 5 });
2176                         dtLoad.Rows.Add (new object[] { 6 });
2177                         dtLoad.AcceptChanges ();
2178                         DataTableReader dtr = dt.CreateDataReader ();
2179                         dtLoad.Load (dtr);
2180                         Assert.AreEqual (2, dtLoad.Columns.Count, "NColumns");
2181                         Assert.AreEqual (6, dtLoad.Rows.Count, "NRows");
2182                         Assert.AreEqual (4, dtLoad.Rows[0][0], "RowData0-0");
2183                         Assert.AreEqual (5, dtLoad.Rows[1][0], "RowData1-0");
2184                         Assert.AreEqual (6, dtLoad.Rows[2][0], "RowData2-0");
2185                         Assert.AreEqual (1, dtLoad.Rows[3][0], "RowData3-0");
2186                         Assert.AreEqual ("mono 1", dtLoad.Rows[3][1], "RowData3-1");
2187                         Assert.AreEqual (2, dtLoad.Rows[4][0], "RowData4-0");
2188                         Assert.AreEqual ("mono 2", dtLoad.Rows[4][1], "RowData4-1");
2189                         Assert.AreEqual (3, dtLoad.Rows[5][0], "RowData5-0");
2190                         Assert.AreEqual ("mono 3", dtLoad.Rows[5][1], "RowData5-1");
2191                 }
2192
2193                 [Test]
2194                 [ExpectedException (typeof (ConstraintException))]
2195                 public void Load_MissingColsNonNullable () {
2196                         localSetup ();
2197                         DataTable dtLoad = new DataTable ("LoadMissingCols");
2198                         dtLoad.Columns.Add ("id", typeof (int));
2199                         dtLoad.Columns.Add ("name", typeof (string));
2200                         dtLoad.Columns.Add ("missing", typeof (string));
2201                         dtLoad.Columns["missing"].AllowDBNull = false;
2202                         dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2203                         dtLoad.Rows.Add (new object[] { 4, "mono 4", "miss4" });
2204                         dtLoad.Rows.Add (new object[] { 5, "mono 5", "miss5" });
2205                         dtLoad.Rows.Add (new object[] { 6, "mono 6", "miss6" });
2206                         dtLoad.AcceptChanges ();
2207                         DataTableReader dtr = dt.CreateDataReader ();
2208                         dtLoad.Load (dtr);
2209                 }
2210
2211                 [Test]
2212                 public void Load_MissingColsDefault () {
2213                         localSetup ();
2214                         DataTable dtLoad = new DataTable ("LoadMissingCols");
2215                         dtLoad.Columns.Add ("id", typeof (int));
2216                         dtLoad.Columns.Add ("name", typeof (string));
2217                         dtLoad.Columns.Add ("missing", typeof (string));
2218                         dtLoad.Columns["missing"].AllowDBNull = false;
2219                         dtLoad.Columns["missing"].DefaultValue = "DefaultValue";
2220                         dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2221                         dtLoad.Rows.Add (new object[] { 4, "mono 4", "miss4" });
2222                         dtLoad.Rows.Add (new object[] { 5, "mono 5", "miss5" });
2223                         dtLoad.Rows.Add (new object[] { 6, "mono 6", "miss6" });
2224                         dtLoad.AcceptChanges ();
2225                         DataTableReader dtr = dt.CreateDataReader ();
2226                         dtLoad.Load (dtr);
2227                         Assert.AreEqual (3, dtLoad.Columns.Count, "NColumns");
2228                         Assert.AreEqual (6, dtLoad.Rows.Count, "NRows");
2229                         Assert.AreEqual (4, dtLoad.Rows[0][0], "RowData0-0");
2230                         Assert.AreEqual ("mono 4", dtLoad.Rows[0][1], "RowData0-1");
2231                         Assert.AreEqual ("miss4", dtLoad.Rows[0][2], "RowData0-2");
2232                         Assert.AreEqual (5, dtLoad.Rows[1][0], "RowData1-0");
2233                         Assert.AreEqual ("mono 5", dtLoad.Rows[1][1], "RowData1-1");
2234                         Assert.AreEqual ("miss5", dtLoad.Rows[1][2], "RowData1-2");
2235                         Assert.AreEqual (6, dtLoad.Rows[2][0], "RowData2-0");
2236                         Assert.AreEqual ("mono 6", dtLoad.Rows[2][1], "RowData2-1");
2237                         Assert.AreEqual ("miss6", dtLoad.Rows[2][2], "RowData2-2");
2238                         Assert.AreEqual (1, dtLoad.Rows[3][0], "RowData3-0");
2239                         Assert.AreEqual ("mono 1", dtLoad.Rows[3][1], "RowData3-1");
2240                         Assert.AreEqual ("DefaultValue", dtLoad.Rows[3][2], "RowData3-2");
2241                         Assert.AreEqual (2, dtLoad.Rows[4][0], "RowData4-0");
2242                         Assert.AreEqual ("mono 2", dtLoad.Rows[4][1], "RowData4-1");
2243                         Assert.AreEqual ("DefaultValue", dtLoad.Rows[4][2], "RowData4-2");
2244                         Assert.AreEqual (3, dtLoad.Rows[5][0], "RowData5-0");
2245                         Assert.AreEqual ("mono 3", dtLoad.Rows[5][1], "RowData5-1");
2246                         Assert.AreEqual ("DefaultValue", dtLoad.Rows[5][2], "RowData5-2");
2247                 }
2248
2249                 [Test]
2250                 public void Load_MissingColsNullable () {
2251                         localSetup ();
2252                         DataTable dtLoad = new DataTable ("LoadMissingCols");
2253                         dtLoad.Columns.Add ("id", typeof (int));
2254                         dtLoad.Columns.Add ("name", typeof (string));
2255                         dtLoad.Columns.Add ("missing", typeof (string));
2256                         dtLoad.Columns["missing"].AllowDBNull = true;
2257                         dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2258                         dtLoad.Rows.Add (new object[] { 4, "mono 4", "miss4" });
2259                         dtLoad.Rows.Add (new object[] { 5, "mono 5", "miss5" });
2260                         dtLoad.Rows.Add (new object[] { 6, "mono 6", "miss6" });
2261                         dtLoad.AcceptChanges ();
2262                         DataTableReader dtr = dt.CreateDataReader ();
2263                         dtLoad.Load (dtr);
2264                         Assert.AreEqual (3, dtLoad.Columns.Count, "NColumns");
2265                         Assert.AreEqual (6, dtLoad.Rows.Count, "NRows");
2266                         Assert.AreEqual (4, dtLoad.Rows[0][0], "RowData0-0");
2267                         Assert.AreEqual ("mono 4", dtLoad.Rows[0][1], "RowData0-1");
2268                         Assert.AreEqual ("miss4", dtLoad.Rows[0][2], "RowData0-2");
2269                         Assert.AreEqual (5, dtLoad.Rows[1][0], "RowData1-0");
2270                         Assert.AreEqual ("mono 5", dtLoad.Rows[1][1], "RowData1-1");
2271                         Assert.AreEqual ("miss5", dtLoad.Rows[1][2], "RowData1-2");
2272                         Assert.AreEqual (6, dtLoad.Rows[2][0], "RowData2-0");
2273                         Assert.AreEqual ("mono 6", dtLoad.Rows[2][1], "RowData2-1");
2274                         Assert.AreEqual ("miss6", dtLoad.Rows[2][2], "RowData2-2");
2275                         Assert.AreEqual (1, dtLoad.Rows[3][0], "RowData3-0");
2276                         Assert.AreEqual ("mono 1", dtLoad.Rows[3][1], "RowData3-1");
2277                         //Assert.IsNull (dtLoad.Rows[3][2], "RowData3-2");
2278                         Assert.AreEqual (2, dtLoad.Rows[4][0], "RowData4-0");
2279                         Assert.AreEqual ("mono 2", dtLoad.Rows[4][1], "RowData4-1");
2280                         //Assert.IsNull (dtLoad.Rows[4][2], "RowData4-2");
2281                         Assert.AreEqual (3, dtLoad.Rows[5][0], "RowData5-0");
2282                         Assert.AreEqual ("mono 3", dtLoad.Rows[5][1], "RowData5-1");
2283                         //Assert.IsNull (dtLoad.Rows[5][2], "RowData5-2");
2284                 }
2285
2286                 private DataTable setupRowState () {
2287                         DataTable tbl = new DataTable ("LoadRowStateChanges");
2288                         tbl.RowChanged += new DataRowChangeEventHandler (dtLoad_RowChanged);
2289                         tbl.RowChanging += new DataRowChangeEventHandler (dtLoad_RowChanging);
2290                         tbl.Columns.Add ("id", typeof (int));
2291                         tbl.Columns.Add ("name", typeof (string));
2292                         tbl.PrimaryKey = new DataColumn[] { tbl.Columns["id"] };
2293                         tbl.Rows.Add (new object[] { 1, "RowState 1" });
2294                         tbl.Rows.Add (new object[] { 2, "RowState 2" });
2295                         tbl.Rows.Add (new object[] { 3, "RowState 3" });
2296                         tbl.AcceptChanges ();
2297                         // Update Table with following changes: Row0 unmodified,
2298                         // Row1 modified, Row2 deleted, Row3 added, Row4 not-present.
2299                         tbl.Rows[1]["name"] = "Modify 2";
2300                         tbl.Rows[2].Delete ();
2301                         DataRow row = tbl.NewRow ();
2302                         row["id"] = 4;
2303                         row["name"] = "Add 4";
2304                         tbl.Rows.Add (row);
2305                         return (tbl);
2306                 }
2307
2308                 private DataRowAction[] rowChangeAction = new DataRowAction[5];
2309                 private bool checkAction = false;
2310                 private int rowChagedCounter, rowChangingCounter;
2311                 private void rowActionInit (DataRowAction[] act) {
2312                         checkAction = true;
2313                         rowChagedCounter = 0;
2314                         rowChangingCounter = 0;
2315                         for (int i = 0; i < 5; i++)
2316                                 rowChangeAction[i] = act[i];
2317                 }
2318                 private void rowActionEnd () {
2319                         checkAction = false;
2320                 }
2321                 private void dtLoad_RowChanged (object sender, DataRowChangeEventArgs e) {
2322                         if (checkAction) {
2323                                 Assert.AreEqual (rowChangeAction[rowChagedCounter], e.Action, "RowChanged" + rowChagedCounter);
2324                                 rowChagedCounter++;
2325                         }
2326                 }
2327                 private void dtLoad_RowChanging (object sender, DataRowChangeEventArgs e) {
2328                         if (checkAction) {
2329                                 Assert.AreEqual (rowChangeAction[rowChangingCounter], e.Action, "RowChanging" + rowChangingCounter);
2330                                 rowChangingCounter++;
2331                         }
2332                 }
2333
2334                 [Test]
2335                 public void Load_RowStateChangesDefault () {
2336                         localSetup ();
2337                         dt.Rows.Add (new object[] { 4, "mono 4" });
2338                         dt.Rows.Add (new object[] { 5, "mono 5" });
2339                         dt.AcceptChanges ();
2340                         DataTableReader dtr = dt.CreateDataReader ();
2341                         DataTable dtLoad = setupRowState ();
2342                         DataRowAction[] dra = new DataRowAction[] {
2343                                 DataRowAction.ChangeCurrentAndOriginal,
2344                                 DataRowAction.ChangeOriginal,
2345                                 DataRowAction.ChangeOriginal,
2346                                 DataRowAction.ChangeOriginal,
2347                                 DataRowAction.ChangeCurrentAndOriginal};
2348                         rowActionInit (dra);
2349                         dtLoad.Load (dtr);
2350                         rowActionEnd ();
2351                         // asserting Unchanged Row0
2352                         Assert.AreEqual ("mono 1", dtLoad.Rows[0][1,DataRowVersion.Current], "RowData0-C");
2353                         Assert.AreEqual ("mono 1", dtLoad.Rows[0][1,DataRowVersion.Original], "RowData0-O");
2354                         Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[0].RowState, "RowState0");
2355                         // asserting Modified Row1
2356                         Assert.AreEqual ("Modify 2", dtLoad.Rows[1][1, DataRowVersion.Current], "RowData1-C");
2357                         Assert.AreEqual ("mono 2", dtLoad.Rows[1][1, DataRowVersion.Original], "RowData1-O");
2358                         Assert.AreEqual (DataRowState.Modified, dtLoad.Rows[1].RowState, "RowState1");
2359                         // asserting Deleted Row2
2360                         Assert.AreEqual ("mono 3", dtLoad.Rows[2][1, DataRowVersion.Original], "RowData1-O");
2361                         Assert.AreEqual (DataRowState.Deleted, dtLoad.Rows[2].RowState, "RowState2");
2362                         // asserting Added Row3
2363                         Assert.AreEqual ("Add 4", dtLoad.Rows[3][1, DataRowVersion.Current], "RowData3-C");
2364                         Assert.AreEqual ("mono 4", dtLoad.Rows[3][1, DataRowVersion.Original], "RowData3-O");
2365                         Assert.AreEqual (DataRowState.Modified, dtLoad.Rows[3].RowState, "RowState3");
2366                         // asserting Unpresent Row4
2367                         Assert.AreEqual ("mono 5", dtLoad.Rows[4][1, DataRowVersion.Current], "RowData4-C");
2368                         Assert.AreEqual ("mono 5", dtLoad.Rows[4][1, DataRowVersion.Original], "RowData4-O");
2369                         Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[4].RowState, "RowState4");
2370                 }
2371
2372                 [Test]
2373                 [ExpectedException (typeof (VersionNotFoundException))]
2374                 public void Load_RowStateChangesDefaultDelete () {
2375                         localSetup ();
2376                         DataTable dtLoad = new DataTable ("LoadRowStateChanges");
2377                         dtLoad.Columns.Add ("id", typeof (int));
2378                         dtLoad.Columns.Add ("name", typeof (string));
2379                         dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2380                         dtLoad.Rows.Add (new object[] { 1, "RowState 1" });
2381                         dtLoad.Rows.Add (new object[] { 2, "RowState 2" });
2382                         dtLoad.Rows.Add (new object[] { 3, "RowState 3" });
2383                         dtLoad.AcceptChanges ();
2384                         dtLoad.Rows[2].Delete ();
2385                         DataTableReader dtr = dt.CreateDataReader ();
2386                         dtLoad.Load (dtr);
2387                         Assert.AreEqual (" ", dtLoad.Rows[2][1, DataRowVersion.Current], "RowData2-C");
2388                 }
2389
2390                 [Test]
2391                 public void Load_RowStatePreserveChanges () {
2392                         localSetup ();
2393                         dt.Rows.Add (new object[] { 4, "mono 4" });
2394                         dt.Rows.Add (new object[] { 5, "mono 5" });
2395                         dt.AcceptChanges ();
2396                         DataTableReader dtr = dt.CreateDataReader ();
2397                         DataTable dtLoad = setupRowState ();
2398                         DataRowAction[] dra = new DataRowAction[] {
2399                                 DataRowAction.ChangeCurrentAndOriginal,
2400                                 DataRowAction.ChangeOriginal,
2401                                 DataRowAction.ChangeOriginal,
2402                                 DataRowAction.ChangeOriginal,
2403                                 DataRowAction.ChangeCurrentAndOriginal};
2404                         rowActionInit (dra);
2405                         dtLoad.Load (dtr, LoadOption.PreserveChanges);
2406                         rowActionEnd ();
2407                         // asserting Unchanged Row0
2408                         Assert.AreEqual ("mono 1", dtLoad.Rows[0][1, DataRowVersion.Current], "RowData0-C");
2409                         Assert.AreEqual ("mono 1", dtLoad.Rows[0][1, DataRowVersion.Original], "RowData0-O");
2410                         Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[0].RowState, "RowState0");
2411                         // asserting Modified Row1
2412                         Assert.AreEqual ("Modify 2", dtLoad.Rows[1][1, DataRowVersion.Current], "RowData1-C");
2413                         Assert.AreEqual ("mono 2", dtLoad.Rows[1][1, DataRowVersion.Original], "RowData1-O");
2414                         Assert.AreEqual (DataRowState.Modified, dtLoad.Rows[1].RowState, "RowState1");
2415                         // asserting Deleted Row2
2416                         Assert.AreEqual ("mono 3", dtLoad.Rows[2][1, DataRowVersion.Original], "RowData1-O");
2417                         Assert.AreEqual (DataRowState.Deleted, dtLoad.Rows[2].RowState, "RowState2");
2418                         // asserting Added Row3
2419                         Assert.AreEqual ("Add 4", dtLoad.Rows[3][1, DataRowVersion.Current], "RowData3-C");
2420                         Assert.AreEqual ("mono 4", dtLoad.Rows[3][1, DataRowVersion.Original], "RowData3-O");
2421                         Assert.AreEqual (DataRowState.Modified, dtLoad.Rows[3].RowState, "RowState3");
2422                         // asserting Unpresent Row4
2423                         Assert.AreEqual ("mono 5", dtLoad.Rows[4][1, DataRowVersion.Current], "RowData4-C");
2424                         Assert.AreEqual ("mono 5", dtLoad.Rows[4][1, DataRowVersion.Original], "RowData4-O");
2425                         Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[4].RowState, "RowState4");
2426                 }
2427
2428                 [Test]
2429                 [ExpectedException (typeof (VersionNotFoundException))]
2430                 public void Load_RowStatePreserveChangesDelete () {
2431                         localSetup ();
2432                         DataTable dtLoad = new DataTable ("LoadRowStateChanges");
2433                         dtLoad.Columns.Add ("id", typeof (int));
2434                         dtLoad.Columns.Add ("name", typeof (string));
2435                         dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2436                         dtLoad.Rows.Add (new object[] { 1, "RowState 1" });
2437                         dtLoad.Rows.Add (new object[] { 2, "RowState 2" });
2438                         dtLoad.Rows.Add (new object[] { 3, "RowState 3" });
2439                         dtLoad.AcceptChanges ();
2440                         dtLoad.Rows[2].Delete ();
2441                         DataTableReader dtr = dt.CreateDataReader ();
2442                         dtLoad.Load (dtr,LoadOption.PreserveChanges);
2443                         Assert.AreEqual (" ", dtLoad.Rows[2][1, DataRowVersion.Current], "RowData2-C");
2444                 }
2445
2446                 [Test]
2447                 public void Load_RowStateOverwriteChanges () {
2448                         localSetup ();
2449                         dt.Rows.Add (new object[] { 4, "mono 4" });
2450                         dt.Rows.Add (new object[] { 5, "mono 5" });
2451                         dt.AcceptChanges ();
2452                         DataTableReader dtr = dt.CreateDataReader ();
2453                         DataTable dtLoad = setupRowState ();
2454                         DataRowAction[] dra = new DataRowAction[] {
2455                                 DataRowAction.ChangeCurrentAndOriginal,
2456                                 DataRowAction.ChangeCurrentAndOriginal,
2457                                 DataRowAction.ChangeCurrentAndOriginal,
2458                                 DataRowAction.ChangeCurrentAndOriginal,
2459                                 DataRowAction.ChangeCurrentAndOriginal};
2460                         rowActionInit (dra);
2461                         dtLoad.Load (dtr, LoadOption.OverwriteChanges);
2462                         rowActionEnd ();
2463                         // asserting Unchanged Row0
2464                         Assert.AreEqual ("mono 1", dtLoad.Rows[0][1, DataRowVersion.Current], "RowData0-C");
2465                         Assert.AreEqual ("mono 1", dtLoad.Rows[0][1, DataRowVersion.Original], "RowData0-O");
2466                         Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[0].RowState, "RowState0");
2467                         // asserting Modified Row1
2468                         Assert.AreEqual ("mono 2", dtLoad.Rows[1][1, DataRowVersion.Current], "RowData1-C");
2469                         Assert.AreEqual ("mono 2", dtLoad.Rows[1][1, DataRowVersion.Original], "RowData1-O");
2470                         Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[1].RowState, "RowState1");
2471                         // asserting Deleted Row2
2472                         Assert.AreEqual ("mono 3", dtLoad.Rows[2][1, DataRowVersion.Current], "RowData1-C");
2473                         Assert.AreEqual ("mono 3", dtLoad.Rows[2][1, DataRowVersion.Original], "RowData1-O");
2474                         Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[2].RowState, "RowState2");
2475                         // asserting Added Row3
2476                         Assert.AreEqual ("mono 4", dtLoad.Rows[3][1, DataRowVersion.Current], "RowData3-C");
2477                         Assert.AreEqual ("mono 4", dtLoad.Rows[3][1, DataRowVersion.Original], "RowData3-O");
2478                         Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[3].RowState, "RowState3");
2479                         // asserting Unpresent Row4
2480                         Assert.AreEqual ("mono 5", dtLoad.Rows[4][1, DataRowVersion.Current], "RowData4-C");
2481                         Assert.AreEqual ("mono 5", dtLoad.Rows[4][1, DataRowVersion.Original], "RowData4-O");
2482                         Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[4].RowState, "RowState4");
2483                 }
2484
2485                 [Test]
2486                 public void Load_RowStateUpsert () {
2487                         localSetup ();
2488                         dt.Rows.Add (new object[] { 4, "mono 4" });
2489                         dt.Rows.Add (new object[] { 5, "mono 5" });
2490                         dt.AcceptChanges ();
2491                         DataTableReader dtr = dt.CreateDataReader ();
2492                         DataTable dtLoad = setupRowState ();
2493                         // Notice rowChange-Actions only occur 5 times, as number
2494                         // of actual rows, ignoring row duplication of the deleted row.
2495                         DataRowAction[] dra = new DataRowAction[] {
2496                                 DataRowAction.Change,
2497                                 DataRowAction.Change,
2498                                 DataRowAction.Add,
2499                                 DataRowAction.Change,
2500                                 DataRowAction.Add};
2501                         rowActionInit (dra);
2502                         dtLoad.Load (dtr, LoadOption.Upsert);
2503                         rowActionEnd ();
2504                         // asserting Unchanged Row0
2505                         Assert.AreEqual ("mono 1", dtLoad.Rows[0][1, DataRowVersion.Current], "RowData0-C");
2506                         Assert.AreEqual ("RowState 1", dtLoad.Rows[0][1, DataRowVersion.Original], "RowData0-O");
2507                         Assert.AreEqual (DataRowState.Modified, dtLoad.Rows[0].RowState, "RowState0");
2508                         // asserting Modified Row1
2509                         Assert.AreEqual ("mono 2", dtLoad.Rows[1][1, DataRowVersion.Current], "RowData1-C");
2510                         Assert.AreEqual ("RowState 2", dtLoad.Rows[1][1, DataRowVersion.Original], "RowData1-O");
2511                         Assert.AreEqual (DataRowState.Modified, dtLoad.Rows[1].RowState, "RowState1");
2512                         // asserting Deleted Row2 and "Deleted-Added" Row4
2513                         Assert.AreEqual ("RowState 3", dtLoad.Rows[2][1, DataRowVersion.Original], "RowData2-O");
2514                         Assert.AreEqual (DataRowState.Deleted, dtLoad.Rows[2].RowState, "RowState2");
2515                         Assert.AreEqual ("mono 3", dtLoad.Rows[4][1, DataRowVersion.Current], "RowData4-C");
2516                         Assert.AreEqual (DataRowState.Added, dtLoad.Rows[4].RowState, "RowState4");
2517                         // asserting Added Row3
2518                         Assert.AreEqual ("mono 4", dtLoad.Rows[3][1, DataRowVersion.Current], "RowData3-C");
2519                         Assert.AreEqual (DataRowState.Added, dtLoad.Rows[3].RowState, "RowState3");
2520                         // asserting Unpresent Row5
2521                         // Notice row4 is used for added row of deleted row2 and so
2522                         // unpresent row4 moves to row5
2523                         Assert.AreEqual ("mono 5", dtLoad.Rows[5][1, DataRowVersion.Current], "RowData5-C");
2524                         Assert.AreEqual (DataRowState.Added, dtLoad.Rows[5].RowState, "RowState5");
2525                 }
2526
2527                 [Test]
2528                 public void Load_RowStateUpsertDuplicateKey1 () {
2529                         localSetup ();
2530                         dt.Rows.Add (new object[] { 4, "mono 4" });
2531                         DataTable dtLoad = new DataTable ("LoadRowStateChanges");
2532                         dtLoad.Columns.Add ("id", typeof (int));
2533                         dtLoad.Columns.Add ("name", typeof (string));
2534                         dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2535                         dtLoad.Rows.Add (new object[] { 1, "RowState 1" });
2536                         dtLoad.Rows.Add (new object[] { 2, "RowState 2" });
2537                         dtLoad.Rows.Add (new object[] { 3, "RowState 3" });
2538                         dtLoad.AcceptChanges ();
2539                         dtLoad.Rows[2].Delete ();
2540                         DataTableReader dtr = dt.CreateDataReader ();
2541                         dtLoad.Load (dtr, LoadOption.Upsert);
2542                         dtLoad.Rows[3][1] = "NEWVAL";
2543                         Assert.AreEqual (DataRowState.Deleted, dtLoad.Rows[2].RowState, "A-RowState2");
2544                         Assert.AreEqual (3, dtLoad.Rows[2][0, DataRowVersion.Original], "A-RowData2-id");
2545                         Assert.AreEqual ("RowState 3", dtLoad.Rows[2][1, DataRowVersion.Original], "A-RowData2-name");
2546                         Assert.AreEqual (DataRowState.Added, dtLoad.Rows[3].RowState, "A-RowState3");
2547                         Assert.AreEqual (3, dtLoad.Rows[3][0, DataRowVersion.Current], "A-RowData3-id");
2548                         Assert.AreEqual ("NEWVAL", dtLoad.Rows[3][1, DataRowVersion.Current], "A-RowData3-name");
2549                         Assert.AreEqual (DataRowState.Added, dtLoad.Rows[4].RowState, "A-RowState4");
2550                         Assert.AreEqual (4, dtLoad.Rows[4][0, DataRowVersion.Current], "A-RowData4-id");
2551                         Assert.AreEqual ("mono 4", dtLoad.Rows[4][1, DataRowVersion.Current], "A-RowData4-name");
2552
2553                         dtLoad.AcceptChanges ();
2554
2555                         Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[2].RowState, "B-RowState2");
2556                         Assert.AreEqual (3, dtLoad.Rows[2][0, DataRowVersion.Current], "B-RowData2-id");
2557                         Assert.AreEqual ("NEWVAL", dtLoad.Rows[2][1, DataRowVersion.Current], "B-RowData2-name");
2558                         Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[3].RowState, "B-RowState3");
2559                         Assert.AreEqual (4, dtLoad.Rows[3][0, DataRowVersion.Current], "B-RowData3-id");
2560                         Assert.AreEqual ("mono 4", dtLoad.Rows[3][1, DataRowVersion.Current], "B-RowData3-name");
2561                 }
2562
2563                 [Test]
2564                 [ExpectedException (typeof (IndexOutOfRangeException))]
2565                 public void Load_RowStateUpsertDuplicateKey2 () {
2566                         localSetup ();
2567                         dt.Rows.Add (new object[] { 4, "mono 4" });
2568                         DataTable dtLoad = new DataTable ("LoadRowStateChanges");
2569                         dtLoad.Columns.Add ("id", typeof (int));
2570                         dtLoad.Columns.Add ("name", typeof (string));
2571                         dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2572                         dtLoad.Rows.Add (new object[] { 1, "RowState 1" });
2573                         dtLoad.Rows.Add (new object[] { 2, "RowState 2" });
2574                         dtLoad.Rows.Add (new object[] { 3, "RowState 3" });
2575                         dtLoad.AcceptChanges ();
2576                         dtLoad.Rows[2].Delete ();
2577                         DataTableReader dtr = dt.CreateDataReader ();
2578                         dtLoad.Load (dtr, LoadOption.Upsert);
2579                         dtLoad.AcceptChanges ();
2580                         Assert.AreEqual (" ", dtLoad.Rows[4][1], "RowData4");
2581                 }
2582
2583                 [Test]
2584                 [ExpectedException (typeof (VersionNotFoundException))]
2585                 public void Load_RowStateUpsertDelete1 () {
2586                         localSetup ();
2587                         DataTable dtLoad = new DataTable ("LoadRowStateChanges");
2588                         dtLoad.Columns.Add ("id", typeof (int));
2589                         dtLoad.Columns.Add ("name", typeof (string));
2590                         dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2591                         dtLoad.Rows.Add (new object[] { 1, "RowState 1" });
2592                         dtLoad.Rows.Add (new object[] { 2, "RowState 2" });
2593                         dtLoad.Rows.Add (new object[] { 3, "RowState 3" });
2594                         dtLoad.AcceptChanges ();
2595                         dtLoad.Rows[2].Delete ();
2596                         DataTableReader dtr = dt.CreateDataReader ();
2597                         dtLoad.Load (dtr, LoadOption.Upsert);
2598                         Assert.AreEqual (" ", dtLoad.Rows[2][1, DataRowVersion.Current], "RowData2-C");
2599                 }
2600
2601                 [Test]
2602                 [ExpectedException (typeof (VersionNotFoundException))]
2603                 public void Load_RowStateUpsertDelete2 () {
2604                         localSetup ();
2605                         DataTable dtLoad = new DataTable ("LoadRowStateChanges");
2606                         dtLoad.Columns.Add ("id", typeof (int));
2607                         dtLoad.Columns.Add ("name", typeof (string));
2608                         dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2609                         dtLoad.Rows.Add (new object[] { 1, "RowState 1" });
2610                         dtLoad.Rows.Add (new object[] { 2, "RowState 2" });
2611                         dtLoad.Rows.Add (new object[] { 3, "RowState 3" });
2612                         dtLoad.AcceptChanges ();
2613                         dtLoad.Rows[2].Delete ();
2614                         DataTableReader dtr = dt.CreateDataReader ();
2615                         dtLoad.Load (dtr, LoadOption.Upsert);
2616                         Assert.AreEqual (" ", dtLoad.Rows[3][1, DataRowVersion.Original], "RowData3-O");
2617                 }
2618
2619                 [Test]
2620                 [ExpectedException (typeof (VersionNotFoundException))]
2621                 public void Load_RowStateUpsertAdd () {
2622                         localSetup ();
2623                         dt.Rows.Add (new object[] { 4, "mono 4" });
2624                         DataTable dtLoad = new DataTable ("LoadRowStateChanges");
2625                         dtLoad.Columns.Add ("id", typeof (int));
2626                         dtLoad.Columns.Add ("name", typeof (string));
2627                         dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2628                         dtLoad.Rows.Add (new object[] { 1, "RowState 1" });
2629                         dtLoad.Rows.Add (new object[] { 2, "RowState 2" });
2630                         dtLoad.Rows.Add (new object[] { 3, "RowState 3" });
2631                         dtLoad.AcceptChanges ();
2632                         DataRow row = dtLoad.NewRow ();
2633                         row["id"] = 4;
2634                         row["name"] = "Add 4";
2635                         dtLoad.Rows.Add (row);
2636                         DataTableReader dtr = dt.CreateDataReader ();
2637                         dtLoad.Load (dtr, LoadOption.Upsert);
2638                         Assert.AreEqual (" ", dtLoad.Rows[3][1, DataRowVersion.Original], "RowData3-O");
2639                 }
2640
2641                 [Test]
2642                 [ExpectedException (typeof (VersionNotFoundException))]
2643                 public void Load_RowStateUpsertUnpresent () {
2644                         localSetup ();
2645                         dt.Rows.Add (new object[] { 4, "mono 4" });
2646                         DataTable dtLoad = new DataTable ("LoadRowStateChanges");
2647                         dtLoad.Columns.Add ("id", typeof (int));
2648                         dtLoad.Columns.Add ("name", typeof (string));
2649                         dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2650                         dtLoad.Rows.Add (new object[] { 1, "RowState 1" });
2651                         dtLoad.Rows.Add (new object[] { 2, "RowState 2" });
2652                         dtLoad.Rows.Add (new object[] { 3, "RowState 3" });
2653                         dtLoad.AcceptChanges ();
2654                         DataTableReader dtr = dt.CreateDataReader ();
2655                         dtLoad.Load (dtr, LoadOption.Upsert);
2656                         Assert.AreEqual (" ", dtLoad.Rows[3][1, DataRowVersion.Original], "RowData3-O");
2657                 }
2658
2659                 [Test]
2660                 public void Load_RowStateUpsertUnchangedEqualVal () {
2661                         localSetup ();
2662                         DataTable dtLoad = new DataTable ("LoadRowStateChanges");
2663                         dtLoad.Columns.Add ("id", typeof (int));
2664                         dtLoad.Columns.Add ("name", typeof (string));
2665                         dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2666                         dtLoad.Rows.Add (new object[] { 1, "mono 1" });
2667                         dtLoad.AcceptChanges ();
2668                         DataTableReader dtr = dt.CreateDataReader ();
2669                         DataRowAction[] dra = new DataRowAction[] {
2670                                 DataRowAction.Nothing,// REAL action
2671                                 DataRowAction.Nothing,// dummy
2672                                 DataRowAction.Nothing,// dummy
2673                                 DataRowAction.Nothing,// dummy
2674                                 DataRowAction.Nothing};// dummy
2675                         rowActionInit (dra);
2676                         dtLoad.Load (dtr, LoadOption.Upsert);
2677                         rowActionEnd ();
2678                         Assert.AreEqual ("mono 1", dtLoad.Rows[0][1, DataRowVersion.Current], "RowData0-C");
2679                         Assert.AreEqual ("mono 1", dtLoad.Rows[0][1, DataRowVersion.Original], "RowData0-O");
2680                         Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[0].RowState, "RowState0");
2681                 }
2682
2683                 [Test]
2684                 public void LoadDataRow_LoadOptions () {
2685                         // LoadDataRow is covered in detail (without LoadOptions) in DataTableTest2
2686                         // LoadOption tests are covered in detail in DataTable.Load().
2687                         // Therefore only minimal tests of LoadDataRow with LoadOptions are covered here.
2688                         DataTable dt;
2689                         DataRow dr;
2690                         dt = CreateDataTableExample ();
2691                         dt.PrimaryKey = new DataColumn[] { dt.Columns[0] };     //add ParentId as Primary Key
2692                         dt.Columns["String1"].DefaultValue = "Default";
2693
2694                         dr = dt.Select ("ParentId=1")[0];
2695
2696                         //Update existing row with LoadOptions = OverwriteChanges
2697                         dt.BeginLoadData ();
2698                         dt.LoadDataRow (new object[] { 1, null, "Changed" },
2699                                 LoadOption.OverwriteChanges);
2700                         dt.EndLoadData ();
2701
2702                         // LoadDataRow(update1) - check column String2
2703                         Assert.AreEqual ("Changed", dr["String2", DataRowVersion.Current], "DT72-C");
2704                         Assert.AreEqual ("Changed", dr["String2", DataRowVersion.Original], "DT72-O");
2705
2706                         // LoadDataRow(update1) - check row state
2707                         Assert.AreEqual (DataRowState.Unchanged, dr.RowState, "DT73-LO");
2708
2709                         //Add New row with LoadOptions = Upsert
2710                         dt.BeginLoadData ();
2711                         dt.LoadDataRow (new object[] { 99, null, "Changed" },
2712                                 LoadOption.Upsert);
2713                         dt.EndLoadData ();
2714
2715                         // LoadDataRow(insert1) - check column String2
2716                         dr = dt.Select ("ParentId=99")[0];
2717                         Assert.AreEqual ("Changed", dr["String2", DataRowVersion.Current], "DT75-C");
2718
2719                         // LoadDataRow(insert1) - check row state
2720                         Assert.AreEqual (DataRowState.Added, dr.RowState, "DT76-LO");
2721                 }
2722
2723                 public static DataTable CreateDataTableExample () {
2724                         DataTable dtParent = new DataTable ("Parent");
2725
2726                         dtParent.Columns.Add ("ParentId", typeof (int));
2727                         dtParent.Columns.Add ("String1", typeof (string));
2728                         dtParent.Columns.Add ("String2", typeof (string));
2729
2730                         dtParent.Columns.Add ("ParentDateTime", typeof (DateTime));
2731                         dtParent.Columns.Add ("ParentDouble", typeof (double));
2732                         dtParent.Columns.Add ("ParentBool", typeof (bool));
2733
2734                         dtParent.Rows.Add (new object[] { 1, "1-String1", "1-String2", new DateTime (2005, 1, 1, 0, 0, 0, 0), 1.534, true });
2735                         dtParent.Rows.Add (new object[] { 2, "2-String1", "2-String2", new DateTime (2004, 1, 1, 0, 0, 0, 1), -1.534, true });
2736                         dtParent.Rows.Add (new object[] { 3, "3-String1", "3-String2", new DateTime (2003, 1, 1, 0, 0, 1, 0), double.MinValue * 10000, false });
2737                         dtParent.Rows.Add (new object[] { 4, "4-String1", "4-String2", new DateTime (2002, 1, 1, 0, 1, 0, 0), double.MaxValue / 10000, true });
2738                         dtParent.Rows.Add (new object[] { 5, "5-String1", "5-String2", new DateTime (2001, 1, 1, 1, 0, 0, 0), 0.755, true });
2739                         dtParent.Rows.Add (new object[] { 6, "6-String1", "6-String2", new DateTime (2000, 1, 1, 0, 0, 0, 0), 0.001, false });
2740                         dtParent.AcceptChanges ();
2741                         return dtParent;
2742                 }
2743
2744                 #endregion // DataTable.Load Tests
2745
2746                 #region Read/Write XML Tests
2747
2748                 [Test]
2749                 //[Category ("NotWorking")]
2750                 public void ReadXmlSchema () {
2751                         DataTable Table = new DataTable ();
2752                         Table.ReadXmlSchema ("Test/System.Data/own_schema1.xsd");
2753
2754                         Assert.AreEqual ("test_table", Table.TableName, "test#02");
2755                         Assert.AreEqual ("", Table.Namespace, "test#03");
2756                         Assert.AreEqual (2, Table.Columns.Count, "test#04");
2757                         Assert.AreEqual (0, Table.Rows.Count, "test#05");
2758                         Assert.IsFalse (Table.CaseSensitive, "test#06");
2759                         Assert.AreEqual (1, Table.Constraints.Count, "test#07");
2760                         Assert.AreEqual ("", Table.Prefix, "test#08");
2761
2762                         Constraint cons = Table.Constraints[0];
2763                         Assert.AreEqual ("Constraint1", cons.ConstraintName.ToString (), "test#09");
2764                         Assert.AreEqual ("Constraint1", cons.ToString (), "test#10");
2765
2766                         DataColumn column = Table.Columns[0];
2767                         Assert.IsTrue (column.AllowDBNull, "test#11");
2768                         Assert.IsFalse (column.AutoIncrement, "test#12");
2769                         Assert.AreEqual (0L, column.AutoIncrementSeed, "test#13");
2770                         Assert.AreEqual (1L, column.AutoIncrementStep, "test#14");
2771                         Assert.AreEqual ("test", column.Caption, "test#15");
2772                         Assert.AreEqual ("Element", column.ColumnMapping.ToString (), "test#16");
2773                         Assert.AreEqual ("first", column.ColumnName, "test#17");
2774                         Assert.AreEqual ("System.String", column.DataType.ToString (), "test#18");
2775                         Assert.AreEqual ("test_default_value", column.DefaultValue.ToString (), "test#19");
2776                         Assert.IsFalse (column.DesignMode, "test#20");
2777                         Assert.AreEqual ("", column.Expression, "test#21");
2778                         Assert.AreEqual (100, column.MaxLength, "test#22");
2779                         Assert.AreEqual ("", column.Namespace, "test#23");
2780                         Assert.AreEqual (0, column.Ordinal, "test#24");
2781                         Assert.AreEqual ("", column.Prefix, "test#25");
2782                         Assert.IsFalse (column.ReadOnly, "test#26");
2783                         Assert.IsTrue (column.Unique, "test#27");
2784
2785                         DataColumn column2 = Table.Columns[1];
2786                         Assert.IsTrue (column2.AllowDBNull, "test#28");
2787                         Assert.IsFalse (column2.AutoIncrement, "test#29");
2788                         Assert.AreEqual (0L, column2.AutoIncrementSeed, "test#30");
2789                         Assert.AreEqual (1L, column2.AutoIncrementStep, "test#31");
2790                         Assert.AreEqual ("second", column2.Caption, "test#32");
2791                         Assert.AreEqual ("Element", column2.ColumnMapping.ToString (), "test#33");
2792                         Assert.AreEqual ("second", column2.ColumnName, "test#34");
2793                         Assert.AreEqual ("System.Data.SqlTypes.SqlGuid", column2.DataType.ToString (), "test#35");
2794                         Assert.AreEqual ("Null", column2.DefaultValue.ToString (), "test#36");
2795                         Assert.IsFalse (column2.DesignMode, "test#37");
2796                         Assert.AreEqual ("", column2.Expression, "test#38");
2797                         Assert.AreEqual (-1, column2.MaxLength, "test#39");
2798                         Assert.AreEqual ("", column2.Namespace, "test#40");
2799                         Assert.AreEqual (1, column2.Ordinal, "test#41");
2800                         Assert.AreEqual ("", column2.Prefix, "test#42");
2801                         Assert.IsFalse (column2.ReadOnly, "test#43");
2802                         Assert.IsFalse (column2.Unique, "test#44");
2803
2804                         DataTable Table2 = new DataTable ();
2805                         Table2.ReadXmlSchema ("Test/System.Data/own_schema2.xsd");
2806
2807                         Assert.AreEqual ("second_test_table", Table2.TableName, "test#45");
2808                         Assert.AreEqual ("", Table2.Namespace, "test#46");
2809                         Assert.AreEqual (1, Table2.Columns.Count, "test#47");
2810                         Assert.AreEqual (0, Table2.Rows.Count, "test#48");
2811                         Assert.IsFalse (Table2.CaseSensitive, "test#49");
2812                         Assert.AreEqual (1, Table2.Constraints.Count, "test#50");
2813                         Assert.AreEqual ("", Table2.Prefix, "test#51");
2814
2815                         DataColumn column3 = Table2.Columns[0];
2816                         Assert.IsTrue (column3.AllowDBNull, "test#52");
2817                         Assert.IsFalse (column3.AutoIncrement, "test#53");
2818                         Assert.AreEqual (0L, column3.AutoIncrementSeed, "test#54");
2819                         Assert.AreEqual (1L, column3.AutoIncrementStep, "test#55");
2820                         Assert.AreEqual ("second_first", column3.Caption, "test#56");
2821                         Assert.AreEqual ("Element", column3.ColumnMapping.ToString (), "test#57");
2822                         Assert.AreEqual ("second_first", column3.ColumnName, "test#58");
2823                         Assert.AreEqual ("System.String", column3.DataType.ToString (), "test#59");
2824                         Assert.AreEqual ("default_value", column3.DefaultValue.ToString (), "test#60");
2825                         Assert.IsFalse (column3.DesignMode, "test#61");
2826                         Assert.AreEqual ("", column3.Expression, "test#62");
2827                         Assert.AreEqual (100, column3.MaxLength, "test#63");
2828                         Assert.AreEqual ("", column3.Namespace, "test#64");
2829                         Assert.AreEqual (0, column3.Ordinal, "test#65");
2830                         Assert.AreEqual ("", column3.Prefix, "test#66");
2831                         Assert.IsFalse (column3.ReadOnly, "test#67");
2832                         Assert.IsTrue (column3.Unique, "test#68");
2833                 }
2834
2835                 [Test]
2836                 public void ReadXmlSchema_2 () {
2837                         DataTable dt = new DataTable ();
2838                         string xmlData = string.Empty;
2839                         xmlData += "<?xml version=\"1.0\"?>";
2840                         xmlData += "<xs:schema id=\"SiteConfiguration\" targetNamespace=\"http://tempuri.org/PortalCfg.xsd\" xmlns:mstns=\"http://tempuri.org/PortalCfg.xsd\" xmlns=\"http://tempuri.org/PortalCfg.xsd\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\" attributeFormDefault=\"qualified\" elementFormDefault=\"qualified\">";
2841                         xmlData += "<xs:element name=\"SiteConfiguration\" msdata:IsDataSet=\"true\" msdata:EnforceConstraints=\"False\">";
2842                         xmlData += "<xs:complexType>";
2843                         xmlData += "<xs:choice  minOccurs=\"0\" maxOccurs=\"unbounded\">";
2844                         xmlData += "<xs:element name=\"Tab\">";
2845                         xmlData += "<xs:complexType>";
2846                         xmlData += "<xs:sequence>";
2847                         xmlData += "<xs:element name=\"Module\" minOccurs=\"0\" maxOccurs=\"unbounded\">";
2848                         xmlData += "<xs:complexType>";
2849                         xmlData += "<xs:attribute name=\"ModuleId\" form=\"unqualified\" type=\"xs:int\" />";
2850                         xmlData += "</xs:complexType>";
2851                         xmlData += "</xs:element>";
2852                         xmlData += "</xs:sequence>";
2853                         xmlData += "<xs:attribute name=\"TabId\" form=\"unqualified\" type=\"xs:int\" />";
2854                         xmlData += "</xs:complexType>";
2855                         xmlData += "</xs:element>";
2856                         xmlData += "</xs:choice>";
2857                         xmlData += "</xs:complexType>";
2858                         xmlData += "<xs:key name=\"TabKey\" msdata:PrimaryKey=\"true\">";
2859                         xmlData += "<xs:selector xpath=\".//mstns:Tab\" />";
2860                         xmlData += "<xs:field xpath=\"@TabId\" />";
2861                         xmlData += "</xs:key>";
2862                         xmlData += "<xs:key name=\"ModuleKey\" msdata:PrimaryKey=\"true\">";
2863                         xmlData += "<xs:selector xpath=\".//mstns:Module\" />";
2864                         xmlData += "<xs:field xpath=\"@ModuleID\" />";
2865                         xmlData += "</xs:key>";
2866                         xmlData += "</xs:element>";
2867                         xmlData += "</xs:schema>";
2868                         dt.ReadXmlSchema (new StringReader (xmlData));
2869                 }
2870
2871                 [Test]
2872                 public void ReadXmlSchema_ByStream () {
2873                         DataSet ds1 = new DataSet ();
2874                         ds1.Tables.Add (DataProvider.CreateParentDataTable ());
2875                         ds1.Tables.Add (DataProvider.CreateChildDataTable ());
2876
2877                         MemoryStream ms1 = new MemoryStream ();
2878                         MemoryStream ms2 = new MemoryStream ();
2879                         //write xml  schema only
2880                         //ds1.WriteXmlSchema (ms);
2881                         ds1.Tables[0].WriteXmlSchema (ms1);
2882                         ds1.Tables[1].WriteXmlSchema (ms2);
2883
2884                         MemoryStream ms11 = new MemoryStream (ms1.GetBuffer ());
2885                         MemoryStream ms22 = new MemoryStream (ms2.GetBuffer ());
2886                         //copy schema
2887                         //DataSet ds2 = new DataSet ();
2888                         DataTable dt1 = new DataTable ();
2889                         DataTable dt2 = new DataTable ();
2890
2891                         //ds2.ReadXmlSchema (ms1);
2892                         dt1.ReadXmlSchema (ms11);
2893                         dt2.ReadXmlSchema (ms22);
2894
2895                         //check xml schema
2896                         // ReadXmlSchema - Tables count
2897                         //Assert.AreEqual (ds2.Tables.Count, ds1.Tables.Count, "DS269");
2898
2899                         // ReadXmlSchema - Tables 0 Col count
2900                         Assert.AreEqual (ds1.Tables[0].Columns.Count, dt1.Columns.Count, "DS270");
2901
2902                         // ReadXmlSchema - Tables 1 Col count
2903                         Assert.AreEqual (ds1.Tables[1].Columns.Count, dt2.Columns.Count, "DS271");
2904
2905                         //check some colummns types
2906                         // ReadXmlSchema - Tables 0 Col type
2907                         Assert.AreEqual (ds1.Tables[0].Columns[0].GetType (), dt1.Columns[0].GetType (), "DS272");
2908
2909                         // ReadXmlSchema - Tables 1 Col type
2910                         Assert.AreEqual (ds1.Tables[1].Columns[3].GetType (), dt2.Columns[3].GetType (), "DS273");
2911
2912                         //check that no data exists
2913                         // ReadXmlSchema - Table 1 row count
2914                         Assert.AreEqual (0, dt1.Rows.Count, "DS274");
2915
2916                         // ReadXmlSchema - Table 2 row count
2917                         Assert.AreEqual (0, dt2.Rows.Count, "DS275");
2918                 }
2919
2920                 [Test]
2921                 public void ReadWriteXmlSchema_ByFileName () {
2922                         string sTempFileName1 = "tmpDataSet_ReadWriteXml_43899-1.xml";
2923                         string sTempFileName2 = "tmpDataSet_ReadWriteXml_43899-2.xml";
2924
2925                         DataSet ds1 = new DataSet ();
2926                         ds1.Tables.Add (DataProvider.CreateParentDataTable ());
2927                         ds1.Tables.Add (DataProvider.CreateChildDataTable ());
2928
2929                         ds1.Tables[0].WriteXmlSchema (sTempFileName1);
2930                         ds1.Tables[1].WriteXmlSchema (sTempFileName2);
2931
2932                         DataTable dt1 = new DataTable ();
2933                         DataTable dt2 = new DataTable ();
2934
2935                         dt1.ReadXmlSchema (sTempFileName1);
2936                         dt2.ReadXmlSchema (sTempFileName2);
2937
2938                         Assert.AreEqual (ds1.Tables[0].Columns.Count, dt1.Columns.Count, "DS277");
2939                         Assert.AreEqual (ds1.Tables[1].Columns.Count, dt2.Columns.Count, "DS278");
2940                         Assert.AreEqual (ds1.Tables[0].Columns[0].GetType (), dt1.Columns[0].GetType (), "DS279");
2941                         Assert.AreEqual (ds1.Tables[1].Columns[3].GetType (), dt2.Columns[3].GetType (), "DS280");
2942                         Assert.AreEqual (0, dt1.Rows.Count, "DS281");
2943                         Assert.AreEqual (0, dt2.Rows.Count, "DS282");
2944
2945                         File.Delete (sTempFileName1);
2946                         File.Delete (sTempFileName2);
2947                 }
2948
2949                 [Test]
2950                 public void ReadXmlSchema_ByTextReader () {
2951                         DataSet ds1 = new DataSet ();
2952                         ds1.Tables.Add (DataProvider.CreateParentDataTable ());
2953                         ds1.Tables.Add (DataProvider.CreateChildDataTable ());
2954
2955                         StringWriter sw1 = new StringWriter ();
2956                         StringWriter sw2 = new StringWriter ();
2957                         //write xml file, schema only
2958                         //ds1.WriteXmlSchema (sw);
2959                         ds1.Tables[0].WriteXmlSchema (sw1);
2960                         ds1.Tables[1].WriteXmlSchema (sw2);
2961
2962                         StringReader sr1 = new StringReader (sw1.GetStringBuilder ().ToString ());
2963                         StringReader sr2 = new StringReader (sw2.GetStringBuilder ().ToString ());
2964                         //copy both data and schema
2965                         //DataSet ds2 = new DataSet ();
2966                         DataTable dt1 = new DataTable ();
2967                         DataTable dt2 = new DataTable ();
2968
2969                         //ds2.ReadXmlSchema (sr);
2970                         dt1.ReadXmlSchema (sr1);
2971                         dt2.ReadXmlSchema (sr2);
2972
2973                         //check xml schema
2974                         // ReadXmlSchema - Tables count
2975                         //Assert.AreEqual (ds2.Tables.Count, ds1.Tables.Count, "DS283");
2976
2977                         // ReadXmlSchema - Tables 0 Col count
2978                         Assert.AreEqual (ds1.Tables[0].Columns.Count, dt1.Columns.Count, "DS284");
2979
2980                         // ReadXmlSchema - Tables 1 Col count
2981                         Assert.AreEqual (ds1.Tables[1].Columns.Count, dt2.Columns.Count, "DS285");
2982
2983                         //check some colummns types
2984                         // ReadXmlSchema - Tables 0 Col type
2985                         Assert.AreEqual (ds1.Tables[0].Columns[0].GetType (), dt1.Columns[0].GetType (), "DS286");
2986
2987                         // ReadXmlSchema - Tables 1 Col type
2988                         Assert.AreEqual (ds1.Tables[1].Columns[3].GetType (), dt2.Columns[3].GetType (), "DS287");
2989
2990                         //check that no data exists
2991                         // ReadXmlSchema - Table 1 row count
2992                         Assert.AreEqual (0, dt1.Rows.Count, "DS288");
2993
2994                         // ReadXmlSchema - Table 2 row count
2995                         Assert.AreEqual (0, dt2.Rows.Count, "DS289");
2996                 }
2997
2998                 [Test]
2999                 public void ReadXmlSchema_ByXmlReader () {
3000                         DataSet ds1 = new DataSet ();
3001                         ds1.Tables.Add (DataProvider.CreateParentDataTable ());
3002                         ds1.Tables.Add (DataProvider.CreateChildDataTable ());
3003
3004                         StringWriter sw1 = new StringWriter ();
3005                         XmlTextWriter xmlTW1 = new XmlTextWriter (sw1);
3006                         StringWriter sw2 = new StringWriter ();
3007                         XmlTextWriter xmlTW2 = new XmlTextWriter (sw2);
3008
3009                         //write xml file, schema only
3010                         ds1.Tables[0].WriteXmlSchema (xmlTW1);
3011                         xmlTW1.Flush ();
3012                         ds1.Tables[1].WriteXmlSchema (xmlTW2);
3013                         xmlTW2.Flush ();
3014
3015                         StringReader sr1 = new StringReader (sw1.ToString ());
3016                         XmlTextReader xmlTR1 = new XmlTextReader (sr1);
3017                         StringReader sr2 = new StringReader (sw2.ToString ());
3018                         XmlTextReader xmlTR2 = new XmlTextReader (sr2);
3019
3020                         //copy both data and schema
3021                         //DataSet ds2 = new DataSet ();
3022                         DataTable dt1 = new DataTable ();
3023                         DataTable dt2 = new DataTable ();
3024
3025                         //ds2.ReadXmlSchema (xmlTR);
3026                         dt1.ReadXmlSchema (xmlTR1);
3027                         dt2.ReadXmlSchema (xmlTR2);
3028
3029                         //check xml schema
3030                         // ReadXmlSchema - Tables count
3031                         //Assert.AreEqual (ds2.Tables.Count, ds1.Tables.Count, "DS290");
3032
3033                         // ReadXmlSchema - Tables 0 Col count
3034                         Assert.AreEqual (ds1.Tables[0].Columns.Count, dt1.Columns.Count, "DS291");
3035
3036                         // ReadXmlSchema - Tables 1 Col count
3037                         Assert.AreEqual (ds1.Tables[1].Columns.Count, dt2.Columns.Count, "DS292");
3038
3039                         //check some colummns types
3040                         // ReadXmlSchema - Tables 0 Col type
3041                         Assert.AreEqual (ds1.Tables[0].Columns[0].GetType (), dt1.Columns[0].GetType (), "DS293");
3042
3043                         // ReadXmlSchema - Tables 1 Col type
3044                         Assert.AreEqual (ds1.Tables[1].Columns[3].GetType (), dt2.Columns[3].GetType (), "DS294");
3045
3046                         //check that no data exists
3047                         // ReadXmlSchema - Table 1 row count
3048                         Assert.AreEqual (0, dt1.Rows.Count, "DS295");
3049
3050                         // ReadXmlSchema - Table 2 row count
3051                         Assert.AreEqual (0, dt2.Rows.Count, "DS296");
3052                 }
3053
3054                 [Test]
3055                 public void WriteXmlSchema () {
3056                         DataSet ds = new DataSet ();
3057                         ds.ReadXml ("Test/System.Data/region.xml");
3058                         TextWriter writer = new StringWriter ();
3059                         ds.Tables[0].WriteXmlSchema (writer);
3060
3061
3062                         string TextString = GetNormalizedSchema (writer.ToString ());
3063                         //string TextString = writer.ToString ();
3064
3065                         string substring = TextString.Substring (0, TextString.IndexOf (EOL));
3066                         TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3067                         Assert.AreEqual ("<?xml version=\"1.0\" encoding=\"utf-16\"?>", substring, "test#01");
3068
3069                         substring = TextString.Substring (0, TextString.IndexOf (EOL));
3070                         TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3071                         Assert.AreEqual ("<xs:schema id=\"Root\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">", substring, "test#02");
3072
3073                         substring = TextString.Substring (0, TextString.IndexOf (EOL));
3074                         TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3075                         Assert.AreEqual ("  <xs:element msdata:IsDataSet=\"true\" msdata:MainDataTable=\"Region\" msdata:UseCurrentLocale=\"true\" name=\"Root\">", substring, "test#03");
3076
3077                         substring = TextString.Substring (0, TextString.IndexOf (EOL));
3078                         TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3079                         Assert.AreEqual ("    <xs:complexType>", substring, "test#04");
3080
3081                         substring = TextString.Substring (0, TextString.IndexOf (EOL));
3082                         TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3083                         Assert.AreEqual ("      <xs:choice maxOccurs=\"unbounded\" minOccurs=\"0\">", substring, "test#05");
3084
3085                         substring = TextString.Substring (0, TextString.IndexOf (EOL));
3086                         TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3087                         Assert.AreEqual ("        <xs:element name=\"Region\">", substring, "test#06");
3088
3089                         substring = TextString.Substring (0, TextString.IndexOf (EOL));
3090                         TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3091                         Assert.AreEqual ("          <xs:complexType>", substring, "test#07");
3092
3093                         substring = TextString.Substring (0, TextString.IndexOf (EOL));
3094                         TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3095                         Assert.AreEqual ("            <xs:sequence>", substring, "test#08");
3096
3097                         substring = TextString.Substring (0, TextString.IndexOf (EOL));
3098                         TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3099                         Assert.AreEqual ("              <xs:element minOccurs=\"0\" name=\"RegionID\" type=\"xs:string\" />", substring, "test#09");
3100
3101                         substring = TextString.Substring (0, TextString.IndexOf (EOL));
3102                         TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3103                         Assert.AreEqual ("              <xs:element minOccurs=\"0\" name=\"RegionDescription\" type=\"xs:string\" />", substring, "test#10");
3104
3105                         substring = TextString.Substring (0, TextString.IndexOf (EOL));
3106                         TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3107                         Assert.AreEqual ("            </xs:sequence>", substring, "test#11");
3108
3109                         substring = TextString.Substring (0, TextString.IndexOf (EOL));
3110                         TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3111                         Assert.AreEqual ("          </xs:complexType>", substring, "test#12");
3112
3113                         substring = TextString.Substring (0, TextString.IndexOf (EOL));
3114                         TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3115                         Assert.AreEqual ("        </xs:element>", substring, "test#13");
3116
3117                         substring = TextString.Substring (0, TextString.IndexOf (EOL));
3118                         TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3119                         Assert.AreEqual ("      </xs:choice>", substring, "test#14");
3120
3121                         substring = TextString.Substring (0, TextString.IndexOf (EOL));
3122                         TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3123                         Assert.AreEqual ("    </xs:complexType>", substring, "test#15");
3124
3125                         substring = TextString.Substring (0, TextString.IndexOf (EOL));
3126                         TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3127                         Assert.AreEqual ("  </xs:element>", substring, "test#16");
3128
3129                         Assert.AreEqual ("</xs:schema>", TextString, "test#17");
3130                 }
3131
3132                 [Test]
3133                 public void WriteXmlSchema2 () {
3134                         string xml = @"<myDataSet xmlns='NetFrameWork'><myTable><id>0</id><item>item 0</item></myTable><myTable><id>1</id><item>item 1</item></myTable><myTable><id>2</id><item>item 2</item></myTable><myTable><id>3</id><item>item 3</item></myTable><myTable><id>4</id><item>item 4</item></myTable><myTable><id>5</id><item>item 5</item></myTable><myTable><id>6</id><item>item 6</item></myTable><myTable><id>7</id><item>item 7</item></myTable><myTable><id>8</id><item>item 8</item></myTable><myTable><id>9</id><item>item 9</item></myTable></myDataSet>";
3135                         string schema = @"<?xml version='1.0' encoding='utf-16'?>
3136 <xs:schema id='myDataSet' targetNamespace='NetFrameWork' xmlns:mstns='NetFrameWork' xmlns='NetFrameWork' xmlns:xs='http://www.w3.org/2001/XMLSchema' xmlns:msdata='urn:schemas-microsoft-com:xml-msdata' attributeFormDefault='qualified' elementFormDefault='qualified'>
3137   <xs:element name='myDataSet' msdata:IsDataSet='true' msdata:MainDataTable='NetFrameWork_x003A_myTable' msdata:UseCurrentLocale='true'>
3138     <xs:complexType>
3139       <xs:choice minOccurs='0' maxOccurs='unbounded'>
3140         <xs:element name='myTable'>
3141           <xs:complexType>
3142             <xs:sequence>
3143               <xs:element name='id' msdata:AutoIncrement='true' type='xs:int' minOccurs='0' />
3144               <xs:element name='item' type='xs:string' minOccurs='0' />
3145             </xs:sequence>
3146           </xs:complexType>
3147         </xs:element>
3148       </xs:choice>
3149     </xs:complexType>
3150   </xs:element>
3151 </xs:schema>";
3152                         DataSet OriginalDataSet = new DataSet ("myDataSet");
3153                         OriginalDataSet.Namespace = "NetFrameWork";
3154                         DataTable myTable = new DataTable ("myTable");
3155                         DataColumn c1 = new DataColumn ("id", typeof (int));
3156                         c1.AutoIncrement = true;
3157                         DataColumn c2 = new DataColumn ("item");
3158                         myTable.Columns.Add (c1);
3159                         myTable.Columns.Add (c2);
3160                         OriginalDataSet.Tables.Add (myTable);
3161                         // Add ten rows.
3162                         DataRow newRow;
3163                         for (int i = 0; i < 10; i++) {
3164                                 newRow = myTable.NewRow ();
3165                                 newRow["item"] = "item " + i;
3166                                 myTable.Rows.Add (newRow);
3167                         }
3168                         OriginalDataSet.AcceptChanges ();
3169
3170                         StringWriter sw = new StringWriter ();
3171                         XmlTextWriter xtw = new XmlTextWriter (sw);
3172                         xtw.QuoteChar = '\'';
3173                         OriginalDataSet.WriteXml (xtw);
3174                         string result = sw.ToString ();
3175
3176                         Assert.AreEqual (xml, result);
3177
3178                         sw = new StringWriter ();
3179                         xtw = new XmlTextWriter (sw);
3180                         xtw.Formatting = Formatting.Indented;
3181                         OriginalDataSet.Tables[0].WriteXmlSchema (xtw);
3182                         result = sw.ToString ();
3183
3184                         result = result.Replace ("\r\n", "\n").Replace ('"', '\'');
3185                         Assert.AreEqual (schema.Replace ("\r\n", "\n"), result);
3186                 }
3187
3188                 [Test]
3189                 public void WriteXmlSchema3 () {
3190                         string xmlschema = @"<?xml version=""1.0"" encoding=""utf-16""?>
3191 <xs:schema id=""ExampleDataSet"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">
3192   <xs:element name=""ExampleDataSet"" msdata:IsDataSet=""true"" msdata:MainDataTable=""ExampleDataTable"" msdata:UseCurrentLocale=""true"">
3193     <xs:complexType>
3194       <xs:choice minOccurs=""0"" maxOccurs=""unbounded"">
3195         <xs:element name=""ExampleDataTable"">
3196           <xs:complexType>
3197             <xs:attribute name=""PrimaryKeyColumn"" type=""xs:int"" use=""required"" />
3198           </xs:complexType>
3199         </xs:element>
3200       </xs:choice>
3201     </xs:complexType>
3202     <xs:unique name=""PK_ExampleDataTable"" msdata:PrimaryKey=""true"">
3203       <xs:selector xpath="".//ExampleDataTable"" />
3204       <xs:field xpath=""@PrimaryKeyColumn"" />
3205     </xs:unique>
3206   </xs:element>
3207 </xs:schema>";
3208                         DataSet ds = new DataSet ("ExampleDataSet");
3209
3210                         ds.Tables.Add (new DataTable ("ExampleDataTable"));
3211                         ds.Tables["ExampleDataTable"].Columns.Add (
3212                                 new DataColumn ("PrimaryKeyColumn", typeof (int), "", MappingType.Attribute));
3213                         ds.Tables["ExampleDataTable"].Columns["PrimaryKeyColumn"].AllowDBNull = false;
3214
3215                         ds.Tables["ExampleDataTable"].Constraints.Add (
3216                                 "PK_ExampleDataTable",
3217                                 ds.Tables["ExampleDataTable"].Columns["PrimaryKeyColumn"],
3218                                 true);
3219
3220                         ds.AcceptChanges ();
3221                         StringWriter sw = new StringWriter ();
3222                         ds.Tables[0].WriteXmlSchema (sw);
3223
3224                         string result = sw.ToString ();
3225
3226                         Assert.AreEqual (xmlschema.Replace ("\r\n", "\n"), result.Replace ("\r\n", "\n"));
3227                         //Assert.AreEqual (xmlschema, result.Replace ("\r\n", "\n"));
3228                 }
3229
3230                 [Test]
3231                 public void WriteXmlSchema4 () {
3232                         string xmlschema = @"<?xml version=""1.0"" encoding=""utf-16""?>
3233 <xs:schema id=""Example"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">
3234   <xs:element name=""Example"" msdata:IsDataSet=""true"" msdata:MainDataTable=""MyType"" msdata:UseCurrentLocale=""true"">
3235     <xs:complexType>
3236       <xs:choice minOccurs=""0"" maxOccurs=""unbounded"">
3237         <xs:element name=""MyType"">
3238           <xs:complexType>
3239             <xs:attribute name=""ID"" type=""xs:int"" use=""required"" />
3240             <xs:attribute name=""Desc"" type=""xs:string"" />
3241           </xs:complexType>
3242         </xs:element>
3243       </xs:choice>
3244     </xs:complexType>
3245   </xs:element>
3246 </xs:schema>";
3247                         DataSet ds = new DataSet ("Example");
3248
3249                         // Add MyType DataTable
3250                         DataTable dt = new DataTable ("MyType");
3251                         ds.Tables.Add (dt);
3252
3253                         dt.Columns.Add (new DataColumn ("ID", typeof (int), "",
3254                                 MappingType.Attribute));
3255                         dt.Columns["ID"].AllowDBNull = false;
3256
3257                         dt.Columns.Add (new DataColumn ("Desc", typeof
3258                                 (string), "", MappingType.Attribute));
3259
3260                         ds.AcceptChanges ();
3261
3262                         StringWriter sw = new StringWriter ();
3263                         ds.Tables[0].WriteXmlSchema (sw);
3264
3265                         string result = sw.ToString ();
3266
3267                         Assert.AreEqual (xmlschema.Replace ("\r\n", "\n"), result.Replace ("\r\n", "\n"));
3268                 }
3269
3270                 [Test]
3271                 public void WriteXmlSchema5 () {
3272                         string xmlschema1 = @"<?xml version=""1.0"" encoding=""utf-16""?>
3273 <xs:schema id=""Example"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">
3274   <xs:element name=""Example"" msdata:IsDataSet=""true"" msdata:MainDataTable=""StandAlone"" msdata:UseCurrentLocale=""true"">
3275     <xs:complexType>
3276       <xs:choice minOccurs=""0"" maxOccurs=""unbounded"">
3277         <xs:element name=""StandAlone"">
3278           <xs:complexType>
3279             <xs:attribute name=""ID"" type=""xs:int"" use=""required"" />
3280             <xs:attribute name=""Desc"" type=""xs:string"" use=""required"" />
3281           </xs:complexType>
3282         </xs:element>
3283       </xs:choice>
3284     </xs:complexType>
3285   </xs:element>
3286 </xs:schema>";
3287                         string xmlschema2 = @"<?xml version=""1.0"" encoding=""utf-16""?>
3288 <xs:schema id=""Example"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">
3289   <xs:element name=""Example"" msdata:IsDataSet=""true"" msdata:MainDataTable=""Dimension"" msdata:UseCurrentLocale=""true"">
3290     <xs:complexType>
3291       <xs:choice minOccurs=""0"" maxOccurs=""unbounded"">
3292         <xs:element name=""Dimension"">
3293           <xs:complexType>
3294             <xs:attribute name=""Number"" msdata:ReadOnly=""true"" type=""xs:int"" use=""required"" />
3295             <xs:attribute name=""Title"" type=""xs:string"" use=""required"" />
3296           </xs:complexType>
3297         </xs:element>
3298       </xs:choice>
3299     </xs:complexType>
3300     <xs:unique name=""PK_Dimension"" msdata:PrimaryKey=""true"">
3301       <xs:selector xpath="".//Dimension"" />
3302       <xs:field xpath=""@Number"" />
3303     </xs:unique>
3304   </xs:element>
3305 </xs:schema>";
3306                         string xmlschema3 = @"<?xml version=""1.0"" encoding=""utf-16""?>
3307 <xs:schema id=""Example"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">
3308   <xs:element name=""Example"" msdata:IsDataSet=""true"" msdata:MainDataTable=""Element"" msdata:UseCurrentLocale=""true"">
3309     <xs:complexType>
3310       <xs:choice minOccurs=""0"" maxOccurs=""unbounded"">
3311         <xs:element name=""Element"">
3312           <xs:complexType>
3313             <xs:attribute name=""Dimension"" msdata:ReadOnly=""true"" type=""xs:int"" use=""required"" />
3314             <xs:attribute name=""Number"" msdata:ReadOnly=""true"" type=""xs:int"" use=""required"" />
3315             <xs:attribute name=""Title"" type=""xs:string"" use=""required"" />
3316           </xs:complexType>
3317         </xs:element>
3318       </xs:choice>
3319     </xs:complexType>
3320     <xs:unique name=""PK_Element"" msdata:PrimaryKey=""true"">
3321       <xs:selector xpath="".//Element"" />
3322       <xs:field xpath=""@Dimension"" />
3323       <xs:field xpath=""@Number"" />
3324     </xs:unique>
3325   </xs:element>
3326 </xs:schema>";
3327                         DataSet ds = new DataSet ("Example");
3328
3329                         // Add a DataTable with no ReadOnly columns
3330                         DataTable dt1 = new DataTable ("StandAlone");
3331                         ds.Tables.Add (dt1);
3332
3333                         // Add a ReadOnly column
3334                         dt1.Columns.Add (new DataColumn ("ID", typeof (int), "",
3335                                 MappingType.Attribute));
3336                         dt1.Columns["ID"].AllowDBNull = false;
3337
3338                         dt1.Columns.Add (new DataColumn ("Desc", typeof
3339                                 (string), "", MappingType.Attribute));
3340                         dt1.Columns["Desc"].AllowDBNull = false;
3341
3342                         // Add related DataTables with ReadOnly columns
3343                         DataTable dt2 = new DataTable ("Dimension");
3344                         ds.Tables.Add (dt2);
3345                         dt2.Columns.Add (new DataColumn ("Number", typeof
3346                                 (int), "", MappingType.Attribute));
3347                         dt2.Columns["Number"].AllowDBNull = false;
3348                         dt2.Columns["Number"].ReadOnly = true;
3349
3350                         dt2.Columns.Add (new DataColumn ("Title", typeof
3351                                 (string), "", MappingType.Attribute));
3352                         dt2.Columns["Title"].AllowDBNull = false;
3353
3354                         dt2.Constraints.Add ("PK_Dimension", dt2.Columns["Number"], true);
3355
3356                         DataTable dt3 = new DataTable ("Element");
3357                         ds.Tables.Add (dt3);
3358
3359                         dt3.Columns.Add (new DataColumn ("Dimension", typeof
3360                                 (int), "", MappingType.Attribute));
3361                         dt3.Columns["Dimension"].AllowDBNull = false;
3362                         dt3.Columns["Dimension"].ReadOnly = true;
3363
3364                         dt3.Columns.Add (new DataColumn ("Number", typeof
3365                                 (int), "", MappingType.Attribute));
3366                         dt3.Columns["Number"].AllowDBNull = false;
3367                         dt3.Columns["Number"].ReadOnly = true;
3368
3369                         dt3.Columns.Add (new DataColumn ("Title", typeof
3370                                 (string), "", MappingType.Attribute));
3371                         dt3.Columns["Title"].AllowDBNull = false;
3372
3373                         dt3.Constraints.Add ("PK_Element", new DataColumn[] {
3374                                 dt3.Columns ["Dimension"],
3375                                 dt3.Columns ["Number"] }, true);
3376
3377                         ds.AcceptChanges ();
3378
3379                         StringWriter sw1 = new StringWriter ();
3380                         ds.Tables[0].WriteXmlSchema (sw1);
3381                         string result1 = sw1.ToString ();
3382                         Assert.AreEqual (xmlschema1.Replace ("\r\n", "\n"), result1.Replace ("\r\n", "\n"));
3383
3384                         StringWriter sw2 = new StringWriter ();
3385                         ds.Tables[1].WriteXmlSchema (sw2);
3386                         string result2 = sw2.ToString ();
3387                         Assert.AreEqual (xmlschema2.Replace ("\r\n", "\n"), result2.Replace ("\r\n", "\n"));
3388
3389                         StringWriter sw3 = new StringWriter ();
3390                         ds.Tables[2].WriteXmlSchema (sw3);
3391                         string result3 = sw3.ToString ();
3392                         Assert.AreEqual (xmlschema3.Replace ("\r\n", "\n"), result3.Replace ("\r\n", "\n"));
3393                 }
3394
3395                 [Test]
3396                 public void WriteXmlSchema6 () {
3397                         string xmlschema = @"<?xml version=""1.0"" encoding=""utf-16""?>
3398 <xs:schema id=""Example"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">
3399   <xs:element name=""Example"" msdata:IsDataSet=""true"" msdata:MainDataTable=""MyType"" msdata:UseCurrentLocale=""true"">
3400     <xs:complexType>
3401       <xs:choice minOccurs=""0"" maxOccurs=""unbounded"">
3402         <xs:element name=""MyType"">
3403           <xs:complexType>
3404             <xs:attribute name=""Desc"">
3405               <xs:simpleType>
3406                 <xs:restriction base=""xs:string"">
3407                   <xs:maxLength value=""32"" />
3408                 </xs:restriction>
3409               </xs:simpleType>
3410             </xs:attribute>
3411           </xs:complexType>
3412         </xs:element>
3413       </xs:choice>
3414     </xs:complexType>
3415   </xs:element>
3416 </xs:schema>";
3417                         DataSet ds = new DataSet ("Example");
3418
3419                         // Add MyType DataTable
3420                         ds.Tables.Add ("MyType");
3421
3422                         ds.Tables["MyType"].Columns.Add (new DataColumn (
3423                                 "Desc", typeof (string), "", MappingType.Attribute));
3424                         ds.Tables["MyType"].Columns["Desc"].MaxLength = 32;
3425
3426                         ds.AcceptChanges ();
3427
3428                         StringWriter sw = new StringWriter ();
3429                         ds.Tables[0].WriteXmlSchema (sw);
3430
3431                         string result = sw.ToString ();
3432
3433                         Assert.AreEqual (xmlschema.Replace ("\r\n", "\n"), result.Replace ("\r\n", "\n"));
3434                 }
3435
3436                 [Test]
3437                 public void WriteXmlSchema7 () {
3438                         DataSet ds = new DataSet ();
3439                         DataTable dt = new DataTable ("table");
3440                         dt.Columns.Add ("col1");
3441                         dt.Columns.Add ("col2");
3442                         ds.Tables.Add (dt);
3443                         dt.Rows.Add (new object[] { "foo", "bar" });
3444                         StringWriter sw = new StringWriter ();
3445                         ds.Tables[0].WriteXmlSchema (sw);
3446                         Assert.IsTrue (sw.ToString ().IndexOf ("xmlns=\"\"") > 0);
3447                 }
3448
3449                 [Test]
3450                 public void WriteXmlSchema_ConstraintNameWithSpaces () {
3451                         DataSet ds = new DataSet ();
3452                         DataTable table1 = ds.Tables.Add ("table1");
3453                         DataTable table2 = ds.Tables.Add ("table2");
3454
3455                         table1.Columns.Add ("col1", typeof (int));
3456                         table2.Columns.Add ("col1", typeof (int));
3457
3458                         table1.Constraints.Add ("uc 1", table1.Columns[0], false);
3459                         table2.Constraints.Add ("fc 1", table1.Columns[0], table2.Columns[0]);
3460
3461                         StringWriter sw1 = new StringWriter ();
3462                         StringWriter sw2 = new StringWriter ();
3463
3464                         //should not throw an exception
3465                         ds.Tables[0].WriteXmlSchema (sw1);
3466                         ds.Tables[1].WriteXmlSchema (sw2);
3467                 }
3468
3469                 [Test]
3470                 public void WriteXmlSchema_ForignKeyConstraint () {
3471                         DataSet ds1 = new DataSet ();
3472
3473                         DataTable table1 = ds1.Tables.Add ();
3474                         DataTable table2 = ds1.Tables.Add ();
3475
3476                         DataColumn col1_1 = table1.Columns.Add ("col1", typeof (int));
3477                         DataColumn col2_1 = table2.Columns.Add ("col1", typeof (int));
3478
3479                         table2.Constraints.Add ("fk", col1_1, col2_1);
3480
3481                         StringWriter sw1 = new StringWriter ();
3482                         ds1.Tables[0].WriteXmlSchema (sw1);
3483                         String xml1 = sw1.ToString ();
3484                         Assert.IsTrue (xml1.IndexOf (@"<xs:unique name=""Constraint1"">") != -1, "#1");
3485
3486                         StringWriter sw2 = new StringWriter ();
3487                         ds1.Tables[1].WriteXmlSchema (sw2);
3488                         String xml2 = sw2.ToString ();
3489                         Assert.IsTrue (xml2.IndexOf (@"<xs:unique name=""Constraint1"">") == -1, "#2");
3490                 }
3491
3492                 [Test]
3493                 public void WriteXmlSchema_Relations_ForeignKeys () {
3494                         MemoryStream ms1 = null;
3495                         MemoryStream ms2 = null;
3496                         MemoryStream msA = null;
3497                         MemoryStream msB = null;
3498
3499                         DataSet ds1 = new DataSet ();
3500
3501                         DataTable table1 = ds1.Tables.Add ("Table 1");
3502                         DataTable table2 = ds1.Tables.Add ("Table 2");
3503
3504                         DataColumn col1_1 = table1.Columns.Add ("col 1", typeof (int));
3505                         DataColumn col1_2 = table1.Columns.Add ("col 2", typeof (int));
3506                         DataColumn col1_3 = table1.Columns.Add ("col 3", typeof (int));
3507                         DataColumn col1_4 = table1.Columns.Add ("col 4", typeof (int));
3508                         DataColumn col1_5 = table1.Columns.Add ("col 5", typeof (int));
3509                         DataColumn col1_6 = table1.Columns.Add ("col 6", typeof (int));
3510                         DataColumn col1_7 = table1.Columns.Add ("col 7", typeof (int));
3511
3512                         DataColumn col2_1 = table2.Columns.Add ("col 1", typeof (int));
3513                         DataColumn col2_2 = table2.Columns.Add ("col 2", typeof (int));
3514                         DataColumn col2_3 = table2.Columns.Add ("col 3", typeof (int));
3515                         DataColumn col2_4 = table2.Columns.Add ("col 4", typeof (int));
3516                         DataColumn col2_5 = table2.Columns.Add ("col 5", typeof (int));
3517                         DataColumn col2_6 = table2.Columns.Add ("col 6", typeof (int));
3518                         DataColumn col2_7 = table2.Columns.Add ("col 7", typeof (int));
3519
3520                         ds1.Relations.Add ("rel 1",
3521                                 new DataColumn[] { col1_1, col1_2 },
3522                                 new DataColumn[] { col2_1, col2_2 },
3523                                 false);
3524                         ds1.Relations.Add ("rel 2",
3525                                 new DataColumn[] { col1_3, col1_4 },
3526                                 new DataColumn[] { col2_3, col2_4 },
3527                                 true);
3528                         table2.Constraints.Add ("fk 1",
3529                                 new DataColumn[] { col1_5, col1_6 },
3530                                 new DataColumn[] { col2_5, col2_6 });
3531                         table1.Constraints.Add ("fk 2",
3532                                 new DataColumn[] { col2_5, col2_6 },
3533                                 new DataColumn[] { col1_5, col1_6 });
3534
3535                         table1.Constraints.Add ("pk 1", col1_7, true);
3536                         table2.Constraints.Add ("pk 2", col2_7, true);
3537
3538                         ms1 = new MemoryStream ();
3539                         ds1.Tables[0].WriteXmlSchema (ms1);
3540                         ms2 = new MemoryStream ();
3541                         ds1.Tables[1].WriteXmlSchema (ms2);
3542
3543                         msA = new MemoryStream (ms1.GetBuffer ());
3544                         DataTable dtA = new DataTable ();
3545                         dtA.ReadXmlSchema (msA);
3546
3547                         msB = new MemoryStream (ms2.GetBuffer ());
3548                         DataTable dtB = new DataTable ();
3549                         dtB.ReadXmlSchema (msB);
3550
3551                         Assert.AreEqual (3, dtA.Constraints.Count, "#2");
3552                         Assert.AreEqual (2, dtB.Constraints.Count, "#3");
3553
3554                         Assert.IsTrue (dtA.Constraints.Contains ("pk 1"), "#5");
3555                         Assert.IsTrue (dtA.Constraints.Contains ("Constraint1"), "#6");
3556                         Assert.IsTrue (dtA.Constraints.Contains ("Constraint2"), "#7");
3557                         Assert.IsTrue (dtB.Constraints.Contains ("pk 2"), "#9");
3558                         Assert.IsTrue (dtB.Constraints.Contains ("Constraint1"), "#10");
3559                 }
3560
3561                 [Test]
3562                 [Category ("NotWorking")]
3563                 public void WriteXmlSchema_DifferentNamespace () {
3564                         string schema = @"<?xml version='1.0' encoding='utf-16'?>\n<xs:schema id='NewDataSet' targetNamespace='urn:bar' xmlns:mstns='urn:bar' xmlns='urn:bar' xmlns:xs='http://www.w3.org/2001/XMLSchema' xmlns:msdata='urn:schemas-microsoft-com:xml-msdata' attributeFormDefault='qualified' elementFormDefault='qualified' xmlns:app1='urn:baz' xmlns:app2='urn:foo' msdata:schemafragmentcount='3'>
3565   <xs:import namespace='urn:foo' />
3566   <xs:import namespace='urn:baz' />
3567   <xs:element name='NewDataSet' msdata:IsDataSet='true' msdata:MainDataTable='urn_x003A_foo_x003A_NS1Table' msdata:UseCurrentLocale='true'>
3568     <xs:complexType>
3569       <xs:choice minOccurs='0' maxOccurs='unbounded'>
3570         <xs:element ref='app2:NS1Table' />
3571       </xs:choice>
3572     </xs:complexType>
3573   </xs:element>
3574 </xs:schema>
3575 <xs:schema targetNamespace='urn:baz' xmlns:mstns='urn:bar' xmlns='urn:baz' xmlns:xs='http://www.w3.org/2001/XMLSchema' xmlns:msdata='urn:schemas-microsoft-com:xml-msdata' attributeFormDefault='qualified' elementFormDefault='qualified' xmlns:app1='urn:baz' xmlns:app2='urn:foo'>
3576   <xs:import namespace='urn:foo' />
3577   <xs:import namespace='urn:bar' />
3578   <xs:element name='column2' type='xs:string' />
3579 </xs:schema>
3580 <xs:schema targetNamespace='urn:foo' xmlns:mstns='urn:bar' xmlns='urn:foo' xmlns:xs='http://www.w3.org/2001/XMLSchema' xmlns:msdata='urn:schemas-microsoft-com:xml-msdata' attributeFormDefault='qualified' elementFormDefault='qualified' xmlns:app2='urn:foo' xmlns:app1='urn:baz'>
3581   <xs:import namespace='urn:bar' />
3582   <xs:import namespace='urn:baz' />
3583   <xs:element name='NS1Table'>
3584     <xs:complexType>
3585       <xs:sequence>
3586         <xs:element name='column1' type='xs:string' minOccurs='0' />
3587         <xs:element ref='app1:column2' minOccurs='0' />
3588       </xs:sequence>
3589     </xs:complexType>
3590   </xs:element>
3591 </xs:schema>";
3592                         DataSet ds = new DataSet ();
3593                         DataTable dt = new DataTable ();
3594                         dt.TableName = "NS1Table";
3595                         dt.Namespace = "urn:foo";
3596                         dt.Columns.Add ("column1");
3597                         dt.Columns.Add ("column2");
3598                         dt.Columns[1].Namespace = "urn:baz";
3599                         ds.Tables.Add (dt);
3600                         DataTable dt2 = new DataTable ();
3601                         dt2.TableName = "NS2Table";
3602                         dt2.Namespace = "urn:bar";
3603                         ds.Tables.Add (dt2);
3604                         ds.Namespace = "urn:bar";
3605
3606                         StringWriter sw1 = new StringWriter ();
3607                         XmlTextWriter xw1 = new XmlTextWriter (sw1);
3608                         xw1.Formatting = Formatting.Indented;
3609                         xw1.QuoteChar = '\'';
3610                         ds.Tables[0].WriteXmlSchema (xw1);
3611                         string result1 = sw1.ToString ();
3612                         Assert.AreEqual (schema, result1, "#1");
3613
3614                         StringWriter sw2 = new StringWriter ();
3615                         XmlTextWriter xw2 = new XmlTextWriter (sw2);
3616                         xw2.Formatting = Formatting.Indented;
3617                         xw2.QuoteChar = '\'';
3618                         ds.Tables[0].WriteXmlSchema (xw2);
3619                         string result2 = sw2.ToString ();
3620                         Assert.AreEqual (schema, result2, "#2");
3621                 }
3622
3623                 [Test]
3624                 public void WriteXmlSchema_Hierarchy () {
3625                         DataSet ds = new DataSet ();
3626                         DataTable table1 = new DataTable ();
3627                         DataColumn idColumn = table1.Columns.Add ("ID", typeof (Int32));
3628                         table1.Columns.Add ("Name", typeof (String));
3629                         table1.PrimaryKey = new DataColumn[] { idColumn };
3630                         DataTable table2 = new DataTable ();
3631                         table2.Columns.Add (new DataColumn ("OrderID", typeof (Int32)));
3632                         table2.Columns.Add (new DataColumn ("CustomerID", typeof (Int32)));
3633                         table2.Columns.Add (new DataColumn ("OrderDate", typeof (DateTime)));
3634                         table2.PrimaryKey = new DataColumn[] { table2.Columns[0] };
3635                         ds.Tables.Add (table1);
3636                         ds.Tables.Add (table2);
3637                         ds.Relations.Add ("CustomerOrder",
3638                             new DataColumn[] { table1.Columns[0] },
3639                             new DataColumn[] { table2.Columns[1] }, true);
3640
3641                         StringWriter writer1 = new StringWriter ();
3642                         table1.WriteXmlSchema (writer1, false);
3643                         string expected1 = "<?xml version=\"1.0\" encoding=\"utf-16\"?>\n<xs:schema id=\"NewDataSet\" xmlns=\"\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\">\n  <xs:element name=\"NewDataSet\" msdata:IsDataSet=\"true\" msdata:MainDataTable=\"Table1\" msdata:UseCurrentLocale=\"true\">\n    <xs:complexType>\n      <xs:choice minOccurs=\"0\" maxOccurs=\"unbounded\">\n        <xs:element name=\"Table1\">\n          <xs:complexType>\n            <xs:sequence>\n              <xs:element name=\"ID\" type=\"xs:int\" />\n              <xs:element name=\"Name\" type=\"xs:string\" minOccurs=\"0\" />\n            </xs:sequence>\n          </xs:complexType>\n        </xs:element>\n      </xs:choice>\n    </xs:complexType>\n    <xs:unique name=\"Constraint1\" msdata:PrimaryKey=\"true\">\n      <xs:selector xpath=\".//Table1\" />\n      <xs:field xpath=\"ID\" />\n    </xs:unique>\n  </xs:element>\n</xs:schema>";
3644                         Assert.AreEqual (expected1, writer1.ToString(), "#1");
3645
3646                         StringWriter writer2 = new StringWriter ();
3647                         table1.WriteXmlSchema (writer2, true);
3648                         string expected2 = "<?xml version=\"1.0\" encoding=\"utf-16\"?>\n<xs:schema id=\"NewDataSet\" xmlns=\"\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\">\n  <xs:element name=\"NewDataSet\" msdata:IsDataSet=\"true\" msdata:MainDataTable=\"Table1\" msdata:UseCurrentLocale=\"true\">\n    <xs:complexType>\n      <xs:choice minOccurs=\"0\" maxOccurs=\"unbounded\">\n        <xs:element name=\"Table1\">\n          <xs:complexType>\n            <xs:sequence>\n              <xs:element name=\"ID\" type=\"xs:int\" />\n              <xs:element name=\"Name\" type=\"xs:string\" minOccurs=\"0\" />\n            </xs:sequence>\n          </xs:complexType>\n        </xs:element>\n        <xs:element name=\"Table2\">\n          <xs:complexType>\n            <xs:sequence>\n              <xs:element name=\"OrderID\" type=\"xs:int\" />\n              <xs:element name=\"CustomerID\" type=\"xs:int\" minOccurs=\"0\" />\n              <xs:element name=\"OrderDate\" type=\"xs:dateTime\" minOccurs=\"0\" />\n            </xs:sequence>\n          </xs:complexType>\n        </xs:element>\n      </xs:choice>\n    </xs:complexType>\n    <xs:unique name=\"Constraint1\" msdata:PrimaryKey=\"true\">\n      <xs:selector xpath=\".//Table1\" />\n      <xs:field xpath=\"ID\" />\n    </xs:unique>\n    <xs:unique name=\"Table2_Constraint1\" msdata:ConstraintName=\"Constraint1\" msdata:PrimaryKey=\"true\">\n      <xs:selector xpath=\".//Table2\" />\n      <xs:field xpath=\"OrderID\" />\n    </xs:unique>\n    <xs:keyref name=\"CustomerOrder\" refer=\"Constraint1\">\n      <xs:selector xpath=\".//Table2\" />\n      <xs:field xpath=\"CustomerID\" />\n    </xs:keyref>\n  </xs:element>\n</xs:schema>";
3649                         Assert.AreEqual (expected2, writer2.ToString (), "#2");
3650                 }
3651
3652                 [Test]
3653                 //[Category ("NotWorking")]
3654                 // WriteXmlSchema doesn't have overload wityh 2 parameters in System.Data
3655                 // and is commented-out TWICE below
3656                 public void ReadWriteXmlSchema()
3657                 {
3658                         DataSet ds = new DataSet();
3659                         ds.ReadXmlSchema("Test/System.Data/store.xsd");
3660                         // check dataset properties before testing write
3661                         AssertDataSet("ds", ds, "NewDataSet", 3, 2);
3662                         AssertDataTable("tab1", ds.Tables[0], "bookstore", 1, 0, 0, 1, 1, 1);
3663                         AssertDataTable("tab2", ds.Tables[1], "book", 5, 0, 1, 1, 2, 1);
3664                         AssertDataTable("tab3", ds.Tables[2], "author", 3, 0, 1, 0, 1, 0);
3665                         // FIXME: currently order is not compatible. Use name as index
3666                         AssertDataRelation("rel1", ds.Relations["book_author"], "book_author", true, new string[] { "book_Id" }, new string[] { "book_Id" }, true, true);
3667                         AssertDataRelation("rel2", ds.Relations["bookstore_book"], "bookstore_book", true, new string[] { "bookstore_Id" }, new string[] { "bookstore_Id" }, true, true);
3668
3669                         ds.ReadXml("Test/System.Data/region.xml", XmlReadMode.InferSchema);
3670                         ds.Relations.Clear(); // because can not call WriteXmlSchema with nested relations.
3671
3672                         TextWriter writer1 = new StringWriter();
3673                         ds.Tables[0].WriteXmlSchema(writer1);
3674                         //string TextString1 = GetNormalizedSchema(writer1.ToString());
3675                         string TextString1 = writer1.ToString();
3676                         string expected1 = @"<?xml version=""1.0"" encoding=""utf-16""?>" +
3677 @"<xs:schema id=""Root"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">" +
3678   @"<xs:complexType name=""bookstoreType"">" +
3679   @"</xs:complexType>" +
3680   @"<xs:element name=""bookstore"" type=""bookstoreType"" />" +
3681   @"<xs:element name=""Root"" msdata:IsDataSet=""true"" msdata:MainDataTable=""bookstore"" msdata:UseCurrentLocale=""true"">" +
3682     @"<xs:complexType>" +
3683       @"<xs:choice minOccurs=""0"" maxOccurs=""unbounded"">" +
3684     @"<xs:element ref=""bookstore"" />" +
3685       @"</xs:choice>" +
3686     @"</xs:complexType>" +
3687   @"</xs:element>" +
3688 @"</xs:schema>";
3689                         Assert.AreEqual(expected1.Replace("\n", ""), TextString1.Replace("\r\n", "").Replace("  ", "").Replace("\n", ""), "#1");
3690
3691                         TextWriter writer2 = new StringWriter();
3692                         ds.Tables[1].WriteXmlSchema(writer2, false);
3693                         //string TextString2 = GetNormalizedSchema(writer2.ToString());
3694                         string TextString2 = writer2.ToString();
3695                         string expected2 = @"<?xml version=""1.0"" encoding=""utf-16""?>" +
3696 @"<xs:schema id=""Root"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">" +
3697   @"<xs:complexType name=""bookType"">" +
3698     @"<xs:sequence>" +
3699       @"<xs:element name=""title"" type=""xs:string"" msdata:Ordinal=""1"" />" +
3700       @"<xs:element name=""price"" type=""xs:decimal"" msdata:Ordinal=""2"" />" +
3701     @"</xs:sequence>" +
3702     @"<xs:attribute name=""genre"" type=""xs:string"" />" +
3703     @"<xs:attribute name=""bookstore_Id"" type=""xs:int"" use=""prohibited"" />" +
3704   @"</xs:complexType>" +
3705   @"<xs:element name=""book"" type=""bookType"" />" +
3706   @"<xs:element name=""Root"" msdata:IsDataSet=""true"" msdata:MainDataTable=""book"" msdata:UseCurrentLocale=""true"">" +
3707     @"<xs:complexType>" +
3708       @"<xs:choice minOccurs=""0"" maxOccurs=""unbounded"">" +
3709     @"<xs:element ref=""book"" />" +
3710       @"</xs:choice>" +
3711     @"</xs:complexType>" +
3712   @"</xs:element>" +
3713 @"</xs:schema>";
3714                         Assert.AreEqual(expected2, TextString2.Replace("\r\n", "").Replace("  ", ""), "#2");
3715
3716                         TextWriter writer3 = new StringWriter();
3717                         ds.Tables[2].WriteXmlSchema(writer3);
3718                         //string TextString3 = GetNormalizedSchema(writer3.ToString());
3719                         string TextString3 = writer3.ToString();
3720                         string expected3 = @"<?xml version=""1.0"" encoding=""utf-16""?>" +
3721 @"<xs:schema id=""Root"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">" +
3722   @"<xs:complexType name=""authorName"">" +
3723     @"<xs:sequence>" +
3724       @"<xs:element name=""first-name"" type=""xs:string"" msdata:Ordinal=""0"" />" +
3725       @"<xs:element name=""last-name"" type=""xs:string"" msdata:Ordinal=""1"" />" +
3726     @"</xs:sequence>" +
3727     @"<xs:attribute name=""book_Id"" type=""xs:int"" use=""prohibited"" />" +
3728   @"</xs:complexType>" +
3729   @"<xs:element name=""author"" type=""authorName"" />" +
3730   @"<xs:element name=""Root"" msdata:IsDataSet=""true"" msdata:MainDataTable=""author"" msdata:UseCurrentLocale=""true"">" +
3731     @"<xs:complexType>" +
3732       @"<xs:choice minOccurs=""0"" maxOccurs=""unbounded"">" +
3733         @"<xs:element ref=""author"" />" +
3734       @"</xs:choice>" +
3735     @"</xs:complexType>" +
3736   @"</xs:element>" +
3737 @"</xs:schema>";
3738                         Assert.AreEqual(expected3, TextString3.Replace("\r\n", "").Replace("  ", ""), "#3");
3739
3740                         TextWriter writer4 = new StringWriter();
3741                         ds.Tables[3].WriteXmlSchema(writer4);
3742                         //string TextString4 = GetNormalizedSchema(writer4.ToString());
3743                         string TextString4 = writer4.ToString();
3744                         string expected4 = @"<?xml version=""1.0"" encoding=""utf-16""?>" +
3745 @"<xs:schema id=""Root"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">" +
3746   @"<xs:element name=""Root"" msdata:IsDataSet=""true"" msdata:MainDataTable=""Region"" msdata:UseCurrentLocale=""true"">" +
3747     @"<xs:complexType>" +
3748       @"<xs:choice minOccurs=""0"" maxOccurs=""unbounded"">" +
3749         @"<xs:element name=""Region"">" +
3750           @"<xs:complexType>" +
3751             @"<xs:sequence>" +
3752               @"<xs:element name=""RegionID"" type=""xs:string"" minOccurs=""0"" />" +
3753               @"<xs:element name=""RegionDescription"" type=""xs:string"" minOccurs=""0"" />" +
3754             @"</xs:sequence>" +
3755           @"</xs:complexType>" +
3756         @"</xs:element>" +
3757       @"</xs:choice>" +
3758     @"</xs:complexType>" +
3759   @"</xs:element>" +
3760 @"</xs:schema>";
3761                         Assert.AreEqual(expected4, TextString4.Replace("\r\n", "").Replace("  ", ""), "#4");
3762                 }
3763
3764                 [Test]
3765                 //[Category ("NotWorking")]
3766                 public void ReadWriteXmlSchema_IgnoreSchema () {
3767                         DataSet ds = new DataSet ();
3768                         ds.ReadXmlSchema ("Test/System.Data/store.xsd");
3769                         // check dataset properties before testing write
3770                         AssertDataSet ("ds", ds, "NewDataSet", 3, 2);
3771                         AssertDataTable ("tab1", ds.Tables[0], "bookstore", 1, 0, 0, 1, 1, 1);
3772                         AssertDataTable ("tab2", ds.Tables[1], "book", 5, 0, 1, 1, 2, 1);
3773                         AssertDataTable ("tab3", ds.Tables[2], "author", 3, 0, 1, 0, 1, 0);
3774                         // FIXME: currently order is not compatible. Use name as index
3775                         AssertDataRelation ("rel1", ds.Relations["book_author"], "book_author", true, new string[] { "book_Id" }, new string[] { "book_Id" }, true, true);
3776                         AssertDataRelation ("rel2", ds.Relations["bookstore_book"], "bookstore_book", true, new string[] { "bookstore_Id" }, new string[] { "bookstore_Id" }, true, true);
3777
3778                         ds.ReadXml ("Test/System.Data/region.xml", XmlReadMode.IgnoreSchema);
3779                         ds.Relations.Clear (); // because can not call WriteXmlSchema with nested relations.
3780
3781                         TextWriter writer1 = new StringWriter ();
3782                         ds.Tables[0].WriteXmlSchema (writer1);
3783                         //string TextString1 = GetNormalizedSchema (writer1.ToString ());
3784                         string TextString1 = writer1.ToString ();
3785                         string expected1 = @"<?xml version=""1.0"" encoding=""utf-16""?>" +
3786 @"<xs:schema id=""NewDataSet"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">" +
3787   @"<xs:complexType name=""bookstoreType"">" +
3788   @"</xs:complexType>" +
3789   @"<xs:element name=""bookstore"" type=""bookstoreType"" />" +
3790   @"<xs:element name=""NewDataSet"" msdata:IsDataSet=""true"" msdata:MainDataTable=""bookstore"" msdata:UseCurrentLocale=""true"">" +
3791     @"<xs:complexType>" +
3792       @"<xs:choice minOccurs=""0"" maxOccurs=""unbounded"">" +
3793         @"<xs:element ref=""bookstore"" />" +
3794       @"</xs:choice>" +
3795     @"</xs:complexType>" +
3796   @"</xs:element>" +
3797 @"</xs:schema>";
3798                         Console.WriteLine ("{0} - {1}", TextString1, expected1);
3799                         Assert.AreEqual (expected1, TextString1.Replace ("\r\n", "").Replace ("  ", "").Replace ("\n", ""), "#1");
3800
3801                         TextWriter writer2 = new StringWriter ();
3802                         ds.Tables[1].WriteXmlSchema (writer2, false);
3803                         string TextString2 = GetNormalizedSchema (writer2.ToString ());
3804                         string expected2 = @"<?xml version=""1.0"" encoding=""utf-16""?>" +
3805 @"<xs:schema id=""NewDataSet"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">" +
3806   @"<xs:complexType name=""bookType"">" +
3807     @"<xs:sequence>" +
3808       @"<xs:element name=""title"" type=""xs:string"" msdata:Ordinal=""1"" />" +
3809       @"<xs:element name=""price"" type=""xs:decimal"" msdata:Ordinal=""2"" />" +
3810     @"</xs:sequence>" +
3811     @"<xs:attribute name=""genre"" type=""xs:string"" />" +
3812     @"<xs:attribute name=""bookstore_Id"" type=""xs:int"" use=""prohibited"" />" +
3813   @"</xs:complexType>" +
3814   @"<xs:element name=""book"" type=""bookType"" />" +
3815   @"<xs:element name=""NewDataSet"" msdata:IsDataSet=""true"" msdata:MainDataTable=""book"" msdata:UseCurrentLocale=""true"">" +
3816     @"<xs:complexType>" +
3817       @"<xs:choice minOccurs=""0"" maxOccurs=""unbounded"">" +
3818         @"<xs:element ref=""book"" />" +
3819       @"</xs:choice>" +
3820     @"</xs:complexType>" +
3821   @"</xs:element>" +
3822 @"</xs:schema>";
3823                         Assert.AreEqual (expected2, TextString2.Replace ("\r\n", "").Replace ("  ", ""), "#2");
3824
3825                         TextWriter writer3 = new StringWriter ();
3826                         ds.Tables[2].WriteXmlSchema (writer3);
3827                         string TextString3 = GetNormalizedSchema (writer3.ToString ());
3828                         string expected3 = @"<?xml version=""1.0"" encoding=""utf-16""?>" +
3829 @"<xs:schema id=""NewDataSet"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">" +
3830   @"<xs:complexType name=""authorName"">" +
3831     @"<xs:sequence>" +
3832       @"<xs:element name=""first-name"" type=""xs:string"" msdata:Ordinal=""0"" />" +
3833       @"<xs:element name=""last-name"" type=""xs:string"" msdata:Ordinal=""1"" />" +
3834     @"</xs:sequence>" +
3835     @"<xs:attribute name=""book_Id"" type=""xs:int"" use=""prohibited"" />" +
3836   @"</xs:complexType>" +
3837   @"<xs:element name=""author"" type=""authorName"" />" +
3838   @"<xs:element name=""NewDataSet"" msdata:IsDataSet=""true"" msdata:MainDataTable=""author"" msdata:UseCurrentLocale=""true"">" +
3839     @"<xs:complexType>" +
3840       @"<xs:choice minOccurs=""0"" maxOccurs=""unbounded"">" +
3841         @"<xs:element ref=""author"" />" +
3842       @"</xs:choice>" +
3843     @"</xs:complexType>" +
3844   @"</xs:element>" +
3845 @"</xs:schema>";
3846                         Assert.AreEqual (expected3, TextString3.Replace ("\r\n", "").Replace ("  ", ""), "#3");
3847
3848                         TextWriter writer4 = new StringWriter ();
3849                         string expStr = "";
3850                         try {
3851                                 ds.Tables[3].WriteXmlSchema (writer4);
3852                         }
3853                         catch (Exception ex) {
3854                                 expStr = ex.Message;
3855                         }
3856                         Assert.AreEqual ("Cannot find table 3.", expStr, "#4");
3857                 }
3858
3859                 [Test]
3860                 public void ReadWriteXmlSchema_2 () {
3861                         DataSet ds = new DataSet ("dataset");
3862                         ds.Tables.Add ("table1");
3863                         ds.Tables.Add ("table2");
3864                         ds.Tables[0].Columns.Add ("col");
3865                         ds.Tables[1].Columns.Add ("col");
3866                         ds.Relations.Add ("rel", ds.Tables[0].Columns[0], ds.Tables[1].Columns[0], true);
3867
3868                         MemoryStream ms1 = new MemoryStream ();
3869                         ds.Tables[0].WriteXmlSchema (ms1);
3870                         MemoryStream ms2 = new MemoryStream ();
3871                         ds.Tables[1].WriteXmlSchema (ms2);
3872
3873                         DataSet ds1 = new DataSet ();
3874                         ds1.Tables.Add ();
3875                         ds1.Tables.Add ();
3876                         ds1.Tables[0].ReadXmlSchema (new MemoryStream (ms1.GetBuffer ()));
3877                         ds1.Tables[1].ReadXmlSchema (new MemoryStream (ms2.GetBuffer ()));
3878
3879                         Assert.AreEqual (0, ds1.Relations.Count, "#1");
3880                         Assert.AreEqual (1, ds1.Tables[0].Columns.Count, "#2");
3881                         Assert.AreEqual (1, ds1.Tables[1].Columns.Count, "#3");
3882                 }
3883
3884                 [Test]
3885                 [ExpectedException (typeof (XmlException))]
3886                 public void ReadWriteXmlSchemaExp_NoRootElmnt () {
3887                         MemoryStream ms = new MemoryStream ();
3888                         DataTable dtr = new DataTable ();
3889                         dtr.ReadXmlSchema (ms);
3890                 }
3891
3892                 [Test]
3893                 [ExpectedException (typeof (InvalidOperationException))]
3894                 public void ReadWriteXmlSchemaExp_NoTableName () {
3895                         DataTable dtw = new DataTable ();
3896                         MemoryStream ms = new MemoryStream ();
3897                         dtw.WriteXmlSchema (ms);
3898                 }
3899
3900                 [Test]
3901                 [ExpectedException (typeof (ArgumentException))]
3902                 public void ReadWriteXmlSchemaExp_NoFileName () {
3903                         DataTable dtw = new DataTable ();
3904                         dtw.WriteXmlSchema ("");
3905                 }
3906
3907                 [Test]
3908                 [ExpectedException (typeof (ArgumentException))]
3909                 public void ReadWriteXmlSchemaExp_TableNameConflict () {
3910                         DataTable dtw = new DataTable ("Table1");
3911                         StringWriter writer1 = new StringWriter ();
3912                         dtw.WriteXmlSchema (writer1);
3913                         DataTable dtr = new DataTable ("Table2");
3914                         StringReader reader1 = new StringReader (writer1.ToString());
3915                         dtr.ReadXmlSchema (reader1);
3916                 }
3917
3918                 #endregion // Read/Write XML Tests
3919
3920 #endif // NET_2_0
3921
3922         }
3923
3924
3925          public  class MyDataTable:DataTable {
3926
3927              public static int count = 0;
3928
3929              public MyDataTable() {
3930
3931                     count++;
3932              }
3933
3934          }
3935
3936         [Serializable]
3937         [TestFixture]
3938         public class AppDomainsAndFormatInfo
3939         {
3940                 public void Remote ()
3941                 {
3942                         int n = (int) Convert.ChangeType ("5", typeof (int));
3943                         Assert.AreEqual (5, n, "n");
3944                 }
3945 #if !TARGET_JVM
3946                 [Test]
3947                 public void NFIFromBug55978 ()
3948                 {
3949                         AppDomain domain = AppDomain.CreateDomain ("testdomain");
3950                         AppDomainsAndFormatInfo test = new AppDomainsAndFormatInfo ();
3951                         test.Remote ();
3952                         domain.DoCallBack (new CrossAppDomainDelegate (test.Remote));
3953                         AppDomain.Unload (domain);
3954                 }
3955 #endif
3956
3957                 [Test]
3958                 public void Bug55978 ()
3959                 {
3960                         DataTable dt = new DataTable ();
3961                         dt.Columns.Add ("StartDate", typeof (DateTime));
3962
3963                         DataRow dr;
3964                         DateTime date = DateTime.Now;
3965
3966                         for (int i = 0; i < 10; i++) {
3967                                 dr = dt.NewRow ();
3968                                 dr ["StartDate"] = date.AddDays (i);
3969                                 dt.Rows.Add (dr);
3970                         }
3971
3972                         DataView dv = dt.DefaultView;
3973                         dv.RowFilter = "StartDate >= '" + DateTime.Now.AddDays (2) + "' and StartDate <= '" + DateTime.Now.AddDays (4) + "'";
3974                         Assert.AreEqual (10, dt.Rows.Count, "Table");
3975                         Assert.AreEqual (2, dv.Count, "View");
3976                 }
3977         }
3978 }