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                         AssertEquals("CaseSensitive must be false." ,false,dt.CaseSensitive);
  60                         Assert("Col",dt.Columns != null);
  61                         //Assert(dt.ChildRelations != null);
  62                         Assert("Const", dt.Constraints != null);
  63                         Assert("ds", dt.DataSet == null);
  64                         Assert("dv", dt.DefaultView != null);
  65                         Assert("de", dt.DisplayExpression == "");
  66                         Assert("ep", dt.ExtendedProperties != null);
  67                         Assert("he", dt.HasErrors == false);
  68                         Assert("lc", dt.Locale != null);
  69                         Assert("mc", dt.MinimumCapacity == 50); //LAMESPEC:
  70                         Assert("ns", dt.Namespace == "");
  71                         //Assert(dt.ParentRelations != null);
  72                         Assert("pf", dt.Prefix == "");
  73                         Assert("pk", dt.PrimaryKey != null);
  74                         Assert("rows", dt.Rows != null);
  75                         Assert("Site", dt.Site == null);
  76                         Assert("tname", dt.TableName == "");
  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                         AssertEquals ("test#01", 2, Rows.Length);
 170
 171                         // test with apos escaped
 172                         Rows = Mom.Select ("Name = '''Jhon O'''' Collenal'''");
 173                         AssertEquals ("test#01.1", 1, Rows.Length);
 174
 175                         Rows = Mom.Select ("Name = 'Teresa' and ChildName = 'Nick'");
 176                         AssertEquals ("test#02", 0, Rows.Length);
 177
 178                         Rows = Mom.Select ("Name = 'Teresa' and ChildName = 'Jack'");
 179                         AssertEquals ("test#03", 1, Rows.Length);
 180
 181                         Rows = Mom.Select ("Name = 'Teresa' and ChildName <> 'Jack'");
 182                         AssertEquals ("test#04", "Mack", Rows [0] [1]);
 183
 184                         Rows = Mom.Select ("Name = 'Teresa' or ChildName <> 'Jack'");
 185                         AssertEquals ("test#05", 6, Rows.Length);
 186
 187                         Rows = Child.Select ("age = 20 - 1");
 188                         AssertEquals ("test#06", 1, Rows.Length);
 189
 190                         Rows = Child.Select ("age <= 20");
 191                         AssertEquals ("test#07", 3, Rows.Length);
 192
 193                         Rows = Child.Select ("age >= 20");
 194                         AssertEquals ("test#08", 4, Rows.Length);
 195
 196                         Rows = Child.Select ("age >= 20 and name = 'Mack' or name = 'Nick'");
 197                         AssertEquals ("test#09", 2, Rows.Length);
 198
 199                         Rows = Child.Select ("age >= 20 and (name = 'Mack' or name = 'Nick')");
 200                         AssertEquals ("test#10", 1, Rows.Length);
 201                         AssertEquals ("test#11", "Mack", Rows [0] [0]);
 202
 203                         Rows = Child.Select ("not (Name = 'Jack')");
 204                         AssertEquals ("test#12", 6, Rows.Length);
 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                         AssertEquals ("test#01", 3, Rows.Length);
 253                         AssertEquals ("test#02", "Mack", Rows [0] [0]);
 254                         AssertEquals ("test#03", "Mick", Rows [1] [0]);
 255                         AssertEquals ("test#04", "Dick", Rows [2] [0]);
 256
 257                         Rows = Child.Select ("age >= 20", "age asc");
 258                         AssertEquals ("test#05", 3, Rows.Length);
 259                         AssertEquals ("test#06", "Dick", Rows [0] [0]);
 260                         AssertEquals ("test#07", "Mick", Rows [1] [0]);
 261                         AssertEquals ("test#08", "Mack", Rows [2] [0]);
 262
 263                         Rows = Child.Select ("age >= 20", "name asc");
 264                         AssertEquals ("test#09", 3, Rows.Length);
 265                         AssertEquals ("test#10", "Dick", Rows [0] [0]);
 266                         AssertEquals ("test#11", "Mack", Rows [1] [0]);
 267                         AssertEquals ("test#12", "Mick", Rows [2] [0]);
 268
 269                         Rows = Child.Select ("age >= 20", "name desc");
 270                         AssertEquals ("test#09", 3, Rows.Length);
 271                         AssertEquals ("test#10", "Mick", Rows [0] [0]);
 272                         AssertEquals ("test#11", "Mack", Rows [1] [0]);
 273                         AssertEquals ("test#12", "Dick", Rows [2] [0]);
 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                         AssertEquals ("test#01", 12, T.Select ("age<=10").Length);
 308
 309                         AssertEquals ("test#02", 12, T.Select ("age\n\t<\n\t=\t\n10").Length);
 310
 311                         try {
 312                                 T.Select ("name = 1human ");
 313                                 Fail ("test#03");
 314                         } catch (Exception e) {
 315
 316                                 // missing operand after 'human' operand
 317                                 AssertEquals ("test#04", typeof (SyntaxErrorException), e.GetType ());
 318                         }
 319
 320                         try {
 321                                 T.Select ("name = 1");
 322                                 Fail ("test#05");
 323                         } catch (Exception e) {
 324
 325                                 // Cannot perform '=' operation between string and Int32
 326                                 AssertEquals ("test#06", typeof (EvaluateException), e.GetType ());
 327                         }
 328
 329                         AssertEquals ("test#07", 1, T.Select ("age = '13'").Length);
 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                         AssertEquals ("test#01", 1, dt.Select (@"SomeCol='\t'").Length);
 341                         AssertEquals ("test#02", 1, dt.Select (@"SomeCol='\\'").Length);
 342
 343                         try {
 344                                 dt.Select (@"SomeCol='\x'");
 345                                 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                         AssertEquals ("test#01", 11, T.Select ("age < 10").Length);
 380                         AssertEquals ("test#02", 12, T.Select ("age <= 10").Length);
 381                         AssertEquals ("test#03", 12, T.Select ("age< =10").Length);
 382                         AssertEquals ("test#04", 89, T.Select ("age > 10").Length);
 383                         AssertEquals ("test#05", 90, T.Select ("age >= 10").Length);
 384                         AssertEquals ("test#06", 100, T.Select ("age <> 10").Length);
 385                         AssertEquals ("test#07", 3, T.Select ("name < 'human10'").Length);
 386                         AssertEquals ("test#08", 3, T.Select ("id < '10'").Length);
 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                         //AssertEquals ("test#09", 25, T.Select ("id < 10").Length);
 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                                 Fail ("test#01");
 417                         } catch (Exception e) {
 418
 419                                 // column name human not found
 420                                 AssertEquals ("test#02", typeof (EvaluateException), e.GetType ());
 421                         }
 422
 423                         AssertEquals ("test#04", 1, T.Select ("id = '12'").Length);
 424                         AssertEquals ("test#05", 1, T.Select ("id = 12").Length);
 425
 426                         try {
 427                                 T.Select ("id = 1k3");
 428                                 Fail ("test#06");
 429                         } catch (Exception e) {
 430
 431                                 // no operands after k3 operator
 432                                 AssertEquals ("test#07", typeof (SyntaxErrorException), e.GetType ());
 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                         AssertEquals ("test#01", 1, T.Select ("name = 'human' + 1").Length);
 466
 467                         AssertEquals ("test#02", "human1", T.Select ("name = 'human' + 1") [0] ["name"]);
 468                         AssertEquals ("test#03", 1, T.Select ("name = 'human' + '1'").Length);
 469                         AssertEquals ("test#04", "human1", T.Select ("name = 'human' + '1'") [0] ["name"]);
 470                         AssertEquals ("test#05", 1, T.Select ("name = 'human' + 1 + 2").Length);
 471                         AssertEquals ("test#06", "human12", T.Select ("name = 'human' + '1' + '2'") [0] ["name"]);
 472
 473                         AssertEquals ("test#07", 1, T.Select ("name = 'huMAn' + 1").Length);
 474
 475                         Set.CaseSensitive = true;
 476                         AssertEquals ("test#08", 0, T.Select ("name = 'huMAn' + 1").Length);
 477
 478                         T.CaseSensitive = false;
 479                         AssertEquals ("test#09", 1, T.Select ("name = 'huMAn' + 1").Length);
 480
 481                         T.CaseSensitive = true;
 482                         AssertEquals ("test#10", 0, T.Select ("name = 'huMAn' + 1").Length);
 483
 484                         Set.CaseSensitive = false;
 485                         AssertEquals ("test#11", 0, T.Select ("name = 'huMAn' + 1").Length);
 486
 487                         T.CaseSensitive = false;
 488                         AssertEquals ("test#12", 1, T.Select ("name = 'huMAn' + 1").Length);
 489
 490                         AssertEquals ("test#13", 0, T.Select ("name = 'human1*'").Length);
 491                         AssertEquals ("test#14", 11, T.Select ("name like 'human1*'").Length);
 492                         AssertEquals ("test#15", 11, T.Select ("name like 'human1%'").Length);
 493
 494                         try {
 495                                 AssertEquals ("test#16", 11, T.Select ("name like 'h*an1'").Length);
 496                                 Fail ("test#16");
 497                         } catch (Exception e) {
 498
 499                                 // 'h*an1' is invalid
 500                                 AssertEquals ("test#17", typeof (EvaluateException), e.GetType ());
 501                         }
 502
 503                         try {
 504                                 AssertEquals ("test#18", 11, T.Select ("name like 'h%an1'").Length);
 505                                 Fail ("test#19");
 506                         } catch (Exception e) {
 507
 508                                 // 'h%an1' is invalid
 509                                 AssertEquals ("test#20", typeof (EvaluateException), e.GetType ());
 510                         }
 511
 512                         AssertEquals ("test#21", 0, T.Select ("name like 'h[%]an'").Length);
 513                         AssertEquals ("test#22", 1, T.Select ("name like 'h[*]an'").Length);
 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                         AssertEquals ("test#01", 1000, T.Select ("Sum(age) > 10").Length);
 539                         AssertEquals ("test#02", 1000, T.Select ("avg(age) = 499").Length);
 540                         AssertEquals ("test#03", 1000, T.Select ("min(age) = 0").Length);
 541                         AssertEquals ("test#04", 1000, T.Select ("max(age) = 999").Length);
 542                         AssertEquals ("test#05", 1000, T.Select ("count(age) = 1000").Length);
 543                         AssertEquals ("test#06", 1000, T.Select ("stdev(age) > 287 and stdev(age) < 289").Length);
 544                         AssertEquals ("test#07", 1000, T.Select ("var(age) < 83417 and var(age) > 83416").Length);
 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                         AssertEquals ("test#01", 25, T.Select ("age = 5*5") [0]["age"]);
 576                         AssertEquals ("test#02", 901, T.Select ("len(name) > 7").Length);
 577                         AssertEquals ("test#03", 125, T.Select ("age = 5*5*5 AND len(name)>7") [0]["age"]);
 578                         AssertEquals ("test#04", 1, T.Select ("isnull(id, 'test') = 'test'").Length);
 579                         AssertEquals ("test#05", 1000, T.Select ("iif(id = '56', 'test', 'false') = 'false'").Length);
 580                         AssertEquals ("test#06", 1, T.Select ("iif(id = '56', 'test', 'false') = 'test'").Length);
 581                         AssertEquals ("test#07", 9, T.Select ("substring(id, 2, 3) = '23'").Length);
 582                         AssertEquals ("test#08", "123", T.Select ("substring(id, 2, 3) = '23'") [0] ["id"]);
 583                         AssertEquals ("test#09", "423", T.Select ("substring(id, 2, 3) = '23'") [3] ["id"]);
 584                         AssertEquals ("test#10", "923", T.Select ("substring(id, 2, 3) = '23'") [8] ["id"]);
 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                         AssertEquals ("test#01", 6, Rows.Length);
 669                         Rows = Child.Select ("Parent.childname = 'Jack'");
 670                         AssertEquals ("test#02", 1, Rows.Length);
 671
 672                         /*
 673                         try {
 674                                 // FIXME: LAMESPEC: Why the exception is thrown why... why...
 675                                 Mom.Select ("Child.Name = 'Jack'");
 676                                 Fail ("test#03");
 677                         } catch (Exception e) {
 678                                 AssertEquals ("test#04", typeof (SyntaxErrorException), e.GetType ());
 679                                 AssertEquals ("test#05", "Cannot interpret token 'Child' at position 1.", e.Message);
 680                         }
 681                         */
 682
 683                         Rows = Child.Select ("Parent.name = 'Laura'");
 684                         AssertEquals ("test#06", 3, Rows.Length);
 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                                 Fail ("test#07");
 725                         } catch (Exception e) {
 726                                 AssertEquals ("test#08", typeof (EvaluateException), e.GetType ());
 727                                 //AssertEquals ("test#09", "The table [Child] involved in more than one relation. You must explicitly mention a relation name in the expression 'parent.[ChildName]'.", e.Message);
 728                         }
 729
 730                         Rows = Child.Select ("Parent(rel).ChildName = 'Jack'");
 731                         AssertEquals ("test#10", 1, Rows.Length);
 732
 733                         Rows = Child.Select ("Parent(Rel2).ChildName = 'Jack'");
 734                         AssertEquals ("test#10", 1, Rows.Length);
 735
 736                         try {
 737                                 Mom.Select ("Parent.name  = 'John'");
 738                         } catch (Exception e) {
 739                                 AssertEquals ("test#11", typeof (IndexOutOfRangeException), e.GetType ());
 740                                 AssertEquals ("test#12", "Cannot find relation 0.", e.Message);
 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                         AssertEquals(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                         AssertEquals(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                         AssertEquals(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                         AssertEquals ("test#01", 0, dt.PrimaryKey.Length);
 785
 786                         dt.PrimaryKey = new DataColumn [] {dt.Columns [0]};
 787                         AssertEquals ("test#02", 1, dt.PrimaryKey.Length);
 788                         AssertEquals ("test#03", "Column1", dt.PrimaryKey [0].ColumnName);
 789
 790                         dt.PrimaryKey = null;
 791                         AssertEquals ("test#04", 0, dt.PrimaryKey.Length);
 792
 793                         Col = new DataColumn ("failed");
 794
 795                         try {
 796                                 dt.PrimaryKey = new DataColumn [] {Col};
 797                                 Fail ("test#05");
 798                         } catch (Exception e) {
 799                                 AssertEquals ("test#06", typeof (ArgumentException), e.GetType ());
 800                                 AssertEquals ("test#07", "Column must belong to a table.", e.Message);
 801                         }
 802
 803                         DataTable dt2 = new DataTable ();
 804                         dt2.Columns.Add ();
 805
 806                         try {
 807                                 dt.PrimaryKey = new DataColumn [] {dt2.Columns [0]};
 808                                 Fail ("test#08");
 809                         } catch (Exception e) {
 810                                 AssertEquals ("test#09", typeof (ArgumentException), e.GetType ());
 811                                 AssertEquals ("test#10", "PrimaryKey columns do not belong to this table.", e.Message);
 812                         }
 813
 814
 815                         AssertEquals ("test#11", 0, dt.Constraints.Count);
 816
 817                         dt.PrimaryKey = new DataColumn [] {dt.Columns [0], dt.Columns [1]};
 818                         AssertEquals ("test#12", 2, dt.PrimaryKey.Length);
 819                         AssertEquals ("test#13", 1, dt.Constraints.Count);
 820                         AssertEquals ("test#14", true, dt.Constraints [0] is UniqueConstraint);
 821                         AssertEquals ("test#15", "Column1", dt.PrimaryKey [0].ColumnName);
 822                         AssertEquals ("test#16", "Column2", dt.PrimaryKey [1].ColumnName);
 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                                 Fail ("#A01");
 864                         }
 865                         catch (Exception e) {
 866                                 if (e.GetType () != typeof (AssertionException))
 867                                         AssertEquals ("#A02", "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);
 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                                 Fail ("#A03");
 876                         }
 877                         catch (Exception e) {
 878                                  if (e.GetType () != typeof (AssertionException))
 879                                         AssertEquals ("#A04", "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);
 880                                 else
 881                                         Console.WriteLine (e);
 882                         }
 883                         try {
 884                                 table.Prefix = "Prefix#1";
 885                                 Fail ("#A05");
 886                         }
 887                         catch (Exception e){
 888                                 if (e.GetType () != typeof (AssertionException))
 889                                         AssertEquals ("#A06", "Prefix 'Prefix#1' is not valid, because it contains special characters.",e.Message);
 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                         AssertEquals ("#A01", 1, table.GetErrors ().Length);
 918                         AssertEquals ("#A02", "Error#1", (table.GetErrors ())[0].RowError);
 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                         AssertEquals ("#NewRowAdded Event #01", true, _tableNewRowAddedEventFired);
 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                         AssertEquals ("#A01",true ,cloneTable.CaseSensitive);
1025                         AssertEquals ("#A02", 0 , cloneTable.ChildRelations.Count);
1026                         AssertEquals ("#A03", 0 , cloneTable.ParentRelations.Count);
1027                         AssertEquals ("#A04", 2,  cloneTable.Columns.Count);
1028                         AssertEquals ("#A05", 1, cloneTable.Constraints.Count);
1029                         AssertEquals ("#A06", "Id / Name + (Id * Id)", cloneTable.DisplayExpression);
1030                         AssertEquals ("#A07", 1 ,cloneTable.ExtendedProperties.Count);
1031                         AssertEquals ("#A08", false ,cloneTable.HasErrors);
1032 #if NET_1_1
1033 #else
1034                         AssertEquals ("#A09", 2057, cloneTable.Locale.LCID);
1035 #endif
1036                         AssertEquals ("#A10", 100, cloneTable.MinimumCapacity);
1037                         AssertEquals ("#A11","Namespace#1", cloneTable.Namespace);
1038                         AssertEquals ("#A12", "PrefixNo:1",cloneTable.Prefix);
1039                         AssertEquals ("#A13", "Id",  cloneTable.PrimaryKey[0].ColumnName);
1040                         AssertEquals ("#A14",0 , cloneTable.Rows.Count );
1041                         AssertEquals ("#A15", "Table#1", cloneTable.TableName);
1042
1043                         //Testing properties of copy
1044                         DataTable copyTable = table.Copy ();
1045                         AssertEquals ("#A16",true ,copyTable.CaseSensitive);
1046                         AssertEquals ("#A17", 0 , copyTable.ChildRelations.Count);
1047                         AssertEquals ("#A18", 0 , copyTable.ParentRelations.Count);
1048                         AssertEquals ("#A19", 2,  copyTable.Columns.Count);
1049                         AssertEquals ("#A20", 1, copyTable.Constraints.Count);
1050                         AssertEquals ("#A21", "Id / Name + (Id * Id)", copyTable.DisplayExpression);
1051                         AssertEquals ("#A22", 1 ,copyTable.ExtendedProperties.Count);
1052                         AssertEquals ("#A23", true ,copyTable.HasErrors);
1053 #if NET_1_1
1054 #else
1055                         AssertEquals ("#A24", 2057, copyTable.Locale.LCID);
1056 #endif
1057                         AssertEquals ("#A25", 100, copyTable.MinimumCapacity);
1058                         AssertEquals ("#A26","Namespace#1", copyTable.Namespace);
1059                         AssertEquals ("#A27", "PrefixNo:1",copyTable.Prefix);
1060                         AssertEquals ("#A28", "Id",  copyTable.PrimaryKey[0].ColumnName);
1061                         AssertEquals ("#A29", 2 , copyTable.Rows.Count );
1062                         AssertEquals ("#A30", "Table#1", copyTable.TableName);
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                                 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                         AssertEquals ("#A01", 1 ,changesTable.Rows.Count);
1131                         AssertEquals ("#A02","Efg" ,changesTable.Rows[0]["Name"]);
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                                         AssertEquals ("#A03",typeof(NullReferenceException) ,e.GetType ());
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                         AssertEquals ("#A03", "Abc" , (table.Rows [0]) ["Name"]);
1153                         AssertEquals ("#A04", 2, table.Rows.Count);
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                                 Fail ("#AA1 Should have thrown exception violativ PK");
1192                         } catch (ConstraintException e) {}
1193
1194                         // check row states
1195                         AssertEquals ("#A1", src.Rows [0].RowState, target.Rows [0].RowState);
1196                         AssertEquals ("#A2", src.Rows [1].RowState, target.Rows [1].RowState);
1197                         AssertEquals ("#A3", src.Rows [2].RowState, target.Rows [2].RowState);
1198                         AssertEquals ("#A4", src.Rows [3].RowState, target.Rows [3].RowState);
1199
1200                         // check for modified row (1st row)
1201                         AssertEquals ("#B1", (string) src.Rows [0] [1], (string) target.Rows [0] [1]);
1202                         AssertEquals ("#B2", (string) src.Rows [0] [1, DataRowVersion.Default], (string) target.Rows [0] [1, DataRowVersion.Default]);
1203                         AssertEquals ("#B3", (string) src.Rows [0] [1, DataRowVersion.Original], (string) target.Rows [0] [1, DataRowVersion.Original]);
1204                         AssertEquals ("#B4", (string) src.Rows [0] [1, DataRowVersion.Current], (string) target.Rows [0] [1, DataRowVersion.Current]);
1205                         AssertEquals ("#B5", false, target.Rows [0].HasVersion(DataRowVersion.Proposed));
1206
1207                         // check for deleted row (2nd row)
1208                         AssertEquals ("#C1", (string) src.Rows [1] [1, DataRowVersion.Original], (string) target.Rows [1] [1, DataRowVersion.Original]);
1209
1210                         // check for unchanged row (3rd row)
1211                         AssertEquals ("#D1", (string) src.Rows [2] [1], (string) target.Rows [2] [1]);
1212                         AssertEquals ("#D2", (string) src.Rows [2] [1, DataRowVersion.Default], (string) target.Rows [2] [1, DataRowVersion.Default]);
1213                         AssertEquals ("#D3", (string) src.Rows [2] [1, DataRowVersion.Original], (string) target.Rows [2] [1, DataRowVersion.Original]);
1214                         AssertEquals ("#D4", (string) src.Rows [2] [1, DataRowVersion.Current], (string) target.Rows [2] [1, DataRowVersion.Current]);
1215
1216                         // check for newly added row (4th row)
1217                         AssertEquals ("#E1", (string) src.Rows [3] [1], (string) target.Rows [3] [1]);
1218                         AssertEquals ("#E2", (string) src.Rows [3] [1, DataRowVersion.Default], (string) target.Rows [3] [1, DataRowVersion.Default]);
1219                         AssertEquals ("#E3", (string) src.Rows [3] [1, DataRowVersion.Current], (string) target.Rows [3] [1, DataRowVersion.Current]);
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                         AssertEquals ("#1", 0, table.Rows.Count);
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                         AssertEquals ("#1", 2, table.Rows.Count);
1265
1266                         // Both the deleted rows shud be now gone
1267                         table.AcceptChanges ();
1268                         AssertEquals ("#2", 0, table.Rows.Count);
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                         AssertEquals ("#3", 2, table.Rows.Count);
1280                         AssertEquals ("#4", DataRowState.Deleted, table.Rows[1].RowState);
1281
1282                         try {
1283                                 table.RejectChanges ();
1284                                 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                         AssertEquals (2, table.Rows.Count);
1321                         AssertEquals (1, table.ChildRelations.Count);
1322                         try {
1323                                 table.Reset ();
1324                                 Fail ("#A01, should have thrown ArgumentException");
1325                         }
1326                         catch (ArgumentException) {
1327                         }
1328                         AssertEquals ("#CT01", 0, table.Rows.Count);
1329                         AssertEquals ("#CT02", 0, table.ChildRelations.Count);
1330                         AssertEquals ("#CT03", 0, table.ParentRelations.Count);
1331                         AssertEquals ("#CT04", 0, table.Constraints.Count);
1332
1333                         table1.Reset ();
1334                         AssertEquals ("#A05", 0, table1.Rows.Count);
1335                         AssertEquals ("#A06", 0, table1.Constraints.Count);
1336                         AssertEquals ("#A07", 0, table1.ParentRelations.Count);
1337
1338                         // clear test
1339                         table.Clear ();
1340                         AssertEquals ("#A08", 0, table.Rows.Count);
1341 #if NET_1_1
1342                         AssertEquals ("#A09", 0, table.Constraints.Count);
1343 #else
1344                         AssertEquals ("#A09", 1, table.Constraints.Count);
1345 #endif
1346                         AssertEquals ("#A10", 0, table.ChildRelations.Count);
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                         AssertEquals ("#3 should have fired cleared event", true, _tableClearingEventFired);
1375                         AssertEquals ("#0 should have fired cleared event", true, _tableClearedEventFired);
1376 #endif // NET_2_0
1377
1378                         DataRow r = table.Rows.Find (1);
1379                         AssertEquals ("#1 should have cleared", true, r == null);
1380
1381                         // try adding new row. indexes should have cleared
1382                         table.Rows.Add (new object [] { 2, "mono 2" });
1383                         AssertEquals ("#2 should add row", 1, table.Rows.Count);
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                         AssertEquals ("test#01", "<?xml version=\"1.0\" encoding=\"utf-16\"?>", substring);
1428
1429                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1430                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1431                         AssertEquals ("test#02", "<xs:schema id=\"NewDataSet\" xmlns=\"\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\">", substring);
1432                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1433                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1434                         AssertEquals ("test#03", "  <xs:element name=\"NewDataSet\" msdata:IsDataSet=\"true\" msdata:MainDataTable=\"TestWriteXmlSchema\" msdata:UseCurrentLocale=\"true\">", substring);
1435                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1436                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1437                         AssertEquals ("test#04", "    <xs:complexType>", substring);
1438
1439                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1440                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1441                         AssertEquals ("test#05", "      <xs:choice minOccurs=\"0\" maxOccurs=\"unbounded\">", substring);
1442
1443                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1444                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1445                         AssertEquals ("test#06", "        <xs:element name=\"TestWriteXmlSchema\">", substring);
1446
1447                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1448                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1449                         AssertEquals ("test#07", "          <xs:complexType>", substring);
1450
1451                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1452                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1453                         AssertEquals ("test#08", "            <xs:sequence>", substring);
1454
1455                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1456                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1457                         AssertEquals ("test#09", "              <xs:element name=\"Col1\" type=\"xs:int\" minOccurs=\"0\" />", substring);
1458
1459                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1460                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1461                         AssertEquals ("test#10", "              <xs:element name=\"Col2\" type=\"xs:int\" minOccurs=\"0\" />", substring);
1462
1463                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1464                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1465                         AssertEquals ("test#11", "            </xs:sequence>", substring);
1466
1467                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1468                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1469                         AssertEquals ("test#12", "          </xs:complexType>", substring);
1470
1471                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1472                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1473                         AssertEquals ("test#13", "        </xs:element>", substring);
1474
1475
1476                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1477                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1478                         AssertEquals ("test#14", "      </xs:choice>", substring);
1479
1480                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1481                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1482                         AssertEquals ("test#15", "    </xs:complexType>", substring);
1483
1484                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1485                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1486                         AssertEquals ("test#16", "  </xs:element>", substring);
1487                         AssertEquals ("test#17", "</xs:schema>", TextString);
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                         AssertEquals ("test#01", "<?xml version=\"1.0\" encoding=\"utf-16\"?>", substring);
1517
1518                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1519                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1520                         AssertEquals ("test#02", "<xs:schema id=\"NewDataSet\" xmlns=\"\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\">", substring);
1521                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1522                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1523                         AssertEquals ("test#03", "  <xs:element name=\"NewDataSet\" msdata:IsDataSet=\"true\" msdata:MainDataTable=\"TestWriteXmlSchema\" msdata:UseCurrentLocale=\"true\">", substring);
1524                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1525                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1526                         AssertEquals ("test#04", "    <xs:complexType>", substring);
1527
1528                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1529                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1530                         AssertEquals ("test#05", "      <xs:choice minOccurs=\"0\" maxOccurs=\"unbounded\">", substring);
1531
1532                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1533                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1534                         AssertEquals ("test#06", "        <xs:element name=\"TestWriteXmlSchema\">", substring);
1535
1536                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1537                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1538                         AssertEquals ("test#07", "          <xs:complexType>", substring);
1539
1540                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1541                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1542                         AssertEquals ("test#08", "            <xs:sequence>", substring);
1543
1544                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1545                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1546                         AssertEquals ("test#09", "              <xs:element name=\"Col1\" type=\"xs:int\" minOccurs=\"0\" />", substring);
1547
1548                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1549                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1550                         AssertEquals ("test#10", "              <xs:element name=\"Col2\" type=\"xs:int\" minOccurs=\"0\" />", substring);
1551
1552                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1553                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1554                         AssertEquals ("test#11", "            </xs:sequence>", substring);
1555
1556                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1557                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1558                         AssertEquals ("test#12", "          </xs:complexType>", substring);
1559
1560                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1561                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1562                         AssertEquals ("test#13", "        </xs:element>", substring);
1563
1564                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1565                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1566                         AssertEquals ("test#14", "      </xs:choice>", substring);
1567
1568                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1569                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1570                         AssertEquals ("test#15", "    </xs:complexType>", substring);
1571
1572                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1573                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1574                         AssertEquals ("test#16", "    <xs:unique name=\"Constraint1\">", substring);
1575
1576                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1577                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1578                         AssertEquals ("test#17", "      <xs:selector xpath=\".//TestWriteXmlSchema\" />", substring);
1579
1580                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1581                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1582                         AssertEquals ("test#18", "      <xs:field xpath=\"Col1\" />", substring);
1583
1584                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1585                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1586                         AssertEquals ("test#19", "    </xs:unique>", substring);
1587
1588                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1589                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1590                         AssertEquals ("test#20", "  </xs:element>", substring);
1591                         AssertEquals ("test#21", "</xs:schema>", TextString);
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                         AssertEquals ("test#01", "<?xml version=\"1.0\" encoding=\"utf-16\"?>", substring);
1621
1622                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1623                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1624                         AssertEquals ("test#02", "<xs:schema id=\"NewDataSet\" xmlns=\"\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\">", substring);
1625                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1626                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1627                         AssertEquals ("test#03", "  <xs:element name=\"NewDataSet\" msdata:IsDataSet=\"true\" msdata:MainDataTable=\"TestWriteXmlSchema\" msdata:UseCurrentLocale=\"true\">", substring);
1628                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1629                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1630                         AssertEquals ("test#04", "    <xs:complexType>", substring);
1631
1632                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1633                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1634                         AssertEquals ("test#05", "      <xs:choice minOccurs=\"0\" maxOccurs=\"unbounded\">", substring);
1635
1636                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1637                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1638                         AssertEquals ("test#06", "        <xs:element name=\"TestWriteXmlSchema\">", substring);
1639
1640                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1641                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1642                         AssertEquals ("test#07", "          <xs:complexType>", substring);
1643
1644                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1645                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1646                         AssertEquals ("test#08", "            <xs:sequence>", substring);
1647
1648                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1649                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1650                         AssertEquals ("test#09", "              <xs:element name=\"Col1\" type=\"xs:int\" minOccurs=\"0\" />", substring);
1651
1652                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1653                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1654                         AssertEquals ("test#10", "              <xs:element name=\"Col2\" type=\"xs:int\" minOccurs=\"0\" />", substring);
1655
1656                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1657                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1658                         AssertEquals ("test#11", "            </xs:sequence>", substring);
1659
1660                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1661                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1662                         AssertEquals ("test#12", "          </xs:complexType>", substring);
1663
1664                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1665                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1666                         AssertEquals ("test#13", "        </xs:element>", substring);
1667
1668                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1669                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1670                         AssertEquals ("test#14", "        <xs:element name=\"HelloWorld\">", substring);
1671
1672                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1673                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1674                         AssertEquals ("test#15", "          <xs:complexType>", substring);
1675
1676                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1677                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1678                         AssertEquals ("test#16", "            <xs:sequence>", substring);
1679
1680                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1681                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1682                         AssertEquals ("test#17", "              <xs:element name=\"T1\" type=\"xs:int\" minOccurs=\"0\" />", substring);
1683
1684                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1685                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1686                         AssertEquals ("test#18", "              <xs:element name=\"T2\" type=\"xs:int\" minOccurs=\"0\" />", substring);
1687
1688                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1689                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1690                         AssertEquals ("test#19", "            </xs:sequence>", substring);
1691
1692                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1693                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1694                         AssertEquals ("test#20", "          </xs:complexType>", substring);
1695
1696                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1697                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1698                         AssertEquals ("test#21", "        </xs:element>", substring);
1699
1700                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1701                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1702                         AssertEquals ("test#22", "      </xs:choice>", substring);
1703
1704                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1705                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1706                         AssertEquals ("test#23", "    </xs:complexType>", substring);
1707
1708                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1709                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1710                         AssertEquals ("test#24", "    <xs:unique name=\"Constraint1\">", substring);
1711
1712                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1713                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1714                         AssertEquals ("test#25", "      <xs:selector xpath=\".//TestWriteXmlSchema\" />", substring);
1715
1716                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1717                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1718                         AssertEquals ("test#26", "      <xs:field xpath=\"Col1\" />", substring);
1719
1720                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1721                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1722                         AssertEquals ("test#27", "    </xs:unique>", substring);
1723
1724                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1725                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1726                         AssertEquals ("test#28", "    <xs:keyref name=\"Relation1\" refer=\"Constraint1\">", substring);
1727
1728                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1729                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1730                         AssertEquals ("test#29", "      <xs:selector xpath=\".//HelloWorld\" />", substring);
1731
1732                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1733                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1734                         AssertEquals ("test#30", "      <xs:field xpath=\"T1\" />", substring);
1735
1736                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1737                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1738                         AssertEquals ("test#31", "    </xs:keyref>", substring);
1739
1740                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1741                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1742                         AssertEquals ("test#32", "  </xs:element>", substring);
1743                         AssertEquals ("test#33", "</xs:schema>", TextString);
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                         AssertEquals (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                         AssertEquals ("#1" , true, col1.AllowDBNull);
1830                         AssertEquals ("#2" , true, col2.AllowDBNull);
1831                         AssertEquals ("#3" , false, col2.Unique);
1832                         AssertEquals ("#4" , false, col2.Unique);
1833
1834                         table.PrimaryKey = new DataColumn[] {col1,col2};
1835                         AssertEquals ("#5" , false, col1.AllowDBNull);
1836                         AssertEquals ("#6" , false, col2.AllowDBNull);
1837                         // LAMESPEC or bug ??
1838                         AssertEquals ("#7" , false, col1.Unique);
1839                         AssertEquals ("#8" , false, col2.Unique);
1840                 }
1841
1842                 void RowChanging (object o, DataRowChangeEventArgs e)
1843                 {
1844                         AssertEquals ("changing.Action", rowChangingExpectedAction, e.Action);
1845                         rowChangingRowChanging = true;
1846                 }
1847
1848                 void RowChanged (object o, DataRowChangeEventArgs e)
1849                 {
1850                         AssertEquals ("changed.Action", rowChangingExpectedAction, e.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 ("changing,Added", rowChangingRowChanging);
1868                         Assert ("changed,Added", rowChangingRowChanged);
1869                         rowChangingExpectedAction = DataRowAction.Change;
1870                         dt.Rows [0] [0] = 2;
1871                         Assert ("changing,Changed", rowChangingRowChanging);
1872                         Assert ("changed,Changed", rowChangingRowChanged);
1873                 }
1874
1875                  [Test]
1876                 public void CloneSubClassTest()
1877                 {
1878                         MyDataTable dt1 = new MyDataTable();
1879                         MyDataTable dt = (MyDataTable)(dt1.Clone());
1880                         AssertEquals("A#01",2,MyDataTable.count);
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                                 AssertEquals ("#1 should have fired event and set action to commit",
1902                                               DataRowAction.Commit, rowActionChanging);
1903                                 AssertEquals ("#2 should have fired event and set action to commit",
1904                                               DataRowAction.Commit, rowActionChanged);
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                         AssertEquals(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                         AssertEquals("TableInitialized #01", tableInitialized, false);
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                         AssertEquals("TableInitialized #02", tableInitialized, true);
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                         AssertEquals("TableInitialized #03", tableInitialized, dt.IsInitialized);
1953                         dt.Initialized -= new EventHandler (OnTableInitialized);
1954                 }
1955                 [Test]
1956                 public void TableInitializedEventTest4 () {
1957                         DataTable dt = new DataTable();
1958                         AssertEquals("TableInitialized #04", true, dt.IsInitialized);
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                         AssertEquals("TableInitialized #05", false, dt.IsInitialized);
1965                         dt.EndInit ();
1966                         NUnit.Framework.Assert.IsTrue (dt.IsInitialized, "TableInitialized #06");
1967                         NUnit.Framework.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 ("HasRows", dtr.HasRows);
2010                         AssertEquals ("CountCols", dt.Columns.Count, dtr.FieldCount);
2011                         int ri = 0;
2012                         while (dtr.Read ()) {
2013                                 for (int i = 0; i < dtr.FieldCount; i++) {
2014                                         AssertEquals ("RowData-" + ri + "-" + i, dt.Rows[ri][i],
2015                                                 dtr[i]);
2016                                 }
2017                                 ri++;
2018                         }
2019                 }
2020
2021                 [Test]
2022                 public void CreateDataReader2 () {
2023                         localSetup ();
2024                         DataTableReader dtr = dt.CreateDataReader ();
2025                         Assert ("HasRows", dtr.HasRows);
2026                         AssertEquals ("CountCols", dt.Columns.Count, dtr.FieldCount);
2027                         dtr.Read ();
2028                         AssertEquals ("RowData0-0", 1, dtr[0]);
2029                         AssertEquals ("RowData0-1", "mono 1", dtr[1]);
2030                         dtr.Read ();
2031                         AssertEquals ("RowData1-0", 2, dtr[0]);
2032                         AssertEquals ("RowData1-1", "mono 2", dtr[1]);
2033                         dtr.Read ();
2034                         AssertEquals ("RowData2-0", 3, dtr[0]);
2035                         AssertEquals ("RowData2-1", "mono 3", dtr[1]);
2036                 }
2037
2038                 #endregion // DataTable.CreateDataReader Tests
2039
2040                 #region DataTable.Load Tests
2041
2042                 [Test]
2043                 public void Load_Basic () {
2044                         localSetup ();
2045                         DataTable dtLoad = new DataTable ("LoadBasic");
2046                         dtLoad.Columns.Add ("id", typeof (int));
2047                         dtLoad.Columns.Add ("name", typeof (string));
2048                         dtLoad.Columns["id"].ReadOnly = true;
2049                         dtLoad.Columns["name"].ReadOnly = true;
2050                         dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2051                         dtLoad.Rows.Add (new object[] { 1, "load 1" });
2052                         dtLoad.Rows.Add (new object[] { 2, "load 2" });
2053                         dtLoad.Rows.Add (new object[] { 3, "load 3" });
2054                         dtLoad.AcceptChanges ();
2055                         DataTableReader dtr = dt.CreateDataReader ();
2056                         dtLoad.Load (dtr);
2057                         AssertEquals ("NColumns", 2, dtLoad.Columns.Count);
2058                         AssertEquals ("NRows", 3, dtLoad.Rows.Count);
2059                         AssertEquals ("RowData0-0", 1, dtLoad.Rows[0][0]);
2060                         AssertEquals ("RowData0-1", "mono 1", dtLoad.Rows[0][1]);
2061                         AssertEquals ("RowData1-0", 2, dtLoad.Rows[1][0]);
2062                         AssertEquals ("RowData1-1", "mono 2", dtLoad.Rows[1][1]);
2063                         AssertEquals ("RowData2-0", 3, dtLoad.Rows[2][0]);
2064                         AssertEquals ("RowData2-1", "mono 3", dtLoad.Rows[2][1]);
2065                 }
2066
2067                 [Test]
2068                 public void Load_NoSchema () {
2069                         localSetup ();
2070                         DataTable dtLoad = new DataTable ("LoadNoSchema");
2071                         DataTableReader dtr = dt.CreateDataReader ();
2072                         dtLoad.Load (dtr);
2073                         AssertEquals ("NColumns", 2, dtLoad.Columns.Count);
2074                         AssertEquals ("NRows", 3, dtLoad.Rows.Count);
2075                         AssertEquals ("RowData0-0", 1, dtLoad.Rows[0][0]);
2076                         AssertEquals ("RowData0-1", "mono 1", dtLoad.Rows[0][1]);
2077                         AssertEquals ("RowData1-0", 2, dtLoad.Rows[1][0]);
2078                         AssertEquals ("RowData1-1", "mono 2", dtLoad.Rows[1][1]);
2079                         AssertEquals ("RowData2-0", 3, dtLoad.Rows[2][0]);
2080                         AssertEquals ("RowData2-1", "mono 3", dtLoad.Rows[2][1]);
2081                 }
2082
2083                 internal struct fillErrorStruct {
2084                         internal string error;
2085                         internal string tableName;
2086                         internal int rowKey;
2087                         internal bool contFlag;
2088                         internal void init (string tbl, int row, bool cont, string err) {
2089                                 tableName = tbl;
2090                                 rowKey = row;
2091                                 contFlag = cont;
2092                                 error = err;
2093                         }
2094                 }
2095                 private fillErrorStruct[] fillErr = new fillErrorStruct[3];
2096                 private int fillErrCounter;
2097                 private void fillErrorHandler (object sender, FillErrorEventArgs e) {
2098                         e.Continue = fillErr[fillErrCounter].contFlag;
2099                         AssertEquals ("fillErr-T", fillErr[fillErrCounter].tableName, e.DataTable.TableName);
2100                         //AssertEquals ("fillErr-R", fillErr[fillErrCounter].rowKey, e.Values[0]);
2101                         AssertEquals ("fillErr-C", fillErr[fillErrCounter].contFlag, e.Continue);
2102                         //AssertEquals ("fillErr-E", fillErr[fillErrCounter].error, e.Errors.Message);
2103                         fillErrCounter++;
2104                 }
2105
2106                 [Test]
2107                 [ExpectedException (typeof (ArgumentException))]
2108                 public void Load_Incompatible () {
2109                         localSetup ();
2110                         DataTable dtLoad = new DataTable ("LoadIncompatible");
2111                         dtLoad.Columns.Add ("name", typeof (double));
2112                         DataTableReader dtr = dt.CreateDataReader ();
2113                         dtLoad.Load (dtr);
2114                 }
2115                 [Test]
2116                 // Load doesn't have a third overload in System.Data
2117                 // and is commented-out below
2118                 public void Load_IncompatibleEHandlerT () {
2119                         fillErrCounter = 0;
2120                         fillErr[0].init ("LoadIncompatible", 1, true,
2121                                  "Input string was not in a correct format.Couldn't store <mono 1> in name Column.  Expected type is Double.");
2122                         fillErr[1].init ("LoadIncompatible", 2, true,
2123                                 "Input string was not in a correct format.Couldn't store <mono 2> in name Column.  Expected type is Double.");
2124                         fillErr[2].init ("LoadIncompatible", 3, true,
2125                                 "Input string was not in a correct format.Couldn't store <mono 3> in name Column.  Expected type is Double.");
2126                         localSetup ();
2127                         DataTable dtLoad = new DataTable ("LoadIncompatible");
2128                         dtLoad.Columns.Add ("name", typeof (double));
2129                         DataTableReader dtr = dt.CreateDataReader ();
2130                         dtLoad.Load (dtr,LoadOption.PreserveChanges,fillErrorHandler);
2131                 }
2132                 [Test]
2133                 // Load doesn't have a third overload in System.Data
2134                 // and is commented-out below
2135                 [ExpectedException (typeof (ArgumentException))]
2136                 public void Load_IncompatibleEHandlerF () {
2137                         fillErrCounter = 0;
2138                         fillErr[0].init ("LoadIncompatible", 1, false,
2139                                 "Input string was not in a correct format.Couldn't store <mono 1> in name Column.  Expected type is Double.");
2140                         localSetup ();
2141                         DataTable dtLoad = new DataTable ("LoadIncompatible");
2142                         dtLoad.Columns.Add ("name", typeof (double));
2143                         DataTableReader dtr = dt.CreateDataReader ();
2144                         dtLoad.Load (dtr, LoadOption.PreserveChanges, fillErrorHandler);
2145                 }
2146
2147                 [Test]
2148                 public void Load_ExtraColsEqualVal () {
2149                         localSetup ();
2150                         DataTable dtLoad = new DataTable ("LoadExtraCols");
2151                         dtLoad.Columns.Add ("id", typeof (int));
2152                         dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2153                         dtLoad.Rows.Add (new object[] { 1 });
2154                         dtLoad.Rows.Add (new object[] { 2 });
2155                         dtLoad.Rows.Add (new object[] { 3 });
2156                         dtLoad.AcceptChanges ();
2157                         DataTableReader dtr = dt.CreateDataReader ();
2158                         dtLoad.Load (dtr);
2159                         AssertEquals ("NColumns", 2, dtLoad.Columns.Count);
2160                         AssertEquals ("NRows", 3, dtLoad.Rows.Count);
2161                         AssertEquals ("RowData0-0", 1, dtLoad.Rows[0][0]);
2162                         AssertEquals ("RowData0-1", "mono 1", dtLoad.Rows[0][1]);
2163                         AssertEquals ("RowData1-0", 2, dtLoad.Rows[1][0]);
2164                         AssertEquals ("RowData1-1", "mono 2", dtLoad.Rows[1][1]);
2165                         AssertEquals ("RowData2-0", 3, dtLoad.Rows[2][0]);
2166                         AssertEquals ("RowData2-1", "mono 3", dtLoad.Rows[2][1]);
2167                 }
2168
2169                 [Test]
2170                 public void Load_ExtraColsNonEqualVal () {
2171                         localSetup ();
2172                         DataTable dtLoad = new DataTable ("LoadExtraCols");
2173                         dtLoad.Columns.Add ("id", typeof (int));
2174                         dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2175                         dtLoad.Rows.Add (new object[] { 4 });
2176                         dtLoad.Rows.Add (new object[] { 5 });
2177                         dtLoad.Rows.Add (new object[] { 6 });
2178                         dtLoad.AcceptChanges ();
2179                         DataTableReader dtr = dt.CreateDataReader ();
2180                         dtLoad.Load (dtr);
2181                         AssertEquals ("NColumns", 2, dtLoad.Columns.Count);
2182                         AssertEquals ("NRows", 6, dtLoad.Rows.Count);
2183                         AssertEquals ("RowData0-0", 4, dtLoad.Rows[0][0]);
2184                         AssertEquals ("RowData1-0", 5, dtLoad.Rows[1][0]);
2185                         AssertEquals ("RowData2-0", 6, dtLoad.Rows[2][0]);
2186                         AssertEquals ("RowData3-0", 1, dtLoad.Rows[3][0]);
2187                         AssertEquals ("RowData3-1", "mono 1", dtLoad.Rows[3][1]);
2188                         AssertEquals ("RowData4-0", 2, dtLoad.Rows[4][0]);
2189                         AssertEquals ("RowData4-1", "mono 2", dtLoad.Rows[4][1]);
2190                         AssertEquals ("RowData5-0", 3, dtLoad.Rows[5][0]);
2191                         AssertEquals ("RowData5-1", "mono 3", dtLoad.Rows[5][1]);
2192                 }
2193
2194                 [Test]
2195                 [ExpectedException (typeof (ConstraintException))]
2196                 public void Load_MissingColsNonNullable () {
2197                         localSetup ();
2198                         DataTable dtLoad = new DataTable ("LoadMissingCols");
2199                         dtLoad.Columns.Add ("id", typeof (int));
2200                         dtLoad.Columns.Add ("name", typeof (string));
2201                         dtLoad.Columns.Add ("missing", typeof (string));
2202                         dtLoad.Columns["missing"].AllowDBNull = false;
2203                         dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2204                         dtLoad.Rows.Add (new object[] { 4, "mono 4", "miss4" });
2205                         dtLoad.Rows.Add (new object[] { 5, "mono 5", "miss5" });
2206                         dtLoad.Rows.Add (new object[] { 6, "mono 6", "miss6" });
2207                         dtLoad.AcceptChanges ();
2208                         DataTableReader dtr = dt.CreateDataReader ();
2209                         dtLoad.Load (dtr);
2210                 }
2211
2212                 [Test]
2213                 public void Load_MissingColsDefault () {
2214                         localSetup ();
2215                         DataTable dtLoad = new DataTable ("LoadMissingCols");
2216                         dtLoad.Columns.Add ("id", typeof (int));
2217                         dtLoad.Columns.Add ("name", typeof (string));
2218                         dtLoad.Columns.Add ("missing", typeof (string));
2219                         dtLoad.Columns["missing"].AllowDBNull = false;
2220                         dtLoad.Columns["missing"].DefaultValue = "DefaultValue";
2221                         dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2222                         dtLoad.Rows.Add (new object[] { 4, "mono 4", "miss4" });
2223                         dtLoad.Rows.Add (new object[] { 5, "mono 5", "miss5" });
2224                         dtLoad.Rows.Add (new object[] { 6, "mono 6", "miss6" });
2225                         dtLoad.AcceptChanges ();
2226                         DataTableReader dtr = dt.CreateDataReader ();
2227                         dtLoad.Load (dtr);
2228                         AssertEquals ("NColumns", 3, dtLoad.Columns.Count);
2229                         AssertEquals ("NRows", 6, dtLoad.Rows.Count);
2230                         AssertEquals ("RowData0-0", 4, dtLoad.Rows[0][0]);
2231                         AssertEquals ("RowData0-1", "mono 4", dtLoad.Rows[0][1]);
2232                         AssertEquals ("RowData0-2", "miss4", dtLoad.Rows[0][2]);
2233                         AssertEquals ("RowData1-0", 5, dtLoad.Rows[1][0]);
2234                         AssertEquals ("RowData1-1", "mono 5", dtLoad.Rows[1][1]);
2235                         AssertEquals ("RowData1-2", "miss5", dtLoad.Rows[1][2]);
2236                         AssertEquals ("RowData2-0", 6, dtLoad.Rows[2][0]);
2237                         AssertEquals ("RowData2-1", "mono 6", dtLoad.Rows[2][1]);
2238                         AssertEquals ("RowData2-2", "miss6", dtLoad.Rows[2][2]);
2239                         AssertEquals ("RowData3-0", 1, dtLoad.Rows[3][0]);
2240                         AssertEquals ("RowData3-1", "mono 1", dtLoad.Rows[3][1]);
2241                         AssertEquals ("RowData3-2", "DefaultValue", dtLoad.Rows[3][2]);
2242                         AssertEquals ("RowData4-0", 2, dtLoad.Rows[4][0]);
2243                         AssertEquals ("RowData4-1", "mono 2", dtLoad.Rows[4][1]);
2244                         AssertEquals ("RowData4-2", "DefaultValue", dtLoad.Rows[4][2]);
2245                         AssertEquals ("RowData5-0", 3, dtLoad.Rows[5][0]);
2246                         AssertEquals ("RowData5-1", "mono 3", dtLoad.Rows[5][1]);
2247                         AssertEquals ("RowData5-2", "DefaultValue", dtLoad.Rows[5][2]);
2248                 }
2249
2250                 [Test]
2251                 public void Load_MissingColsNullable () {
2252                         localSetup ();
2253                         DataTable dtLoad = new DataTable ("LoadMissingCols");
2254                         dtLoad.Columns.Add ("id", typeof (int));
2255                         dtLoad.Columns.Add ("name", typeof (string));
2256                         dtLoad.Columns.Add ("missing", typeof (string));
2257                         dtLoad.Columns["missing"].AllowDBNull = true;
2258                         dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2259                         dtLoad.Rows.Add (new object[] { 4, "mono 4", "miss4" });
2260                         dtLoad.Rows.Add (new object[] { 5, "mono 5", "miss5" });
2261                         dtLoad.Rows.Add (new object[] { 6, "mono 6", "miss6" });
2262                         dtLoad.AcceptChanges ();
2263                         DataTableReader dtr = dt.CreateDataReader ();
2264                         dtLoad.Load (dtr);
2265                         AssertEquals ("NColumns", 3, dtLoad.Columns.Count);
2266                         AssertEquals ("NRows", 6, dtLoad.Rows.Count);
2267                         AssertEquals ("RowData0-0", 4, dtLoad.Rows[0][0]);
2268                         AssertEquals ("RowData0-1", "mono 4", dtLoad.Rows[0][1]);
2269                         AssertEquals ("RowData0-2", "miss4", dtLoad.Rows[0][2]);
2270                         AssertEquals ("RowData1-0", 5, dtLoad.Rows[1][0]);
2271                         AssertEquals ("RowData1-1", "mono 5", dtLoad.Rows[1][1]);
2272                         AssertEquals ("RowData1-2", "miss5", dtLoad.Rows[1][2]);
2273                         AssertEquals ("RowData2-0", 6, dtLoad.Rows[2][0]);
2274                         AssertEquals ("RowData2-1", "mono 6", dtLoad.Rows[2][1]);
2275                         AssertEquals ("RowData2-2", "miss6", dtLoad.Rows[2][2]);
2276                         AssertEquals ("RowData3-0", 1, dtLoad.Rows[3][0]);
2277                         AssertEquals ("RowData3-1", "mono 1", dtLoad.Rows[3][1]);
2278                         //AssertEquals ("RowData3-2", null, dtLoad.Rows[3][2]);
2279                         AssertEquals ("RowData4-0", 2, dtLoad.Rows[4][0]);
2280                         AssertEquals ("RowData4-1", "mono 2", dtLoad.Rows[4][1]);
2281                         //AssertEquals ("RowData4-2", null, dtLoad.Rows[4][2]);
2282                         AssertEquals ("RowData5-0", 3, dtLoad.Rows[5][0]);
2283                         AssertEquals ("RowData5-1", "mono 3", dtLoad.Rows[5][1]);
2284                         //AssertEquals ("RowData5-2", null, dtLoad.Rows[5][2]);
2285                 }
2286
2287                 private DataTable setupRowState () {
2288                         DataTable tbl = new DataTable ("LoadRowStateChanges");
2289                         tbl.RowChanged += new DataRowChangeEventHandler (dtLoad_RowChanged);
2290                         tbl.RowChanging += new DataRowChangeEventHandler (dtLoad_RowChanging);
2291                         tbl.Columns.Add ("id", typeof (int));
2292                         tbl.Columns.Add ("name", typeof (string));
2293                         tbl.PrimaryKey = new DataColumn[] { tbl.Columns["id"] };
2294                         tbl.Rows.Add (new object[] { 1, "RowState 1" });
2295                         tbl.Rows.Add (new object[] { 2, "RowState 2" });
2296                         tbl.Rows.Add (new object[] { 3, "RowState 3" });
2297                         tbl.AcceptChanges ();
2298                         // Update Table with following changes: Row0 unmodified,
2299                         // Row1 modified, Row2 deleted, Row3 added, Row4 not-present.
2300                         tbl.Rows[1]["name"] = "Modify 2";
2301                         tbl.Rows[2].Delete ();
2302                         DataRow row = tbl.NewRow ();
2303                         row["id"] = 4;
2304                         row["name"] = "Add 4";
2305                         tbl.Rows.Add (row);
2306                         return (tbl);
2307                 }
2308
2309                 private DataRowAction[] rowChangeAction = new DataRowAction[5];
2310                 private bool checkAction = false;
2311                 private int rowChagedCounter, rowChangingCounter;
2312                 private void rowActionInit (DataRowAction[] act) {
2313                         checkAction = true;
2314                         rowChagedCounter = 0;
2315                         rowChangingCounter = 0;
2316                         for (int i = 0; i < 5; i++)
2317                                 rowChangeAction[i] = act[i];
2318                 }
2319                 private void rowActionEnd () {
2320                         checkAction = false;
2321                 }
2322                 private void dtLoad_RowChanged (object sender, DataRowChangeEventArgs e) {
2323                         if (checkAction) {
2324                                 AssertEquals ("RowChanged" + rowChagedCounter,
2325                                         rowChangeAction[rowChagedCounter], e.Action);
2326                                 rowChagedCounter++;
2327                         }
2328                 }
2329                 private void dtLoad_RowChanging (object sender, DataRowChangeEventArgs e) {
2330                         if (checkAction) {
2331                                 AssertEquals ("RowChanging" + rowChangingCounter,
2332                                         rowChangeAction[rowChangingCounter], e.Action);
2333                                 rowChangingCounter++;
2334                         }
2335                 }
2336
2337                 [Test]
2338                 public void Load_RowStateChangesDefault () {
2339                         localSetup ();
2340                         dt.Rows.Add (new object[] { 4, "mono 4" });
2341                         dt.Rows.Add (new object[] { 5, "mono 5" });
2342                         dt.AcceptChanges ();
2343                         DataTableReader dtr = dt.CreateDataReader ();
2344                         DataTable dtLoad = setupRowState ();
2345                         DataRowAction[] dra = new DataRowAction[] {
2346                                 DataRowAction.ChangeCurrentAndOriginal,
2347                                 DataRowAction.ChangeOriginal,
2348                                 DataRowAction.ChangeOriginal,
2349                                 DataRowAction.ChangeOriginal,
2350                                 DataRowAction.ChangeCurrentAndOriginal};
2351                         rowActionInit (dra);
2352                         dtLoad.Load (dtr);
2353                         rowActionEnd ();
2354                         // asserting Unchanged Row0
2355                         AssertEquals ("RowData0-C", "mono 1",
2356                                 dtLoad.Rows[0][1,DataRowVersion.Current]);
2357                         AssertEquals ("RowData0-O", "mono 1",
2358                                 dtLoad.Rows[0][1,DataRowVersion.Original]);
2359                         AssertEquals ("RowState0", DataRowState.Unchanged,
2360                                 dtLoad.Rows[0].RowState);
2361                         // asserting Modified Row1
2362                         AssertEquals ("RowData1-C", "Modify 2",
2363                                 dtLoad.Rows[1][1, DataRowVersion.Current]);
2364                         AssertEquals ("RowData1-O", "mono 2",
2365                                 dtLoad.Rows[1][1, DataRowVersion.Original]);
2366                         AssertEquals ("RowState1", DataRowState.Modified,
2367                                 dtLoad.Rows[1].RowState);
2368                         // asserting Deleted Row2
2369                         AssertEquals ("RowData1-O", "mono 3",
2370                                 dtLoad.Rows[2][1, DataRowVersion.Original]);
2371                         AssertEquals ("RowState2", DataRowState.Deleted,
2372                                 dtLoad.Rows[2].RowState);
2373                         // asserting Added Row3
2374                         AssertEquals ("RowData3-C", "Add 4",
2375                                 dtLoad.Rows[3][1, DataRowVersion.Current]);
2376                         AssertEquals ("RowData3-O", "mono 4",
2377                                 dtLoad.Rows[3][1, DataRowVersion.Original]);
2378                         AssertEquals ("RowState3", DataRowState.Modified,
2379                                 dtLoad.Rows[3].RowState);
2380                         // asserting Unpresent Row4
2381                         AssertEquals ("RowData4-C", "mono 5",
2382                                 dtLoad.Rows[4][1, DataRowVersion.Current]);
2383                         AssertEquals ("RowData4-O", "mono 5",
2384                                 dtLoad.Rows[4][1, DataRowVersion.Original]);
2385                         AssertEquals ("RowState4", DataRowState.Unchanged,
2386                                 dtLoad.Rows[4].RowState);
2387                 }
2388
2389                 [Test]
2390                 [ExpectedException (typeof (VersionNotFoundException))]
2391                 public void Load_RowStateChangesDefaultDelete () {
2392                         localSetup ();
2393                         DataTable dtLoad = new DataTable ("LoadRowStateChanges");
2394                         dtLoad.Columns.Add ("id", typeof (int));
2395                         dtLoad.Columns.Add ("name", typeof (string));
2396                         dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2397                         dtLoad.Rows.Add (new object[] { 1, "RowState 1" });
2398                         dtLoad.Rows.Add (new object[] { 2, "RowState 2" });
2399                         dtLoad.Rows.Add (new object[] { 3, "RowState 3" });
2400                         dtLoad.AcceptChanges ();
2401                         dtLoad.Rows[2].Delete ();
2402                         DataTableReader dtr = dt.CreateDataReader ();
2403                         dtLoad.Load (dtr);
2404                         AssertEquals ("RowData2-C", " ",
2405                                 dtLoad.Rows[2][1, DataRowVersion.Current]);
2406                 }
2407
2408                 [Test]
2409                 public void Load_RowStatePreserveChanges () {
2410                         localSetup ();
2411                         dt.Rows.Add (new object[] { 4, "mono 4" });
2412                         dt.Rows.Add (new object[] { 5, "mono 5" });
2413                         dt.AcceptChanges ();
2414                         DataTableReader dtr = dt.CreateDataReader ();
2415                         DataTable dtLoad = setupRowState ();
2416                         DataRowAction[] dra = new DataRowAction[] {
2417                                 DataRowAction.ChangeCurrentAndOriginal,
2418                                 DataRowAction.ChangeOriginal,
2419                                 DataRowAction.ChangeOriginal,
2420                                 DataRowAction.ChangeOriginal,
2421                                 DataRowAction.ChangeCurrentAndOriginal};
2422                         rowActionInit (dra);
2423                         dtLoad.Load (dtr, LoadOption.PreserveChanges);
2424                         rowActionEnd ();
2425                         // asserting Unchanged Row0
2426                         AssertEquals ("RowData0-C", "mono 1",
2427                                 dtLoad.Rows[0][1, DataRowVersion.Current]);
2428                         AssertEquals ("RowData0-O", "mono 1",
2429                                 dtLoad.Rows[0][1, DataRowVersion.Original]);
2430                         AssertEquals ("RowState0", DataRowState.Unchanged,
2431                                 dtLoad.Rows[0].RowState);
2432                         // asserting Modified Row1
2433                         AssertEquals ("RowData1-C", "Modify 2",
2434                                 dtLoad.Rows[1][1, DataRowVersion.Current]);
2435                         AssertEquals ("RowData1-O", "mono 2",
2436                                 dtLoad.Rows[1][1, DataRowVersion.Original]);
2437                         AssertEquals ("RowState1", DataRowState.Modified,
2438                                 dtLoad.Rows[1].RowState);
2439                         // asserting Deleted Row2
2440                         AssertEquals ("RowData1-O", "mono 3",
2441                                 dtLoad.Rows[2][1, DataRowVersion.Original]);
2442                         AssertEquals ("RowState2", DataRowState.Deleted,
2443                                 dtLoad.Rows[2].RowState);
2444                         // asserting Added Row3
2445                         AssertEquals ("RowData3-C", "Add 4",
2446                                 dtLoad.Rows[3][1, DataRowVersion.Current]);
2447                         AssertEquals ("RowData3-O", "mono 4",
2448                                 dtLoad.Rows[3][1, DataRowVersion.Original]);
2449                         AssertEquals ("RowState3", DataRowState.Modified,
2450                                 dtLoad.Rows[3].RowState);
2451                         // asserting Unpresent Row4
2452                         AssertEquals ("RowData4-C", "mono 5",
2453                                 dtLoad.Rows[4][1, DataRowVersion.Current]);
2454                         AssertEquals ("RowData4-O", "mono 5",
2455                                 dtLoad.Rows[4][1, DataRowVersion.Original]);
2456                         AssertEquals ("RowState4", DataRowState.Unchanged,
2457                                 dtLoad.Rows[4].RowState);
2458                 }
2459
2460                 [Test]
2461                 [ExpectedException (typeof (VersionNotFoundException))]
2462                 public void Load_RowStatePreserveChangesDelete () {
2463                         localSetup ();
2464                         DataTable dtLoad = new DataTable ("LoadRowStateChanges");
2465                         dtLoad.Columns.Add ("id", typeof (int));
2466                         dtLoad.Columns.Add ("name", typeof (string));
2467                         dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2468                         dtLoad.Rows.Add (new object[] { 1, "RowState 1" });
2469                         dtLoad.Rows.Add (new object[] { 2, "RowState 2" });
2470                         dtLoad.Rows.Add (new object[] { 3, "RowState 3" });
2471                         dtLoad.AcceptChanges ();
2472                         dtLoad.Rows[2].Delete ();
2473                         DataTableReader dtr = dt.CreateDataReader ();
2474                         dtLoad.Load (dtr,LoadOption.PreserveChanges);
2475                         AssertEquals ("RowData2-C", " ",
2476                                 dtLoad.Rows[2][1, DataRowVersion.Current]);
2477                 }
2478
2479                 [Test]
2480                 public void Load_RowStateOverwriteChanges () {
2481                         localSetup ();
2482                         dt.Rows.Add (new object[] { 4, "mono 4" });
2483                         dt.Rows.Add (new object[] { 5, "mono 5" });
2484                         dt.AcceptChanges ();
2485                         DataTableReader dtr = dt.CreateDataReader ();
2486                         DataTable dtLoad = setupRowState ();
2487                         DataRowAction[] dra = new DataRowAction[] {
2488                                 DataRowAction.ChangeCurrentAndOriginal,
2489                                 DataRowAction.ChangeCurrentAndOriginal,
2490                                 DataRowAction.ChangeCurrentAndOriginal,
2491                                 DataRowAction.ChangeCurrentAndOriginal,
2492                                 DataRowAction.ChangeCurrentAndOriginal};
2493                         rowActionInit (dra);
2494                         dtLoad.Load (dtr, LoadOption.OverwriteChanges);
2495                         rowActionEnd ();
2496                         // asserting Unchanged Row0
2497                         AssertEquals ("RowData0-C", "mono 1",
2498                                 dtLoad.Rows[0][1, DataRowVersion.Current]);
2499                         AssertEquals ("RowData0-O", "mono 1",
2500                                 dtLoad.Rows[0][1, DataRowVersion.Original]);
2501                         AssertEquals ("RowState0", DataRowState.Unchanged,
2502                                 dtLoad.Rows[0].RowState);
2503                         // asserting Modified Row1
2504                         AssertEquals ("RowData1-C", "mono 2",
2505                                 dtLoad.Rows[1][1, DataRowVersion.Current]);
2506                         AssertEquals ("RowData1-O", "mono 2",
2507                                 dtLoad.Rows[1][1, DataRowVersion.Original]);
2508                         AssertEquals ("RowState1", DataRowState.Unchanged,
2509                                 dtLoad.Rows[1].RowState);
2510                         // asserting Deleted Row2
2511                         AssertEquals ("RowData1-C", "mono 3",
2512                                 dtLoad.Rows[2][1, DataRowVersion.Current]);
2513                         AssertEquals ("RowData1-O", "mono 3",
2514                                 dtLoad.Rows[2][1, DataRowVersion.Original]);
2515                         AssertEquals ("RowState2", DataRowState.Unchanged,
2516                                 dtLoad.Rows[2].RowState);
2517                         // asserting Added Row3
2518                         AssertEquals ("RowData3-C", "mono 4",
2519                                 dtLoad.Rows[3][1, DataRowVersion.Current]);
2520                         AssertEquals ("RowData3-O", "mono 4",
2521                                 dtLoad.Rows[3][1, DataRowVersion.Original]);
2522                         AssertEquals ("RowState3", DataRowState.Unchanged,
2523                                 dtLoad.Rows[3].RowState);
2524                         // asserting Unpresent Row4
2525                         AssertEquals ("RowData4-C", "mono 5",
2526                                 dtLoad.Rows[4][1, DataRowVersion.Current]);
2527                         AssertEquals ("RowData4-O", "mono 5",
2528                                 dtLoad.Rows[4][1, DataRowVersion.Original]);
2529                         AssertEquals ("RowState4", DataRowState.Unchanged,
2530                                 dtLoad.Rows[4].RowState);
2531                 }
2532
2533                 [Test]
2534                 public void Load_RowStateUpsert () {
2535                         localSetup ();
2536                         dt.Rows.Add (new object[] { 4, "mono 4" });
2537                         dt.Rows.Add (new object[] { 5, "mono 5" });
2538                         dt.AcceptChanges ();
2539                         DataTableReader dtr = dt.CreateDataReader ();
2540                         DataTable dtLoad = setupRowState ();
2541                         // Notice rowChange-Actions only occur 5 times, as number
2542                         // of actual rows, ignoring row duplication of the deleted row.
2543                         DataRowAction[] dra = new DataRowAction[] {
2544                                 DataRowAction.Change,
2545                                 DataRowAction.Change,
2546                                 DataRowAction.Add,
2547                                 DataRowAction.Change,
2548                                 DataRowAction.Add};
2549                         rowActionInit (dra);
2550                         dtLoad.Load (dtr, LoadOption.Upsert);
2551                         rowActionEnd ();
2552                         // asserting Unchanged Row0
2553                         AssertEquals ("RowData0-C", "mono 1",
2554                                 dtLoad.Rows[0][1, DataRowVersion.Current]);
2555                         AssertEquals ("RowData0-O", "RowState 1",
2556                                 dtLoad.Rows[0][1, DataRowVersion.Original]);
2557                         AssertEquals ("RowState0", DataRowState.Modified,
2558                                 dtLoad.Rows[0].RowState);
2559                         // asserting Modified Row1
2560                         AssertEquals ("RowData1-C", "mono 2",
2561                                 dtLoad.Rows[1][1, DataRowVersion.Current]);
2562                         AssertEquals ("RowData1-O", "RowState 2",
2563                                 dtLoad.Rows[1][1, DataRowVersion.Original]);
2564                         AssertEquals ("RowState1", DataRowState.Modified,
2565                                 dtLoad.Rows[1].RowState);
2566                         // asserting Deleted Row2 and "Deleted-Added" Row4
2567                         AssertEquals ("RowData2-O", "RowState 3",
2568                                 dtLoad.Rows[2][1, DataRowVersion.Original]);
2569                         AssertEquals ("RowState2", DataRowState.Deleted,
2570                                 dtLoad.Rows[2].RowState);
2571                         AssertEquals ("RowData4-C", "mono 3",
2572                                 dtLoad.Rows[4][1, DataRowVersion.Current]);
2573                         AssertEquals ("RowState4", DataRowState.Added,
2574                                 dtLoad.Rows[4].RowState);
2575                         // asserting Added Row3
2576                         AssertEquals ("RowData3-C", "mono 4",
2577                                 dtLoad.Rows[3][1, DataRowVersion.Current]);
2578                         AssertEquals ("RowState3", DataRowState.Added,
2579                                 dtLoad.Rows[3].RowState);
2580                         // asserting Unpresent Row5
2581                         // Notice row4 is used for added row of deleted row2 and so
2582                         // unpresent row4 moves to row5
2583                         AssertEquals ("RowData5-C", "mono 5",
2584                                 dtLoad.Rows[5][1, DataRowVersion.Current]);
2585                         AssertEquals ("RowState5", DataRowState.Added,
2586                                 dtLoad.Rows[5].RowState);
2587                 }
2588
2589                 [Test]
2590                 public void Load_RowStateUpsertDuplicateKey1 () {
2591                         localSetup ();
2592                         dt.Rows.Add (new object[] { 4, "mono 4" });
2593                         DataTable dtLoad = new DataTable ("LoadRowStateChanges");
2594                         dtLoad.Columns.Add ("id", typeof (int));
2595                         dtLoad.Columns.Add ("name", typeof (string));
2596                         dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2597                         dtLoad.Rows.Add (new object[] { 1, "RowState 1" });
2598                         dtLoad.Rows.Add (new object[] { 2, "RowState 2" });
2599                         dtLoad.Rows.Add (new object[] { 3, "RowState 3" });
2600                         dtLoad.AcceptChanges ();
2601                         dtLoad.Rows[2].Delete ();
2602                         DataTableReader dtr = dt.CreateDataReader ();
2603                         dtLoad.Load (dtr, LoadOption.Upsert);
2604                         dtLoad.Rows[3][1] = "NEWVAL";
2605                         AssertEquals ("A-RowState2", DataRowState.Deleted,
2606                                 dtLoad.Rows[2].RowState);
2607                         AssertEquals ("A-RowData2-id", 3,
2608                                 dtLoad.Rows[2][0, DataRowVersion.Original]);
2609                         AssertEquals ("A-RowData2-name", "RowState 3",
2610                                 dtLoad.Rows[2][1, DataRowVersion.Original]);
2611                         AssertEquals ("A-RowState3", DataRowState.Added,
2612                                 dtLoad.Rows[3].RowState);
2613                         AssertEquals ("A-RowData3-id", 3,
2614                                 dtLoad.Rows[3][0, DataRowVersion.Current]);
2615                         AssertEquals ("A-RowData3-name", "NEWVAL",
2616                                 dtLoad.Rows[3][1, DataRowVersion.Current]);
2617                         AssertEquals ("A-RowState4", DataRowState.Added,
2618                                 dtLoad.Rows[4].RowState);
2619                         AssertEquals ("A-RowData4-id", 4,
2620                                 dtLoad.Rows[4][0, DataRowVersion.Current]);
2621                         AssertEquals ("A-RowData4-name", "mono 4",
2622                                 dtLoad.Rows[4][1, DataRowVersion.Current]);
2623
2624                         dtLoad.AcceptChanges ();
2625
2626                         AssertEquals ("B-RowState2", DataRowState.Unchanged,
2627                                 dtLoad.Rows[2].RowState);
2628                         AssertEquals ("B-RowData2-id", 3,
2629                                 dtLoad.Rows[2][0, DataRowVersion.Current]);
2630                         AssertEquals ("B-RowData2-name", "NEWVAL",
2631                                 dtLoad.Rows[2][1, DataRowVersion.Current]);
2632                         AssertEquals ("B-RowState3", DataRowState.Unchanged,
2633                                 dtLoad.Rows[3].RowState);
2634                         AssertEquals ("B-RowData3-id", 4,
2635                                 dtLoad.Rows[3][0, DataRowVersion.Current]);
2636                         AssertEquals ("B-RowData3-name", "mono 4",
2637                                 dtLoad.Rows[3][1, DataRowVersion.Current]);
2638                 }
2639
2640                 [Test]
2641                 [ExpectedException (typeof (IndexOutOfRangeException))]
2642                 public void Load_RowStateUpsertDuplicateKey2 () {
2643                         localSetup ();
2644                         dt.Rows.Add (new object[] { 4, "mono 4" });
2645                         DataTable dtLoad = new DataTable ("LoadRowStateChanges");
2646                         dtLoad.Columns.Add ("id", typeof (int));
2647                         dtLoad.Columns.Add ("name", typeof (string));
2648                         dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2649                         dtLoad.Rows.Add (new object[] { 1, "RowState 1" });
2650                         dtLoad.Rows.Add (new object[] { 2, "RowState 2" });
2651                         dtLoad.Rows.Add (new object[] { 3, "RowState 3" });
2652                         dtLoad.AcceptChanges ();
2653                         dtLoad.Rows[2].Delete ();
2654                         DataTableReader dtr = dt.CreateDataReader ();
2655                         dtLoad.Load (dtr, LoadOption.Upsert);
2656                         dtLoad.AcceptChanges ();
2657                         AssertEquals ("RowData4", " ", dtLoad.Rows[4][1]);
2658                 }
2659
2660                 [Test]
2661                 [ExpectedException (typeof (VersionNotFoundException))]
2662                 public void Load_RowStateUpsertDelete1 () {
2663                         localSetup ();
2664                         DataTable dtLoad = new DataTable ("LoadRowStateChanges");
2665                         dtLoad.Columns.Add ("id", typeof (int));
2666                         dtLoad.Columns.Add ("name", typeof (string));
2667                         dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2668                         dtLoad.Rows.Add (new object[] { 1, "RowState 1" });
2669                         dtLoad.Rows.Add (new object[] { 2, "RowState 2" });
2670                         dtLoad.Rows.Add (new object[] { 3, "RowState 3" });
2671                         dtLoad.AcceptChanges ();
2672                         dtLoad.Rows[2].Delete ();
2673                         DataTableReader dtr = dt.CreateDataReader ();
2674                         dtLoad.Load (dtr, LoadOption.Upsert);
2675                         AssertEquals ("RowData2-C", " ",
2676                                 dtLoad.Rows[2][1, DataRowVersion.Current]);
2677                 }
2678
2679                 [Test]
2680                 [ExpectedException (typeof (VersionNotFoundException))]
2681                 public void Load_RowStateUpsertDelete2 () {
2682                         localSetup ();
2683                         DataTable dtLoad = new DataTable ("LoadRowStateChanges");
2684                         dtLoad.Columns.Add ("id", typeof (int));
2685                         dtLoad.Columns.Add ("name", typeof (string));
2686                         dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2687                         dtLoad.Rows.Add (new object[] { 1, "RowState 1" });
2688                         dtLoad.Rows.Add (new object[] { 2, "RowState 2" });
2689                         dtLoad.Rows.Add (new object[] { 3, "RowState 3" });
2690                         dtLoad.AcceptChanges ();
2691                         dtLoad.Rows[2].Delete ();
2692                         DataTableReader dtr = dt.CreateDataReader ();
2693                         dtLoad.Load (dtr, LoadOption.Upsert);
2694                         AssertEquals ("RowData3-O", " ",
2695                                 dtLoad.Rows[3][1, DataRowVersion.Original]);
2696                 }
2697
2698                 [Test]
2699                 [ExpectedException (typeof (VersionNotFoundException))]
2700                 public void Load_RowStateUpsertAdd () {
2701                         localSetup ();
2702                         dt.Rows.Add (new object[] { 4, "mono 4" });
2703                         DataTable dtLoad = new DataTable ("LoadRowStateChanges");
2704                         dtLoad.Columns.Add ("id", typeof (int));
2705                         dtLoad.Columns.Add ("name", typeof (string));
2706                         dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2707                         dtLoad.Rows.Add (new object[] { 1, "RowState 1" });
2708                         dtLoad.Rows.Add (new object[] { 2, "RowState 2" });
2709                         dtLoad.Rows.Add (new object[] { 3, "RowState 3" });
2710                         dtLoad.AcceptChanges ();
2711                         DataRow row = dtLoad.NewRow ();
2712                         row["id"] = 4;
2713                         row["name"] = "Add 4";
2714                         dtLoad.Rows.Add (row);
2715                         DataTableReader dtr = dt.CreateDataReader ();
2716                         dtLoad.Load (dtr, LoadOption.Upsert);
2717                         AssertEquals ("RowData3-O", " ",
2718                                 dtLoad.Rows[3][1, DataRowVersion.Original]);
2719                 }
2720
2721                 [Test]
2722                 [ExpectedException (typeof (VersionNotFoundException))]
2723                 public void Load_RowStateUpsertUnpresent () {
2724                         localSetup ();
2725                         dt.Rows.Add (new object[] { 4, "mono 4" });
2726                         DataTable dtLoad = new DataTable ("LoadRowStateChanges");
2727                         dtLoad.Columns.Add ("id", typeof (int));
2728                         dtLoad.Columns.Add ("name", typeof (string));
2729                         dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2730                         dtLoad.Rows.Add (new object[] { 1, "RowState 1" });
2731                         dtLoad.Rows.Add (new object[] { 2, "RowState 2" });
2732                         dtLoad.Rows.Add (new object[] { 3, "RowState 3" });
2733                         dtLoad.AcceptChanges ();
2734                         DataTableReader dtr = dt.CreateDataReader ();
2735                         dtLoad.Load (dtr, LoadOption.Upsert);
2736                         AssertEquals ("RowData3-O", " ",
2737                                 dtLoad.Rows[3][1, DataRowVersion.Original]);
2738                 }
2739
2740                 [Test]
2741                 public void Load_RowStateUpsertUnchangedEqualVal () {
2742                         localSetup ();
2743                         DataTable dtLoad = new DataTable ("LoadRowStateChanges");
2744                         dtLoad.Columns.Add ("id", typeof (int));
2745                         dtLoad.Columns.Add ("name", typeof (string));
2746                         dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2747                         dtLoad.Rows.Add (new object[] { 1, "mono 1" });
2748                         dtLoad.AcceptChanges ();
2749                         DataTableReader dtr = dt.CreateDataReader ();
2750                         DataRowAction[] dra = new DataRowAction[] {
2751                                 DataRowAction.Nothing,// REAL action
2752                                 DataRowAction.Nothing,// dummy
2753                                 DataRowAction.Nothing,// dummy
2754                                 DataRowAction.Nothing,// dummy
2755                                 DataRowAction.Nothing};// dummy
2756                         rowActionInit (dra);
2757                         dtLoad.Load (dtr, LoadOption.Upsert);
2758                         rowActionEnd ();
2759                         AssertEquals ("RowData0-C", "mono 1",
2760                                 dtLoad.Rows[0][1, DataRowVersion.Current]);
2761                         AssertEquals ("RowData0-O", "mono 1",
2762                                 dtLoad.Rows[0][1, DataRowVersion.Original]);
2763                         AssertEquals ("RowState0", DataRowState.Unchanged,
2764                                 dtLoad.Rows[0].RowState);
2765                 }
2766
2767                 [Test]
2768                 public void LoadDataRow_LoadOptions () {
2769                         // LoadDataRow is covered in detail (without LoadOptions) in DataTableTest2
2770                         // LoadOption tests are covered in detail in DataTable.Load().
2771                         // Therefore only minimal tests of LoadDataRow with LoadOptions are covered here.
2772                         DataTable dt;
2773                         DataRow dr;
2774                         dt = CreateDataTableExample ();
2775                         dt.PrimaryKey = new DataColumn[] { dt.Columns[0] };     //add ParentId as Primary Key
2776                         dt.Columns["String1"].DefaultValue = "Default";
2777
2778                         dr = dt.Select ("ParentId=1")[0];
2779
2780                         //Update existing row with LoadOptions = OverwriteChanges
2781                         dt.BeginLoadData ();
2782                         dt.LoadDataRow (new object[] { 1, null, "Changed" },
2783                                 LoadOption.OverwriteChanges);
2784                         dt.EndLoadData ();
2785
2786                         // LoadDataRow(update1) - check column String2
2787                         AssertEquals ("DT72-C", "Changed",
2788                                 dr["String2", DataRowVersion.Current]);
2789                         AssertEquals ("DT72-O", "Changed",
2790                                 dr["String2", DataRowVersion.Original]);
2791
2792                         // LoadDataRow(update1) - check row state
2793                         AssertEquals ("DT73-LO", DataRowState.Unchanged, dr.RowState);
2794
2795                         //Add New row with LoadOptions = Upsert
2796                         dt.BeginLoadData ();
2797                         dt.LoadDataRow (new object[] { 99, null, "Changed" },
2798                                 LoadOption.Upsert);
2799                         dt.EndLoadData ();
2800
2801                         // LoadDataRow(insert1) - check column String2
2802                         dr = dt.Select ("ParentId=99")[0];
2803                         AssertEquals ("DT75-C", "Changed",
2804                                 dr["String2", DataRowVersion.Current]);
2805
2806                         // LoadDataRow(insert1) - check row state
2807                         AssertEquals ("DT76-LO", DataRowState.Added, dr.RowState);
2808                 }
2809
2810                 public static DataTable CreateDataTableExample () {
2811                         DataTable dtParent = new DataTable ("Parent");
2812
2813                         dtParent.Columns.Add ("ParentId", typeof (int));
2814                         dtParent.Columns.Add ("String1", typeof (string));
2815                         dtParent.Columns.Add ("String2", typeof (string));
2816
2817                         dtParent.Columns.Add ("ParentDateTime", typeof (DateTime));
2818                         dtParent.Columns.Add ("ParentDouble", typeof (double));
2819                         dtParent.Columns.Add ("ParentBool", typeof (bool));
2820
2821                         dtParent.Rows.Add (new object[] { 1, "1-String1", "1-String2", new DateTime (2005, 1, 1, 0, 0, 0, 0), 1.534, true });
2822                         dtParent.Rows.Add (new object[] { 2, "2-String1", "2-String2", new DateTime (2004, 1, 1, 0, 0, 0, 1), -1.534, true });
2823                         dtParent.Rows.Add (new object[] { 3, "3-String1", "3-String2", new DateTime (2003, 1, 1, 0, 0, 1, 0), double.MinValue * 10000, false });
2824                         dtParent.Rows.Add (new object[] { 4, "4-String1", "4-String2", new DateTime (2002, 1, 1, 0, 1, 0, 0), double.MaxValue / 10000, true });
2825                         dtParent.Rows.Add (new object[] { 5, "5-String1", "5-String2", new DateTime (2001, 1, 1, 1, 0, 0, 0), 0.755, true });
2826                         dtParent.Rows.Add (new object[] { 6, "6-String1", "6-String2", new DateTime (2000, 1, 1, 0, 0, 0, 0), 0.001, false });
2827                         dtParent.AcceptChanges ();
2828                         return dtParent;
2829                 }
2830
2831                 #endregion // DataTable.Load Tests
2832
2833                 #region Read/Write XML Tests
2834
2835                 [Test]
2836                 //[Category ("NotWorking")]
2837                 public void ReadXmlSchema () {
2838                         DataTable Table = new DataTable ();
2839                         Table.ReadXmlSchema ("Test/System.Data/own_schema1.xsd");
2840
2841                         AssertEquals ("test#02", "test_table", Table.TableName);
2842                         AssertEquals ("test#03", "", Table.Namespace);
2843                         AssertEquals ("test#04", 2, Table.Columns.Count);
2844                         AssertEquals ("test#05", 0, Table.Rows.Count);
2845                         AssertEquals ("test#06", false, Table.CaseSensitive);
2846                         AssertEquals ("test#07", 1, Table.Constraints.Count);
2847                         AssertEquals ("test#08", "", Table.Prefix);
2848
2849                         Constraint cons = Table.Constraints[0];
2850                         AssertEquals ("test#09", "Constraint1", cons.ConstraintName.ToString ());
2851                         AssertEquals ("test#10", "Constraint1", cons.ToString ());
2852
2853                         DataColumn column = Table.Columns[0];
2854                         AssertEquals ("test#11", true, column.AllowDBNull);
2855                         AssertEquals ("test#12", false, column.AutoIncrement);
2856                         AssertEquals ("test#13", 0L, column.AutoIncrementSeed);
2857                         AssertEquals ("test#14", 1L, column.AutoIncrementStep);
2858                         AssertEquals ("test#15", "test", column.Caption);
2859                         AssertEquals ("test#16", "Element", column.ColumnMapping.ToString ());
2860                         AssertEquals ("test#17", "first", column.ColumnName);
2861                         AssertEquals ("test#18", "System.String", column.DataType.ToString ());
2862                         AssertEquals ("test#19", "test_default_value", column.DefaultValue.ToString ());
2863                         AssertEquals ("test#20", false, column.DesignMode);
2864                         AssertEquals ("test#21", "", column.Expression);
2865                         AssertEquals ("test#22", 100, column.MaxLength);
2866                         AssertEquals ("test#23", "", column.Namespace);
2867                         AssertEquals ("test#24", 0, column.Ordinal);
2868                         AssertEquals ("test#25", "", column.Prefix);
2869                         AssertEquals ("test#26", false, column.ReadOnly);
2870                         AssertEquals ("test#27", true, column.Unique);
2871
2872                         DataColumn column2 = Table.Columns[1];
2873                         AssertEquals ("test#28", true, column2.AllowDBNull);
2874                         AssertEquals ("test#29", false, column2.AutoIncrement);
2875                         AssertEquals ("test#30", 0L, column2.AutoIncrementSeed);
2876                         AssertEquals ("test#31", 1L, column2.AutoIncrementStep);
2877                         AssertEquals ("test#32", "second", column2.Caption);
2878                         AssertEquals ("test#33", "Element", column2.ColumnMapping.ToString ());
2879                         AssertEquals ("test#34", "second", column2.ColumnName);
2880                         AssertEquals ("test#35", "System.Data.SqlTypes.SqlGuid", column2.DataType.ToString ());
2881                         AssertEquals ("test#36", "Null", column2.DefaultValue.ToString ());
2882                         AssertEquals ("test#37", false, column2.DesignMode);
2883                         AssertEquals ("test#38", "", column2.Expression);
2884                         AssertEquals ("test#39", -1, column2.MaxLength);
2885                         AssertEquals ("test#40", "", column2.Namespace);
2886                         AssertEquals ("test#41", 1, column2.Ordinal);
2887                         AssertEquals ("test#42", "", column2.Prefix);
2888                         AssertEquals ("test#43", false, column2.ReadOnly);
2889                         AssertEquals ("test#44", false, column2.Unique);
2890
2891                         DataTable Table2 = new DataTable ();
2892                         Table2.ReadXmlSchema ("Test/System.Data/own_schema2.xsd");
2893
2894                         AssertEquals ("test#45", "second_test_table", Table2.TableName);
2895                         AssertEquals ("test#46", "", Table2.Namespace);
2896                         AssertEquals ("test#47", 1, Table2.Columns.Count);
2897                         AssertEquals ("test#48", 0, Table2.Rows.Count);
2898                         AssertEquals ("test#49", false, Table2.CaseSensitive);
2899                         AssertEquals ("test#50", 1, Table2.Constraints.Count);
2900                         AssertEquals ("test#51", "", Table2.Prefix);
2901
2902                         DataColumn column3 = Table2.Columns[0];
2903                         AssertEquals ("test#52", true, column3.AllowDBNull);
2904                         AssertEquals ("test#53", false, column3.AutoIncrement);
2905                         AssertEquals ("test#54", 0L, column3.AutoIncrementSeed);
2906                         AssertEquals ("test#55", 1L, column3.AutoIncrementStep);
2907                         AssertEquals ("test#56", "second_first", column3.Caption);
2908                         AssertEquals ("test#57", "Element", column3.ColumnMapping.ToString ());
2909                         AssertEquals ("test#58", "second_first", column3.ColumnName);
2910                         AssertEquals ("test#59", "System.String", column3.DataType.ToString ());
2911                         AssertEquals ("test#60", "default_value", column3.DefaultValue.ToString ());
2912                         AssertEquals ("test#61", false, column3.DesignMode);
2913                         AssertEquals ("test#62", "", column3.Expression);
2914                         AssertEquals ("test#63", 100, column3.MaxLength);
2915                         AssertEquals ("test#64", "", column3.Namespace);
2916                         AssertEquals ("test#65", 0, column3.Ordinal);
2917                         AssertEquals ("test#66", "", column3.Prefix);
2918                         AssertEquals ("test#67", false, column3.ReadOnly);
2919                         AssertEquals ("test#68", true, column3.Unique);
2920                 }
2921
2922                 [Test]
2923                 public void ReadXmlSchema_2 () {
2924                         DataTable dt = new DataTable ();
2925                         string xmlData = string.Empty;
2926                         xmlData += "<?xml version=\"1.0\"?>";
2927                         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\">";
2928                         xmlData += "<xs:element name=\"SiteConfiguration\" msdata:IsDataSet=\"true\" msdata:EnforceConstraints=\"False\">";
2929                         xmlData += "<xs:complexType>";
2930                         xmlData += "<xs:choice  minOccurs=\"0\" maxOccurs=\"unbounded\">";
2931                         xmlData += "<xs:element name=\"Tab\">";
2932                         xmlData += "<xs:complexType>";
2933                         xmlData += "<xs:sequence>";
2934                         xmlData += "<xs:element name=\"Module\" minOccurs=\"0\" maxOccurs=\"unbounded\">";
2935                         xmlData += "<xs:complexType>";
2936                         xmlData += "<xs:attribute name=\"ModuleId\" form=\"unqualified\" type=\"xs:int\" />";
2937                         xmlData += "</xs:complexType>";
2938                         xmlData += "</xs:element>";
2939                         xmlData += "</xs:sequence>";
2940                         xmlData += "<xs:attribute name=\"TabId\" form=\"unqualified\" type=\"xs:int\" />";
2941                         xmlData += "</xs:complexType>";
2942                         xmlData += "</xs:element>";
2943                         xmlData += "</xs:choice>";
2944                         xmlData += "</xs:complexType>";
2945                         xmlData += "<xs:key name=\"TabKey\" msdata:PrimaryKey=\"true\">";
2946                         xmlData += "<xs:selector xpath=\".//mstns:Tab\" />";
2947                         xmlData += "<xs:field xpath=\"@TabId\" />";
2948                         xmlData += "</xs:key>";
2949                         xmlData += "<xs:key name=\"ModuleKey\" msdata:PrimaryKey=\"true\">";
2950                         xmlData += "<xs:selector xpath=\".//mstns:Module\" />";
2951                         xmlData += "<xs:field xpath=\"@ModuleID\" />";
2952                         xmlData += "</xs:key>";
2953                         xmlData += "</xs:element>";
2954                         xmlData += "</xs:schema>";
2955                         dt.ReadXmlSchema (new StringReader (xmlData));
2956                 }
2957
2958                 [Test]
2959                 public void ReadXmlSchema_ByStream () {
2960                         DataSet ds1 = new DataSet ();
2961                         ds1.Tables.Add (DataProvider.CreateParentDataTable ());
2962                         ds1.Tables.Add (DataProvider.CreateChildDataTable ());
2963
2964                         MemoryStream ms1 = new MemoryStream ();
2965                         MemoryStream ms2 = new MemoryStream ();
2966                         //write xml  schema only
2967                         //ds1.WriteXmlSchema (ms);
2968                         ds1.Tables[0].WriteXmlSchema (ms1);
2969                         ds1.Tables[1].WriteXmlSchema (ms2);
2970
2971                         MemoryStream ms11 = new MemoryStream (ms1.GetBuffer ());
2972                         MemoryStream ms22 = new MemoryStream (ms2.GetBuffer ());
2973                         //copy schema
2974                         //DataSet ds2 = new DataSet ();
2975                         DataTable dt1 = new DataTable ();
2976                         DataTable dt2 = new DataTable ();
2977
2978                         //ds2.ReadXmlSchema (ms1);
2979                         dt1.ReadXmlSchema (ms11);
2980                         dt2.ReadXmlSchema (ms22);
2981
2982                         //check xml schema
2983                         // ReadXmlSchema - Tables count
2984                         //Assert.AreEqual (ds2.Tables.Count, ds1.Tables.Count, "DS269");
2985
2986                         // ReadXmlSchema - Tables 0 Col count
2987                         AssertEquals ("DS270", ds1.Tables[0].Columns.Count, dt1.Columns.Count);
2988
2989                         // ReadXmlSchema - Tables 1 Col count
2990                         AssertEquals ("DS271", ds1.Tables[1].Columns.Count, dt2.Columns.Count);
2991
2992                         //check some colummns types
2993                         // ReadXmlSchema - Tables 0 Col type
2994                         AssertEquals ("DS272", ds1.Tables[0].Columns[0].GetType (), dt1.Columns[0].GetType ());
2995
2996                         // ReadXmlSchema - Tables 1 Col type
2997                         AssertEquals ("DS273", ds1.Tables[1].Columns[3].GetType (), dt2.Columns[3].GetType ());
2998
2999                         //check that no data exists
3000                         // ReadXmlSchema - Table 1 row count
3001                         AssertEquals ("DS274",0, dt1.Rows.Count);
3002
3003                         // ReadXmlSchema - Table 2 row count
3004                         AssertEquals ("DS275",0, dt2.Rows.Count);
3005                 }
3006
3007                 [Test]
3008                 public void ReadWriteXmlSchema_ByFileName () {
3009                         string sTempFileName1 = "tmpDataSet_ReadWriteXml_43899-1.xml";
3010                         string sTempFileName2 = "tmpDataSet_ReadWriteXml_43899-2.xml";
3011
3012                         DataSet ds1 = new DataSet ();
3013                         ds1.Tables.Add (DataProvider.CreateParentDataTable ());
3014                         ds1.Tables.Add (DataProvider.CreateChildDataTable ());
3015
3016                         ds1.Tables[0].WriteXmlSchema (sTempFileName1);
3017                         ds1.Tables[1].WriteXmlSchema (sTempFileName2);
3018
3019                         DataTable dt1 = new DataTable ();
3020                         DataTable dt2 = new DataTable ();
3021
3022                         dt1.ReadXmlSchema (sTempFileName1);
3023                         dt2.ReadXmlSchema (sTempFileName2);
3024
3025                         AssertEquals ("DS277", ds1.Tables[0].Columns.Count, dt1.Columns.Count);
3026                         AssertEquals ("DS278", ds1.Tables[1].Columns.Count, dt2.Columns.Count);
3027                         AssertEquals ("DS279", ds1.Tables[0].Columns[0].GetType (), dt1.Columns[0].GetType ());
3028                         AssertEquals ("DS280", ds1.Tables[1].Columns[3].GetType (), dt2.Columns[3].GetType ());
3029                         AssertEquals ("DS281", 0, dt1.Rows.Count);
3030                         AssertEquals ("DS282", 0, dt2.Rows.Count);
3031
3032                         File.Delete (sTempFileName1);
3033                         File.Delete (sTempFileName2);
3034                 }
3035
3036                 [Test]
3037                 public void ReadXmlSchema_ByTextReader () {
3038                         DataSet ds1 = new DataSet ();
3039                         ds1.Tables.Add (DataProvider.CreateParentDataTable ());
3040                         ds1.Tables.Add (DataProvider.CreateChildDataTable ());
3041
3042                         StringWriter sw1 = new StringWriter ();
3043                         StringWriter sw2 = new StringWriter ();
3044                         //write xml file, schema only
3045                         //ds1.WriteXmlSchema (sw);
3046                         ds1.Tables[0].WriteXmlSchema (sw1);
3047                         ds1.Tables[1].WriteXmlSchema (sw2);
3048
3049                         StringReader sr1 = new StringReader (sw1.GetStringBuilder ().ToString ());
3050                         StringReader sr2 = new StringReader (sw2.GetStringBuilder ().ToString ());
3051                         //copy both data and schema
3052                         //DataSet ds2 = new DataSet ();
3053                         DataTable dt1 = new DataTable ();
3054                         DataTable dt2 = new DataTable ();
3055
3056                         //ds2.ReadXmlSchema (sr);
3057                         dt1.ReadXmlSchema (sr1);
3058                         dt2.ReadXmlSchema (sr2);
3059
3060                         //check xml schema
3061                         // ReadXmlSchema - Tables count
3062                         //Assert.AreEqual (ds2.Tables.Count, ds1.Tables.Count, "DS283");
3063
3064                         // ReadXmlSchema - Tables 0 Col count
3065                         AssertEquals ("DS284", ds1.Tables[0].Columns.Count, dt1.Columns.Count);
3066
3067                         // ReadXmlSchema - Tables 1 Col count
3068                         AssertEquals ("DS285", ds1.Tables[1].Columns.Count, dt2.Columns.Count);
3069
3070                         //check some colummns types
3071                         // ReadXmlSchema - Tables 0 Col type
3072                         AssertEquals ("DS286", ds1.Tables[0].Columns[0].GetType (), dt1.Columns[0].GetType ());
3073
3074                         // ReadXmlSchema - Tables 1 Col type
3075                         AssertEquals ("DS287", ds1.Tables[1].Columns[3].GetType (), dt2.Columns[3].GetType ());
3076
3077                         //check that no data exists
3078                         // ReadXmlSchema - Table 1 row count
3079                         AssertEquals ("DS288", 0, dt1.Rows.Count);
3080
3081                         // ReadXmlSchema - Table 2 row count
3082                         AssertEquals ("DS289", 0, dt2.Rows.Count);
3083                 }
3084
3085                 [Test]
3086                 public void ReadXmlSchema_ByXmlReader () {
3087                         DataSet ds1 = new DataSet ();
3088                         ds1.Tables.Add (DataProvider.CreateParentDataTable ());
3089                         ds1.Tables.Add (DataProvider.CreateChildDataTable ());
3090
3091                         StringWriter sw1 = new StringWriter ();
3092                         XmlTextWriter xmlTW1 = new XmlTextWriter (sw1);
3093                         StringWriter sw2 = new StringWriter ();
3094                         XmlTextWriter xmlTW2 = new XmlTextWriter (sw2);
3095
3096                         //write xml file, schema only
3097                         ds1.Tables[0].WriteXmlSchema (xmlTW1);
3098                         xmlTW1.Flush ();
3099                         ds1.Tables[1].WriteXmlSchema (xmlTW2);
3100                         xmlTW2.Flush ();
3101
3102                         StringReader sr1 = new StringReader (sw1.ToString ());
3103                         XmlTextReader xmlTR1 = new XmlTextReader (sr1);
3104                         StringReader sr2 = new StringReader (sw2.ToString ());
3105                         XmlTextReader xmlTR2 = new XmlTextReader (sr2);
3106
3107                         //copy both data and schema
3108                         //DataSet ds2 = new DataSet ();
3109                         DataTable dt1 = new DataTable ();
3110                         DataTable dt2 = new DataTable ();
3111
3112                         //ds2.ReadXmlSchema (xmlTR);
3113                         dt1.ReadXmlSchema (xmlTR1);
3114                         dt2.ReadXmlSchema (xmlTR2);
3115
3116                         //check xml schema
3117                         // ReadXmlSchema - Tables count
3118                         //Assert.AreEqual (ds2.Tables.Count, ds1.Tables.Count, "DS290");
3119
3120                         // ReadXmlSchema - Tables 0 Col count
3121                         AssertEquals ("DS291", ds1.Tables[0].Columns.Count, dt1.Columns.Count);
3122
3123                         // ReadXmlSchema - Tables 1 Col count
3124                         AssertEquals ("DS292", ds1.Tables[1].Columns.Count, dt2.Columns.Count);
3125
3126                         //check some colummns types
3127                         // ReadXmlSchema - Tables 0 Col type
3128                         AssertEquals ("DS293", ds1.Tables[0].Columns[0].GetType (), dt1.Columns[0].GetType ());
3129
3130                         // ReadXmlSchema - Tables 1 Col type
3131                         AssertEquals ("DS294", ds1.Tables[1].Columns[3].GetType (), dt2.Columns[3].GetType ());
3132
3133                         //check that no data exists
3134                         // ReadXmlSchema - Table 1 row count
3135                         AssertEquals ("DS295", 0, dt1.Rows.Count);
3136
3137                         // ReadXmlSchema - Table 2 row count
3138                         AssertEquals ("DS296", 0, dt2.Rows.Count);
3139                 }
3140
3141                 [Test]
3142                 public void WriteXmlSchema () {
3143                         DataSet ds = new DataSet ();
3144                         ds.ReadXml ("Test/System.Data/region.xml");
3145                         TextWriter writer = new StringWriter ();
3146                         ds.Tables[0].WriteXmlSchema (writer);
3147
3148
3149                         string TextString = GetNormalizedSchema (writer.ToString ());
3150                         //string TextString = writer.ToString ();
3151
3152                         string substring = TextString.Substring (0, TextString.IndexOf (EOL));
3153                         TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3154                         AssertEquals ("test#01", "<?xml version=\"1.0\" encoding=\"utf-16\"?>", substring);
3155
3156                         substring = TextString.Substring (0, TextString.IndexOf (EOL));
3157                         TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3158                         AssertEquals ("test#02", "<xs:schema id=\"Root\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">", substring);
3159
3160                         substring = TextString.Substring (0, TextString.IndexOf (EOL));
3161                         TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3162                         AssertEquals ("test#03", "  <xs:element msdata:IsDataSet=\"true\" msdata:MainDataTable=\"Region\" msdata:UseCurrentLocale=\"true\" name=\"Root\">", substring);
3163
3164                         substring = TextString.Substring (0, TextString.IndexOf (EOL));
3165                         TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3166                         AssertEquals ("test#04", "    <xs:complexType>", substring);
3167
3168                         substring = TextString.Substring (0, TextString.IndexOf (EOL));
3169                         TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3170                         AssertEquals ("test#05", "      <xs:choice maxOccurs=\"unbounded\" minOccurs=\"0\">", substring);
3171
3172                         substring = TextString.Substring (0, TextString.IndexOf (EOL));
3173                         TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3174                         AssertEquals ("test#06", "        <xs:element name=\"Region\">", substring);
3175
3176                         substring = TextString.Substring (0, TextString.IndexOf (EOL));
3177                         TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3178                         AssertEquals ("test#07", "          <xs:complexType>", substring);
3179
3180                         substring = TextString.Substring (0, TextString.IndexOf (EOL));
3181                         TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3182                         AssertEquals ("test#08", "            <xs:sequence>", substring);
3183
3184                         substring = TextString.Substring (0, TextString.IndexOf (EOL));
3185                         TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3186                         AssertEquals ("test#09", "              <xs:element minOccurs=\"0\" name=\"RegionID\" type=\"xs:string\" />", substring);
3187
3188                         substring = TextString.Substring (0, TextString.IndexOf (EOL));
3189                         TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3190                         AssertEquals ("test#10", "              <xs:element minOccurs=\"0\" name=\"RegionDescription\" type=\"xs:string\" />", substring);
3191
3192                         substring = TextString.Substring (0, TextString.IndexOf (EOL));
3193                         TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3194                         AssertEquals ("test#11", "            </xs:sequence>", substring);
3195
3196                         substring = TextString.Substring (0, TextString.IndexOf (EOL));
3197                         TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3198                         AssertEquals ("test#12", "          </xs:complexType>", substring);
3199
3200                         substring = TextString.Substring (0, TextString.IndexOf (EOL));
3201                         TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3202                         AssertEquals ("test#13", "        </xs:element>", substring);
3203
3204                         substring = TextString.Substring (0, TextString.IndexOf (EOL));
3205                         TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3206                         AssertEquals ("test#14", "      </xs:choice>", substring);
3207
3208                         substring = TextString.Substring (0, TextString.IndexOf (EOL));
3209                         TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3210                         AssertEquals ("test#15", "    </xs:complexType>", substring);
3211
3212                         substring = TextString.Substring (0, TextString.IndexOf (EOL));
3213                         TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3214                         AssertEquals ("test#16", "  </xs:element>", substring);
3215
3216                         AssertEquals ("test#17", "</xs:schema>", TextString);
3217                 }
3218
3219                 [Test]
3220                 public void WriteXmlSchema2 () {
3221                         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>";
3222                         string schema = @"<?xml version='1.0' encoding='utf-16'?>
3223 <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'>
3224   <xs:element name='myDataSet' msdata:IsDataSet='true' msdata:MainDataTable='NetFrameWork_x003A_myTable' msdata:UseCurrentLocale='true'>
3225     <xs:complexType>
3226       <xs:choice minOccurs='0' maxOccurs='unbounded'>
3227         <xs:element name='myTable'>
3228           <xs:complexType>
3229             <xs:sequence>
3230               <xs:element name='id' msdata:AutoIncrement='true' type='xs:int' minOccurs='0' />
3231               <xs:element name='item' type='xs:string' minOccurs='0' />
3232             </xs:sequence>
3233           </xs:complexType>
3234         </xs:element>
3235       </xs:choice>
3236     </xs:complexType>
3237   </xs:element>
3238 </xs:schema>";
3239                         DataSet OriginalDataSet = new DataSet ("myDataSet");
3240                         OriginalDataSet.Namespace = "NetFrameWork";
3241                         DataTable myTable = new DataTable ("myTable");
3242                         DataColumn c1 = new DataColumn ("id", typeof (int));
3243                         c1.AutoIncrement = true;
3244                         DataColumn c2 = new DataColumn ("item");
3245                         myTable.Columns.Add (c1);
3246                         myTable.Columns.Add (c2);
3247                         OriginalDataSet.Tables.Add (myTable);
3248                         // Add ten rows.
3249                         DataRow newRow;
3250                         for (int i = 0; i < 10; i++) {
3251                                 newRow = myTable.NewRow ();
3252                                 newRow["item"] = "item " + i;
3253                                 myTable.Rows.Add (newRow);
3254                         }
3255                         OriginalDataSet.AcceptChanges ();
3256
3257                         StringWriter sw = new StringWriter ();
3258                         XmlTextWriter xtw = new XmlTextWriter (sw);
3259                         xtw.QuoteChar = '\'';
3260                         OriginalDataSet.WriteXml (xtw);
3261                         string result = sw.ToString ();
3262
3263                         AssertEquals (xml, result);
3264
3265                         sw = new StringWriter ();
3266                         xtw = new XmlTextWriter (sw);
3267                         xtw.Formatting = Formatting.Indented;
3268                         OriginalDataSet.Tables[0].WriteXmlSchema (xtw);
3269                         result = sw.ToString ();
3270
3271                         result = result.Replace ("\r\n", "\n").Replace ('"', '\'');
3272                         AssertEquals (schema.Replace ("\r\n", "\n"), result);
3273                 }
3274
3275                 [Test]
3276                 public void WriteXmlSchema3 () {
3277                         string xmlschema = @"<?xml version=""1.0"" encoding=""utf-16""?>
3278 <xs:schema id=""ExampleDataSet"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">
3279   <xs:element name=""ExampleDataSet"" msdata:IsDataSet=""true"" msdata:MainDataTable=""ExampleDataTable"" msdata:UseCurrentLocale=""true"">
3280     <xs:complexType>
3281       <xs:choice minOccurs=""0"" maxOccurs=""unbounded"">
3282         <xs:element name=""ExampleDataTable"">
3283           <xs:complexType>
3284             <xs:attribute name=""PrimaryKeyColumn"" type=""xs:int"" use=""required"" />
3285           </xs:complexType>
3286         </xs:element>
3287       </xs:choice>
3288     </xs:complexType>
3289     <xs:unique name=""PK_ExampleDataTable"" msdata:PrimaryKey=""true"">
3290       <xs:selector xpath="".//ExampleDataTable"" />
3291       <xs:field xpath=""@PrimaryKeyColumn"" />
3292     </xs:unique>
3293   </xs:element>
3294 </xs:schema>";
3295                         DataSet ds = new DataSet ("ExampleDataSet");
3296
3297                         ds.Tables.Add (new DataTable ("ExampleDataTable"));
3298                         ds.Tables["ExampleDataTable"].Columns.Add (
3299                                 new DataColumn ("PrimaryKeyColumn", typeof (int), "", MappingType.Attribute));
3300                         ds.Tables["ExampleDataTable"].Columns["PrimaryKeyColumn"].AllowDBNull = false;
3301
3302                         ds.Tables["ExampleDataTable"].Constraints.Add (
3303                                 "PK_ExampleDataTable",
3304                                 ds.Tables["ExampleDataTable"].Columns["PrimaryKeyColumn"],
3305                                 true);
3306
3307                         ds.AcceptChanges ();
3308                         StringWriter sw = new StringWriter ();
3309                         ds.Tables[0].WriteXmlSchema (sw);
3310
3311                         string result = sw.ToString ();
3312
3313                         AssertEquals (xmlschema.Replace ("\r\n", "\n"), result.Replace ("\r\n", "\n"));
3314                         //AssertEquals (xmlschema, result.Replace ("\r\n", "\n"));
3315                 }
3316
3317                 [Test]
3318                 public void WriteXmlSchema4 () {
3319                         string xmlschema = @"<?xml version=""1.0"" encoding=""utf-16""?>
3320 <xs:schema id=""Example"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">
3321   <xs:element name=""Example"" msdata:IsDataSet=""true"" msdata:MainDataTable=""MyType"" msdata:UseCurrentLocale=""true"">
3322     <xs:complexType>
3323       <xs:choice minOccurs=""0"" maxOccurs=""unbounded"">
3324         <xs:element name=""MyType"">
3325           <xs:complexType>
3326             <xs:attribute name=""ID"" type=""xs:int"" use=""required"" />
3327             <xs:attribute name=""Desc"" type=""xs:string"" />
3328           </xs:complexType>
3329         </xs:element>
3330       </xs:choice>
3331     </xs:complexType>
3332   </xs:element>
3333 </xs:schema>";
3334                         DataSet ds = new DataSet ("Example");
3335
3336                         // Add MyType DataTable
3337                         DataTable dt = new DataTable ("MyType");
3338                         ds.Tables.Add (dt);
3339
3340                         dt.Columns.Add (new DataColumn ("ID", typeof (int), "",
3341                                 MappingType.Attribute));
3342                         dt.Columns["ID"].AllowDBNull = false;
3343
3344                         dt.Columns.Add (new DataColumn ("Desc", typeof
3345                                 (string), "", MappingType.Attribute));
3346
3347                         ds.AcceptChanges ();
3348
3349                         StringWriter sw = new StringWriter ();
3350                         ds.Tables[0].WriteXmlSchema (sw);
3351
3352                         string result = sw.ToString ();
3353
3354                         AssertEquals (xmlschema.Replace ("\r\n", "\n"), result.Replace ("\r\n", "\n"));
3355                 }
3356
3357                 [Test]
3358                 public void WriteXmlSchema5 () {
3359                         string xmlschema1 = @"<?xml version=""1.0"" encoding=""utf-16""?>
3360 <xs:schema id=""Example"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">
3361   <xs:element name=""Example"" msdata:IsDataSet=""true"" msdata:MainDataTable=""StandAlone"" msdata:UseCurrentLocale=""true"">
3362     <xs:complexType>
3363       <xs:choice minOccurs=""0"" maxOccurs=""unbounded"">
3364         <xs:element name=""StandAlone"">
3365           <xs:complexType>
3366             <xs:attribute name=""ID"" type=""xs:int"" use=""required"" />
3367             <xs:attribute name=""Desc"" type=""xs:string"" use=""required"" />
3368           </xs:complexType>
3369         </xs:element>
3370       </xs:choice>
3371     </xs:complexType>
3372   </xs:element>
3373 </xs:schema>";
3374                         string xmlschema2 = @"<?xml version=""1.0"" encoding=""utf-16""?>
3375 <xs:schema id=""Example"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">
3376   <xs:element name=""Example"" msdata:IsDataSet=""true"" msdata:MainDataTable=""Dimension"" msdata:UseCurrentLocale=""true"">
3377     <xs:complexType>
3378       <xs:choice minOccurs=""0"" maxOccurs=""unbounded"">
3379         <xs:element name=""Dimension"">
3380           <xs:complexType>
3381             <xs:attribute name=""Number"" msdata:ReadOnly=""true"" type=""xs:int"" use=""required"" />
3382             <xs:attribute name=""Title"" type=""xs:string"" use=""required"" />
3383           </xs:complexType>
3384         </xs:element>
3385       </xs:choice>
3386     </xs:complexType>
3387     <xs:unique name=""PK_Dimension"" msdata:PrimaryKey=""true"">
3388       <xs:selector xpath="".//Dimension"" />
3389       <xs:field xpath=""@Number"" />
3390     </xs:unique>
3391   </xs:element>
3392 </xs:schema>";
3393                         string xmlschema3 = @"<?xml version=""1.0"" encoding=""utf-16""?>
3394 <xs:schema id=""Example"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">
3395   <xs:element name=""Example"" msdata:IsDataSet=""true"" msdata:MainDataTable=""Element"" msdata:UseCurrentLocale=""true"">
3396     <xs:complexType>
3397       <xs:choice minOccurs=""0"" maxOccurs=""unbounded"">
3398         <xs:element name=""Element"">
3399           <xs:complexType>
3400             <xs:attribute name=""Dimension"" msdata:ReadOnly=""true"" type=""xs:int"" use=""required"" />
3401             <xs:attribute name=""Number"" msdata:ReadOnly=""true"" type=""xs:int"" use=""required"" />
3402             <xs:attribute name=""Title"" type=""xs:string"" use=""required"" />
3403           </xs:complexType>
3404         </xs:element>
3405       </xs:choice>
3406     </xs:complexType>
3407     <xs:unique name=""PK_Element"" msdata:PrimaryKey=""true"">
3408       <xs:selector xpath="".//Element"" />
3409       <xs:field xpath=""@Dimension"" />
3410       <xs:field xpath=""@Number"" />
3411     </xs:unique>
3412   </xs:element>
3413 </xs:schema>";
3414                         DataSet ds = new DataSet ("Example");
3415
3416                         // Add a DataTable with no ReadOnly columns
3417                         DataTable dt1 = new DataTable ("StandAlone");
3418                         ds.Tables.Add (dt1);
3419
3420                         // Add a ReadOnly column
3421                         dt1.Columns.Add (new DataColumn ("ID", typeof (int), "",
3422                                 MappingType.Attribute));
3423                         dt1.Columns["ID"].AllowDBNull = false;
3424
3425                         dt1.Columns.Add (new DataColumn ("Desc", typeof
3426                                 (string), "", MappingType.Attribute));
3427                         dt1.Columns["Desc"].AllowDBNull = false;
3428
3429                         // Add related DataTables with ReadOnly columns
3430                         DataTable dt2 = new DataTable ("Dimension");
3431                         ds.Tables.Add (dt2);
3432                         dt2.Columns.Add (new DataColumn ("Number", typeof
3433                                 (int), "", MappingType.Attribute));
3434                         dt2.Columns["Number"].AllowDBNull = false;
3435                         dt2.Columns["Number"].ReadOnly = true;
3436
3437                         dt2.Columns.Add (new DataColumn ("Title", typeof
3438                                 (string), "", MappingType.Attribute));
3439                         dt2.Columns["Title"].AllowDBNull = false;
3440
3441                         dt2.Constraints.Add ("PK_Dimension", dt2.Columns["Number"], true);
3442
3443                         DataTable dt3 = new DataTable ("Element");
3444                         ds.Tables.Add (dt3);
3445
3446                         dt3.Columns.Add (new DataColumn ("Dimension", typeof
3447                                 (int), "", MappingType.Attribute));
3448                         dt3.Columns["Dimension"].AllowDBNull = false;
3449                         dt3.Columns["Dimension"].ReadOnly = true;
3450
3451                         dt3.Columns.Add (new DataColumn ("Number", typeof
3452                                 (int), "", MappingType.Attribute));
3453                         dt3.Columns["Number"].AllowDBNull = false;
3454                         dt3.Columns["Number"].ReadOnly = true;
3455
3456                         dt3.Columns.Add (new DataColumn ("Title", typeof
3457                                 (string), "", MappingType.Attribute));
3458                         dt3.Columns["Title"].AllowDBNull = false;
3459
3460                         dt3.Constraints.Add ("PK_Element", new DataColumn[] {
3461                                 dt3.Columns ["Dimension"],
3462                                 dt3.Columns ["Number"] }, true);
3463
3464                         ds.AcceptChanges ();
3465
3466                         StringWriter sw1 = new StringWriter ();
3467                         ds.Tables[0].WriteXmlSchema (sw1);
3468                         string result1 = sw1.ToString ();
3469                         AssertEquals (xmlschema1.Replace ("\r\n", "\n"), result1.Replace ("\r\n", "\n"));
3470
3471                         StringWriter sw2 = new StringWriter ();
3472                         ds.Tables[1].WriteXmlSchema (sw2);
3473                         string result2 = sw2.ToString ();
3474                         AssertEquals (xmlschema2.Replace ("\r\n", "\n"), result2.Replace ("\r\n", "\n"));
3475
3476                         StringWriter sw3 = new StringWriter ();
3477                         ds.Tables[2].WriteXmlSchema (sw3);
3478                         string result3 = sw3.ToString ();
3479                         AssertEquals (xmlschema3.Replace ("\r\n", "\n"), result3.Replace ("\r\n", "\n"));
3480                 }
3481
3482                 [Test]
3483                 public void WriteXmlSchema6 () {
3484                         string xmlschema = @"<?xml version=""1.0"" encoding=""utf-16""?>
3485 <xs:schema id=""Example"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">
3486   <xs:element name=""Example"" msdata:IsDataSet=""true"" msdata:MainDataTable=""MyType"" msdata:UseCurrentLocale=""true"">
3487     <xs:complexType>
3488       <xs:choice minOccurs=""0"" maxOccurs=""unbounded"">
3489         <xs:element name=""MyType"">
3490           <xs:complexType>
3491             <xs:attribute name=""Desc"">
3492               <xs:simpleType>
3493                 <xs:restriction base=""xs:string"">
3494                   <xs:maxLength value=""32"" />
3495                 </xs:restriction>
3496               </xs:simpleType>
3497             </xs:attribute>
3498           </xs:complexType>
3499         </xs:element>
3500       </xs:choice>
3501     </xs:complexType>
3502   </xs:element>
3503 </xs:schema>";
3504                         DataSet ds = new DataSet ("Example");
3505
3506                         // Add MyType DataTable
3507                         ds.Tables.Add ("MyType");
3508
3509                         ds.Tables["MyType"].Columns.Add (new DataColumn (
3510                                 "Desc", typeof (string), "", MappingType.Attribute));
3511                         ds.Tables["MyType"].Columns["Desc"].MaxLength = 32;
3512
3513                         ds.AcceptChanges ();
3514
3515                         StringWriter sw = new StringWriter ();
3516                         ds.Tables[0].WriteXmlSchema (sw);
3517
3518                         string result = sw.ToString ();
3519
3520                         AssertEquals (xmlschema.Replace ("\r\n", "\n"), result.Replace ("\r\n", "\n"));
3521                 }
3522
3523                 [Test]
3524                 public void WriteXmlSchema7 () {
3525                         DataSet ds = new DataSet ();
3526                         DataTable dt = new DataTable ("table");
3527                         dt.Columns.Add ("col1");
3528                         dt.Columns.Add ("col2");
3529                         ds.Tables.Add (dt);
3530                         dt.Rows.Add (new object[] { "foo", "bar" });
3531                         StringWriter sw = new StringWriter ();
3532                         ds.Tables[0].WriteXmlSchema (sw);
3533                         Assert (sw.ToString ().IndexOf ("xmlns=\"\"") > 0);
3534                 }
3535
3536                 [Test]
3537                 public void WriteXmlSchema_ConstraintNameWithSpaces () {
3538                         DataSet ds = new DataSet ();
3539                         DataTable table1 = ds.Tables.Add ("table1");
3540                         DataTable table2 = ds.Tables.Add ("table2");
3541
3542                         table1.Columns.Add ("col1", typeof (int));
3543                         table2.Columns.Add ("col1", typeof (int));
3544
3545                         table1.Constraints.Add ("uc 1", table1.Columns[0], false);
3546                         table2.Constraints.Add ("fc 1", table1.Columns[0], table2.Columns[0]);
3547
3548                         StringWriter sw1 = new StringWriter ();
3549                         StringWriter sw2 = new StringWriter ();
3550
3551                         //should not throw an exception
3552                         ds.Tables[0].WriteXmlSchema (sw1);
3553                         ds.Tables[1].WriteXmlSchema (sw2);
3554                 }
3555
3556                 [Test]
3557                 public void WriteXmlSchema_ForignKeyConstraint () {
3558                         DataSet ds1 = new DataSet ();
3559
3560                         DataTable table1 = ds1.Tables.Add ();
3561                         DataTable table2 = ds1.Tables.Add ();
3562
3563                         DataColumn col1_1 = table1.Columns.Add ("col1", typeof (int));
3564                         DataColumn col2_1 = table2.Columns.Add ("col1", typeof (int));
3565
3566                         table2.Constraints.Add ("fk", col1_1, col2_1);
3567
3568                         StringWriter sw1 = new StringWriter ();
3569                         ds1.Tables[0].WriteXmlSchema (sw1);
3570                         String xml1 = sw1.ToString ();
3571                         Assert ("#1", xml1.IndexOf (@"<xs:unique name=""Constraint1"">") != -1);
3572
3573                         StringWriter sw2 = new StringWriter ();
3574                         ds1.Tables[1].WriteXmlSchema (sw2);
3575                         String xml2 = sw2.ToString ();
3576                         Assert ("#2", xml2.IndexOf (@"<xs:unique name=""Constraint1"">") == -1);
3577                 }
3578
3579                 [Test]
3580                 public void WriteXmlSchema_Relations_ForeignKeys () {
3581                         MemoryStream ms1 = null;
3582                         MemoryStream ms2 = null;
3583                         MemoryStream msA = null;
3584                         MemoryStream msB = null;
3585
3586                         DataSet ds1 = new DataSet ();
3587
3588                         DataTable table1 = ds1.Tables.Add ("Table 1");
3589                         DataTable table2 = ds1.Tables.Add ("Table 2");
3590
3591                         DataColumn col1_1 = table1.Columns.Add ("col 1", typeof (int));
3592                         DataColumn col1_2 = table1.Columns.Add ("col 2", typeof (int));
3593                         DataColumn col1_3 = table1.Columns.Add ("col 3", typeof (int));
3594                         DataColumn col1_4 = table1.Columns.Add ("col 4", typeof (int));
3595                         DataColumn col1_5 = table1.Columns.Add ("col 5", typeof (int));
3596                         DataColumn col1_6 = table1.Columns.Add ("col 6", typeof (int));
3597                         DataColumn col1_7 = table1.Columns.Add ("col 7", typeof (int));
3598
3599                         DataColumn col2_1 = table2.Columns.Add ("col 1", typeof (int));
3600                         DataColumn col2_2 = table2.Columns.Add ("col 2", typeof (int));
3601                         DataColumn col2_3 = table2.Columns.Add ("col 3", typeof (int));
3602                         DataColumn col2_4 = table2.Columns.Add ("col 4", typeof (int));
3603                         DataColumn col2_5 = table2.Columns.Add ("col 5", typeof (int));
3604                         DataColumn col2_6 = table2.Columns.Add ("col 6", typeof (int));
3605                         DataColumn col2_7 = table2.Columns.Add ("col 7", typeof (int));
3606
3607                         ds1.Relations.Add ("rel 1",
3608                                 new DataColumn[] { col1_1, col1_2 },
3609                                 new DataColumn[] { col2_1, col2_2 },
3610                                 false);
3611                         ds1.Relations.Add ("rel 2",
3612                                 new DataColumn[] { col1_3, col1_4 },
3613                                 new DataColumn[] { col2_3, col2_4 },
3614                                 true);
3615                         table2.Constraints.Add ("fk 1",
3616                                 new DataColumn[] { col1_5, col1_6 },
3617                                 new DataColumn[] { col2_5, col2_6 });
3618                         table1.Constraints.Add ("fk 2",
3619                                 new DataColumn[] { col2_5, col2_6 },
3620                                 new DataColumn[] { col1_5, col1_6 });
3621
3622                         table1.Constraints.Add ("pk 1", col1_7, true);
3623                         table2.Constraints.Add ("pk 2", col2_7, true);
3624
3625                         ms1 = new MemoryStream ();
3626                         ds1.Tables[0].WriteXmlSchema (ms1);
3627                         ms2 = new MemoryStream ();
3628                         ds1.Tables[1].WriteXmlSchema (ms2);
3629
3630                         msA = new MemoryStream (ms1.GetBuffer ());
3631                         DataTable dtA = new DataTable ();
3632                         dtA.ReadXmlSchema (msA);
3633
3634                         msB = new MemoryStream (ms2.GetBuffer ());
3635                         DataTable dtB = new DataTable ();
3636                         dtB.ReadXmlSchema (msB);
3637
3638                         AssertEquals ("#2", 3, dtA.Constraints.Count);
3639                         AssertEquals ("#3", 2, dtB.Constraints.Count);
3640
3641                         Assert ("#5", dtA.Constraints.Contains ("pk 1"));
3642                         Assert ("#6", dtA.Constraints.Contains ("Constraint1"));
3643                         Assert ("#7", dtA.Constraints.Contains ("Constraint2"));
3644                         Assert ("#9", dtB.Constraints.Contains ("pk 2"));
3645                         Assert ("#10", dtB.Constraints.Contains ("Constraint1"));
3646                 }
3647
3648                 [Test]
3649                 [Category ("NotWorking")]
3650                 public void WriteXmlSchema_DifferentNamespace () {
3651                         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'>
3652   <xs:import namespace='urn:foo' />
3653   <xs:import namespace='urn:baz' />
3654   <xs:element name='NewDataSet' msdata:IsDataSet='true' msdata:MainDataTable='urn_x003A_foo_x003A_NS1Table' msdata:UseCurrentLocale='true'>
3655     <xs:complexType>
3656       <xs:choice minOccurs='0' maxOccurs='unbounded'>
3657         <xs:element ref='app2:NS1Table' />
3658       </xs:choice>
3659     </xs:complexType>
3660   </xs:element>
3661 </xs:schema>
3662 <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'>
3663   <xs:import namespace='urn:foo' />
3664   <xs:import namespace='urn:bar' />
3665   <xs:element name='column2' type='xs:string' />
3666 </xs:schema>
3667 <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'>
3668   <xs:import namespace='urn:bar' />
3669   <xs:import namespace='urn:baz' />
3670   <xs:element name='NS1Table'>
3671     <xs:complexType>
3672       <xs:sequence>
3673         <xs:element name='column1' type='xs:string' minOccurs='0' />
3674         <xs:element ref='app1:column2' minOccurs='0' />
3675       </xs:sequence>
3676     </xs:complexType>
3677   </xs:element>
3678 </xs:schema>";
3679                         DataSet ds = new DataSet ();
3680                         DataTable dt = new DataTable ();
3681                         dt.TableName = "NS1Table";
3682                         dt.Namespace = "urn:foo";
3683                         dt.Columns.Add ("column1");
3684                         dt.Columns.Add ("column2");
3685                         dt.Columns[1].Namespace = "urn:baz";
3686                         ds.Tables.Add (dt);
3687                         DataTable dt2 = new DataTable ();
3688                         dt2.TableName = "NS2Table";
3689                         dt2.Namespace = "urn:bar";
3690                         ds.Tables.Add (dt2);
3691                         ds.Namespace = "urn:bar";
3692
3693                         StringWriter sw1 = new StringWriter ();
3694                         XmlTextWriter xw1 = new XmlTextWriter (sw1);
3695                         xw1.Formatting = Formatting.Indented;
3696                         xw1.QuoteChar = '\'';
3697                         ds.Tables[0].WriteXmlSchema (xw1);
3698                         string result1 = sw1.ToString ();
3699                         AssertEquals ("#1", schema, result1);
3700
3701                         StringWriter sw2 = new StringWriter ();
3702                         XmlTextWriter xw2 = new XmlTextWriter (sw2);
3703                         xw2.Formatting = Formatting.Indented;
3704                         xw2.QuoteChar = '\'';
3705                         ds.Tables[0].WriteXmlSchema (xw2);
3706                         string result2 = sw2.ToString ();
3707                         AssertEquals ("#2", schema, result2);
3708                 }
3709
3710                 [Test]
3711                 public void WriteXmlSchema_Hierarchy () {
3712                         DataSet ds = new DataSet ();
3713                         DataTable table1 = new DataTable ();
3714                         DataColumn idColumn = table1.Columns.Add ("ID", typeof (Int32));
3715                         table1.Columns.Add ("Name", typeof (String));
3716                         table1.PrimaryKey = new DataColumn[] { idColumn };
3717                         DataTable table2 = new DataTable ();
3718                         table2.Columns.Add (new DataColumn ("OrderID", typeof (Int32)));
3719                         table2.Columns.Add (new DataColumn ("CustomerID", typeof (Int32)));
3720                         table2.Columns.Add (new DataColumn ("OrderDate", typeof (DateTime)));
3721                         table2.PrimaryKey = new DataColumn[] { table2.Columns[0] };
3722                         ds.Tables.Add (table1);
3723                         ds.Tables.Add (table2);
3724                         ds.Relations.Add ("CustomerOrder",
3725                             new DataColumn[] { table1.Columns[0] },
3726                             new DataColumn[] { table2.Columns[1] }, true);
3727
3728                         StringWriter writer1 = new StringWriter ();
3729                         table1.WriteXmlSchema (writer1, false);
3730                         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>";
3731                         AssertEquals ("#1", expected1, writer1.ToString());
3732
3733                         StringWriter writer2 = new StringWriter ();
3734                         table1.WriteXmlSchema (writer2, true);
3735                         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>";
3736                         AssertEquals ("#2", expected2, writer2.ToString ());
3737                 }
3738
3739                 [Test]
3740                 //[Category ("NotWorking")]
3741                 // WriteXmlSchema doesn't have overload wityh 2 parameters in System.Data
3742                 // and is commented-out TWICE below
3743                 public void ReadWriteXmlSchema()
3744                 {
3745                         DataSet ds = new DataSet();
3746                         ds.ReadXmlSchema("Test/System.Data/store.xsd");
3747                         // check dataset properties before testing write
3748                         AssertDataSet("ds", ds, "NewDataSet", 3, 2);
3749                         AssertDataTable("tab1", ds.Tables[0], "bookstore", 1, 0, 0, 1, 1, 1);
3750                         AssertDataTable("tab2", ds.Tables[1], "book", 5, 0, 1, 1, 2, 1);
3751                         AssertDataTable("tab3", ds.Tables[2], "author", 3, 0, 1, 0, 1, 0);
3752                         // FIXME: currently order is not compatible. Use name as index
3753                         AssertDataRelation("rel1", ds.Relations["book_author"], "book_author", true, new string[] { "book_Id" }, new string[] { "book_Id" }, true, true);
3754                         AssertDataRelation("rel2", ds.Relations["bookstore_book"], "bookstore_book", true, new string[] { "bookstore_Id" }, new string[] { "bookstore_Id" }, true, true);
3755
3756                         ds.ReadXml("Test/System.Data/region.xml", XmlReadMode.InferSchema);
3757                         ds.Relations.Clear(); // because can not call WriteXmlSchema with nested relations.
3758
3759                         TextWriter writer1 = new StringWriter();
3760                         ds.Tables[0].WriteXmlSchema(writer1);
3761                         //string TextString1 = GetNormalizedSchema(writer1.ToString());
3762                         string TextString1 = writer1.ToString();
3763                         string expected1 = @"<?xml version=""1.0"" encoding=""utf-16""?>" +
3764 @"<xs:schema id=""Root"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">" +
3765   @"<xs:complexType name=""bookstoreType"">" +
3766   @"</xs:complexType>" +
3767   @"<xs:element name=""bookstore"" type=""bookstoreType"" />" +
3768   @"<xs:element name=""Root"" msdata:IsDataSet=""true"" msdata:MainDataTable=""bookstore"" msdata:UseCurrentLocale=""true"">" +
3769     @"<xs:complexType>" +
3770       @"<xs:choice minOccurs=""0"" maxOccurs=""unbounded"">" +
3771     @"<xs:element ref=""bookstore"" />" +
3772       @"</xs:choice>" +
3773     @"</xs:complexType>" +
3774   @"</xs:element>" +
3775 @"</xs:schema>";
3776                         NUnit.Framework.Assert.AreEqual(expected1.Replace("\n", ""),
3777                                                         TextString1.Replace("\r\n", "").Replace("  ", "").Replace("\n", ""), "#1");
3778
3779                         TextWriter writer2 = new StringWriter();
3780                         ds.Tables[1].WriteXmlSchema(writer2, false);
3781                         //string TextString2 = GetNormalizedSchema(writer2.ToString());
3782                         string TextString2 = writer2.ToString();
3783                         string expected2 = @"<?xml version=""1.0"" encoding=""utf-16""?>" +
3784 @"<xs:schema id=""Root"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">" +
3785   @"<xs:complexType name=""bookType"">" +
3786     @"<xs:sequence>" +
3787       @"<xs:element name=""title"" type=""xs:string"" msdata:Ordinal=""1"" />" +
3788       @"<xs:element name=""price"" type=""xs:decimal"" msdata:Ordinal=""2"" />" +
3789     @"</xs:sequence>" +
3790     @"<xs:attribute name=""genre"" type=""xs:string"" />" +
3791     @"<xs:attribute name=""bookstore_Id"" type=""xs:int"" use=""prohibited"" />" +
3792   @"</xs:complexType>" +
3793   @"<xs:element name=""book"" type=""bookType"" />" +
3794   @"<xs:element name=""Root"" msdata:IsDataSet=""true"" msdata:MainDataTable=""book"" msdata:UseCurrentLocale=""true"">" +
3795     @"<xs:complexType>" +
3796       @"<xs:choice minOccurs=""0"" maxOccurs=""unbounded"">" +
3797     @"<xs:element ref=""book"" />" +
3798       @"</xs:choice>" +
3799     @"</xs:complexType>" +
3800   @"</xs:element>" +
3801 @"</xs:schema>";
3802                         NUnit.Framework.Assert.AreEqual(expected2, TextString2.Replace("\r\n", "").Replace("  ", ""), "#2");
3803
3804                         TextWriter writer3 = new StringWriter();
3805                         ds.Tables[2].WriteXmlSchema(writer3);
3806                         //string TextString3 = GetNormalizedSchema(writer3.ToString());
3807                         string TextString3 = writer3.ToString();
3808                         string expected3 = @"<?xml version=""1.0"" encoding=""utf-16""?>" +
3809 @"<xs:schema id=""Root"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">" +
3810   @"<xs:complexType name=""authorName"">" +
3811     @"<xs:sequence>" +
3812       @"<xs:element name=""first-name"" type=""xs:string"" msdata:Ordinal=""0"" />" +
3813       @"<xs:element name=""last-name"" type=""xs:string"" msdata:Ordinal=""1"" />" +
3814     @"</xs:sequence>" +
3815     @"<xs:attribute name=""book_Id"" type=""xs:int"" use=""prohibited"" />" +
3816   @"</xs:complexType>" +
3817   @"<xs:element name=""author"" type=""authorName"" />" +
3818   @"<xs:element name=""Root"" msdata:IsDataSet=""true"" msdata:MainDataTable=""author"" msdata:UseCurrentLocale=""true"">" +
3819     @"<xs:complexType>" +
3820       @"<xs:choice minOccurs=""0"" maxOccurs=""unbounded"">" +
3821         @"<xs:element ref=""author"" />" +
3822       @"</xs:choice>" +
3823     @"</xs:complexType>" +
3824   @"</xs:element>" +
3825 @"</xs:schema>";
3826                         NUnit.Framework.Assert.AreEqual(expected3, TextString3.Replace("\r\n", "").Replace("  ", ""), "#3");
3827
3828                         TextWriter writer4 = new StringWriter();
3829                         ds.Tables[3].WriteXmlSchema(writer4);
3830                         //string TextString4 = GetNormalizedSchema(writer4.ToString());
3831                         string TextString4 = writer4.ToString();
3832                         string expected4 = @"<?xml version=""1.0"" encoding=""utf-16""?>" +
3833 @"<xs:schema id=""Root"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">" +
3834   @"<xs:element name=""Root"" msdata:IsDataSet=""true"" msdata:MainDataTable=""Region"" msdata:UseCurrentLocale=""true"">" +
3835     @"<xs:complexType>" +
3836       @"<xs:choice minOccurs=""0"" maxOccurs=""unbounded"">" +
3837         @"<xs:element name=""Region"">" +
3838           @"<xs:complexType>" +
3839             @"<xs:sequence>" +
3840               @"<xs:element name=""RegionID"" type=""xs:string"" minOccurs=""0"" />" +
3841               @"<xs:element name=""RegionDescription"" type=""xs:string"" minOccurs=""0"" />" +
3842             @"</xs:sequence>" +
3843           @"</xs:complexType>" +
3844         @"</xs:element>" +
3845       @"</xs:choice>" +
3846     @"</xs:complexType>" +
3847   @"</xs:element>" +
3848 @"</xs:schema>";
3849                         NUnit.Framework.Assert.AreEqual(expected4, TextString4.Replace("\r\n", "").Replace("  ", ""), "#4");
3850                 }
3851
3852                 [Test]
3853                 //[Category ("NotWorking")]
3854                 public void ReadWriteXmlSchema_IgnoreSchema () {
3855                         DataSet ds = new DataSet ();
3856                         ds.ReadXmlSchema ("Test/System.Data/store.xsd");
3857                         // check dataset properties before testing write
3858                         AssertDataSet ("ds", ds, "NewDataSet", 3, 2);
3859                         AssertDataTable ("tab1", ds.Tables[0], "bookstore", 1, 0, 0, 1, 1, 1);
3860                         AssertDataTable ("tab2", ds.Tables[1], "book", 5, 0, 1, 1, 2, 1);
3861                         AssertDataTable ("tab3", ds.Tables[2], "author", 3, 0, 1, 0, 1, 0);
3862                         // FIXME: currently order is not compatible. Use name as index
3863                         AssertDataRelation ("rel1", ds.Relations["book_author"], "book_author", true, new string[] { "book_Id" }, new string[] { "book_Id" }, true, true);
3864                         AssertDataRelation ("rel2", ds.Relations["bookstore_book"], "bookstore_book", true, new string[] { "bookstore_Id" }, new string[] { "bookstore_Id" }, true, true);
3865
3866                         ds.ReadXml ("Test/System.Data/region.xml", XmlReadMode.IgnoreSchema);
3867                         ds.Relations.Clear (); // because can not call WriteXmlSchema with nested relations.
3868
3869                         TextWriter writer1 = new StringWriter ();
3870                         ds.Tables[0].WriteXmlSchema (writer1);
3871                         //string TextString1 = GetNormalizedSchema (writer1.ToString ());
3872                         string TextString1 = writer1.ToString ();
3873                         string expected1 = @"<?xml version=""1.0"" encoding=""utf-16""?>" +
3874 @"<xs:schema id=""NewDataSet"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">" +
3875   @"<xs:complexType name=""bookstoreType"">" +
3876   @"</xs:complexType>" +
3877   @"<xs:element name=""bookstore"" type=""bookstoreType"" />" +
3878   @"<xs:element name=""NewDataSet"" msdata:IsDataSet=""true"" msdata:MainDataTable=""bookstore"" msdata:UseCurrentLocale=""true"">" +
3879     @"<xs:complexType>" +
3880       @"<xs:choice minOccurs=""0"" maxOccurs=""unbounded"">" +
3881         @"<xs:element ref=""bookstore"" />" +
3882       @"</xs:choice>" +
3883     @"</xs:complexType>" +
3884   @"</xs:element>" +
3885 @"</xs:schema>";
3886                         Console.WriteLine ("{0} - {1}", TextString1, expected1);
3887                         AssertEquals ("#1", expected1, TextString1.Replace ("\r\n", "").Replace ("  ", "").Replace ("\n", ""));
3888
3889                         TextWriter writer2 = new StringWriter ();
3890                         ds.Tables[1].WriteXmlSchema (writer2, false);
3891                         string TextString2 = GetNormalizedSchema (writer2.ToString ());
3892                         string expected2 = @"<?xml version=""1.0"" encoding=""utf-16""?>" +
3893 @"<xs:schema id=""NewDataSet"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">" +
3894   @"<xs:complexType name=""bookType"">" +
3895     @"<xs:sequence>" +
3896       @"<xs:element name=""title"" type=""xs:string"" msdata:Ordinal=""1"" />" +
3897       @"<xs:element name=""price"" type=""xs:decimal"" msdata:Ordinal=""2"" />" +
3898     @"</xs:sequence>" +
3899     @"<xs:attribute name=""genre"" type=""xs:string"" />" +
3900     @"<xs:attribute name=""bookstore_Id"" type=""xs:int"" use=""prohibited"" />" +
3901   @"</xs:complexType>" +
3902   @"<xs:element name=""book"" type=""bookType"" />" +
3903   @"<xs:element name=""NewDataSet"" msdata:IsDataSet=""true"" msdata:MainDataTable=""book"" msdata:UseCurrentLocale=""true"">" +
3904     @"<xs:complexType>" +
3905       @"<xs:choice minOccurs=""0"" maxOccurs=""unbounded"">" +
3906         @"<xs:element ref=""book"" />" +
3907       @"</xs:choice>" +
3908     @"</xs:complexType>" +
3909   @"</xs:element>" +
3910 @"</xs:schema>";
3911                         AssertEquals ("#2", expected2, TextString2.Replace ("\r\n", "").Replace ("  ", ""));
3912
3913                         TextWriter writer3 = new StringWriter ();
3914                         ds.Tables[2].WriteXmlSchema (writer3);
3915                         string TextString3 = GetNormalizedSchema (writer3.ToString ());
3916                         string expected3 = @"<?xml version=""1.0"" encoding=""utf-16""?>" +
3917 @"<xs:schema id=""NewDataSet"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">" +
3918   @"<xs:complexType name=""authorName"">" +
3919     @"<xs:sequence>" +
3920       @"<xs:element name=""first-name"" type=""xs:string"" msdata:Ordinal=""0"" />" +
3921       @"<xs:element name=""last-name"" type=""xs:string"" msdata:Ordinal=""1"" />" +
3922     @"</xs:sequence>" +
3923     @"<xs:attribute name=""book_Id"" type=""xs:int"" use=""prohibited"" />" +
3924   @"</xs:complexType>" +
3925   @"<xs:element name=""author"" type=""authorName"" />" +
3926   @"<xs:element name=""NewDataSet"" msdata:IsDataSet=""true"" msdata:MainDataTable=""author"" msdata:UseCurrentLocale=""true"">" +
3927     @"<xs:complexType>" +
3928       @"<xs:choice minOccurs=""0"" maxOccurs=""unbounded"">" +
3929         @"<xs:element ref=""author"" />" +
3930       @"</xs:choice>" +
3931     @"</xs:complexType>" +
3932   @"</xs:element>" +
3933 @"</xs:schema>";
3934                         AssertEquals ("#3", expected3, TextString3.Replace ("\r\n", "").Replace ("  ", ""));
3935
3936                         TextWriter writer4 = new StringWriter ();
3937                         string expStr = "";
3938                         try {
3939                                 ds.Tables[3].WriteXmlSchema (writer4);
3940                         }
3941                         catch (Exception ex) {
3942                                 expStr = ex.Message;
3943                         }
3944                         AssertEquals ("#4", "Cannot find table 3.", expStr);
3945                 }
3946
3947                 [Test]
3948                 public void ReadWriteXmlSchema_2 () {
3949                         DataSet ds = new DataSet ("dataset");
3950                         ds.Tables.Add ("table1");
3951                         ds.Tables.Add ("table2");
3952                         ds.Tables[0].Columns.Add ("col");
3953                         ds.Tables[1].Columns.Add ("col");
3954                         ds.Relations.Add ("rel", ds.Tables[0].Columns[0], ds.Tables[1].Columns[0], true);
3955
3956                         MemoryStream ms1 = new MemoryStream ();
3957                         ds.Tables[0].WriteXmlSchema (ms1);
3958                         MemoryStream ms2 = new MemoryStream ();
3959                         ds.Tables[1].WriteXmlSchema (ms2);
3960
3961                         DataSet ds1 = new DataSet ();
3962                         ds1.Tables.Add ();
3963                         ds1.Tables.Add ();
3964                         ds1.Tables[0].ReadXmlSchema (new MemoryStream (ms1.GetBuffer ()));
3965                         ds1.Tables[1].ReadXmlSchema (new MemoryStream (ms2.GetBuffer ()));
3966
3967                         AssertEquals ("#1", 0, ds1.Relations.Count);
3968                         AssertEquals ("#2", 1, ds1.Tables[0].Columns.Count);
3969                         AssertEquals ("#3", 1, ds1.Tables[1].Columns.Count);
3970                 }
3971
3972                 [Test]
3973                 [ExpectedException (typeof (XmlException))]
3974                 public void ReadWriteXmlSchemaExp_NoRootElmnt () {
3975                         MemoryStream ms = new MemoryStream ();
3976                         DataTable dtr = new DataTable ();
3977                         dtr.ReadXmlSchema (ms);
3978                 }
3979
3980                 [Test]
3981                 [ExpectedException (typeof (InvalidOperationException))]
3982                 public void ReadWriteXmlSchemaExp_NoTableName () {
3983                         DataTable dtw = new DataTable ();
3984                         MemoryStream ms = new MemoryStream ();
3985                         dtw.WriteXmlSchema (ms);
3986                 }
3987
3988                 [Test]
3989                 [ExpectedException (typeof (ArgumentException))]
3990                 public void ReadWriteXmlSchemaExp_NoFileName () {
3991                         DataTable dtw = new DataTable ();
3992                         dtw.WriteXmlSchema ("");
3993                 }
3994
3995                 [Test]
3996                 [ExpectedException (typeof (ArgumentException))]
3997                 public void ReadWriteXmlSchemaExp_TableNameConflict () {
3998                         DataTable dtw = new DataTable ("Table1");
3999                         StringWriter writer1 = new StringWriter ();
4000                         dtw.WriteXmlSchema (writer1);
4001                         DataTable dtr = new DataTable ("Table2");
4002                         StringReader reader1 = new StringReader (writer1.ToString());
4003                         dtr.ReadXmlSchema (reader1);
4004                 }
4005
4006                 #endregion // Read/Write XML Tests
4007
4008 #endif // NET_2_0
4009
4010         }
4011
4012
4013          public  class MyDataTable:DataTable {
4014
4015              public static int count = 0;
4016
4017              public MyDataTable() {
4018
4019                     count++;
4020              }
4021
4022          }
4023
4024         [Serializable]
4025         [TestFixture]
4026         public class AppDomainsAndFormatInfo
4027         {
4028                 public void Remote ()
4029                 {
4030                         int n = (int) Convert.ChangeType ("5", typeof (int));
4031                         Assertion.AssertEquals ("n", 5, n);
4032                 }
4033 #if !TARGET_JVM
4034                 [Test]
4035                 public void NFIFromBug55978 ()
4036                 {
4037                         AppDomain domain = AppDomain.CreateDomain ("testdomain");
4038                         AppDomainsAndFormatInfo test = new AppDomainsAndFormatInfo ();
4039                         test.Remote ();
4040                         domain.DoCallBack (new CrossAppDomainDelegate (test.Remote));
4041                         AppDomain.Unload (domain);
4042                 }
4043 #endif
4044
4045                 [Test]
4046                 public void Bug55978 ()
4047                 {
4048                         DataTable dt = new DataTable ();
4049                         dt.Columns.Add ("StartDate", typeof (DateTime));
4050
4051                         DataRow dr;
4052                         DateTime date = DateTime.Now;
4053
4054                         for (int i = 0; i < 10; i++) {
4055                                 dr = dt.NewRow ();
4056                                 dr ["StartDate"] = date.AddDays (i);
4057                                 dt.Rows.Add (dr);
4058                         }
4059
4060                         DataView dv = dt.DefaultView;
4061                         dv.RowFilter = "StartDate >= '" + DateTime.Now.AddDays (2) + "' and StartDate <= '" + DateTime.Now.AddDays (4) + "'";
4062                         Assertion.AssertEquals ("Table", 10, dt.Rows.Count);
4063                         Assertion.AssertEquals ("View", 2, dv.Count);
4064                 }
4065         }
4066 }