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
  46 namespace MonoTests.System.Data
  47 {
  48         [TestFixture]
  49         public class DataTableTest :  DataSetAssertion
  50         {
  51                 string EOL = Environment.NewLine;
  52
  53                 [Test]
  54                 public void Ctor()
  55                 {
  56                         DataTable dt = new DataTable();
  57
  58                         AssertEquals("CaseSensitive must be false." ,false,dt.CaseSensitive);
  59                         Assert("Col",dt.Columns != null);
  60                         //Assert(dt.ChildRelations != null);
  61                         Assert("Const", dt.Constraints != null);
  62                         Assert("ds", dt.DataSet == null);
  63                         Assert("dv", dt.DefaultView != null);
  64                         Assert("de", dt.DisplayExpression == "");
  65                         Assert("ep", dt.ExtendedProperties != null);
  66                         Assert("he", dt.HasErrors == false);
  67                         Assert("lc", dt.Locale != null);
  68                         Assert("mc", dt.MinimumCapacity == 50); //LAMESPEC:
  69                         Assert("ns", dt.Namespace == "");
  70                         //Assert(dt.ParentRelations != null);
  71                         Assert("pf", dt.Prefix == "");
  72                         Assert("pk", dt.PrimaryKey != null);
  73                         Assert("rows", dt.Rows != null);
  74                         Assert("Site", dt.Site == null);
  75                         Assert("tname", dt.TableName == "");
  76
  77                 }
  78
  79                 [Test]
  80                 public void Select ()
  81                 {
  82                         DataSet Set = new DataSet ();
  83                         DataTable Mom = new DataTable ("Mom");
  84                         DataTable Child = new DataTable ("Child");
  85                         Set.Tables.Add (Mom);
  86                         Set.Tables.Add (Child);
  87
  88                         DataColumn Col = new DataColumn ("Name");
  89                         DataColumn Col2 = new DataColumn ("ChildName");
  90                         Mom.Columns.Add (Col);
  91                         Mom.Columns.Add (Col2);
  92
  93                         DataColumn Col3 = new DataColumn ("Name");
  94                         DataColumn Col4 = new DataColumn ("Age");
  95                         Col4.DataType = Type.GetType ("System.Int16");
  96                         Child.Columns.Add (Col3);
  97                         Child.Columns.Add (Col4);
  98
  99                         DataRelation Relation = new DataRelation ("Rel", Mom.Columns [1], Child.Columns [0]);
 100                         Set.Relations.Add (Relation);
 101
 102                         DataRow Row = Mom.NewRow ();
 103                         Row [0] = "Laura";
 104                         Row [1] = "Nick";
 105                         Mom.Rows.Add (Row);
 106
 107                         Row = Mom.NewRow ();
 108                         Row [0] = "Laura";
 109                         Row [1] = "Dick";
 110                         Mom.Rows.Add (Row);
 111
 112                         Row = Mom.NewRow ();
 113                         Row [0] = "Laura";
 114                         Row [1] = "Mick";
 115                         Mom.Rows.Add (Row);
 116
 117                         Row = Mom.NewRow ();
 118                         Row [0] = "Teresa";
 119                         Row [1] = "Jack";
 120                         Mom.Rows.Add (Row);
 121
 122                         Row = Mom.NewRow ();
 123                         Row [0] = "Teresa";
 124                         Row [1] = "Mack";
 125                         Mom.Rows.Add (Row);
 126
 127                         Row = Mom.NewRow ();
 128                         Row [0] = "'Jhon O'' Collenal'";
 129                         Row [1] = "Pack";
 130                         Mom.Rows.Add (Row);
 131
 132                         Row = Child.NewRow ();
 133                         Row [0] = "Nick";
 134                         Row [1] = 15;
 135                         Child.Rows.Add (Row);
 136
 137                         Row = Child.NewRow ();
 138                         Row [0] = "Dick";
 139                         Row [1] = 25;
 140                         Child.Rows.Add (Row);
 141
 142                         Row = Child.NewRow ();
 143                         Row [0] = "Mick";
 144                         Row [1] = 35;
 145                         Child.Rows.Add (Row);
 146
 147                         Row = Child.NewRow ();
 148                         Row [0] = "Jack";
 149                         Row [1] = 10;
 150                         Child.Rows.Add (Row);
 151
 152                         Row = Child.NewRow ();
 153                         Row [0] = "Mack";
 154                         Row [1] = 19;
 155                         Child.Rows.Add (Row);
 156
 157                         Row = Child.NewRow ();
 158                         Row [0] = "Mack";
 159                         Row [1] = 99;
 160                         Child.Rows.Add (Row);
 161
 162                         Row = Child.NewRow ();
 163                         Row [0] = "Pack";
 164                         Row [1] = 66;
 165                         Child.Rows.Add (Row);
 166
 167                         DataRow [] Rows = Mom.Select ("Name = 'Teresa'");
 168                         AssertEquals ("test#01", 2, Rows.Length);
 169
 170                         // test with apos escaped
 171                         Rows = Mom.Select ("Name = '''Jhon O'''' Collenal'''");
 172                         AssertEquals ("test#01.1", 1, Rows.Length);
 173
 174                         Rows = Mom.Select ("Name = 'Teresa' and ChildName = 'Nick'");
 175                         AssertEquals ("test#02", 0, Rows.Length);
 176
 177                         Rows = Mom.Select ("Name = 'Teresa' and ChildName = 'Jack'");
 178                         AssertEquals ("test#03", 1, Rows.Length);
 179
 180                         Rows = Mom.Select ("Name = 'Teresa' and ChildName <> 'Jack'");
 181                         AssertEquals ("test#04", "Mack", Rows [0] [1]);
 182
 183                         Rows = Mom.Select ("Name = 'Teresa' or ChildName <> 'Jack'");
 184                         AssertEquals ("test#05", 6, Rows.Length);
 185
 186                         Rows = Child.Select ("age = 20 - 1");
 187                         AssertEquals ("test#06", 1, Rows.Length);
 188
 189                         Rows = Child.Select ("age <= 20");
 190                         AssertEquals ("test#07", 3, Rows.Length);
 191
 192                         Rows = Child.Select ("age >= 20");
 193                         AssertEquals ("test#08", 4, Rows.Length);
 194
 195                         Rows = Child.Select ("age >= 20 and name = 'Mack' or name = 'Nick'");
 196                         AssertEquals ("test#09", 2, Rows.Length);
 197
 198                         Rows = Child.Select ("age >= 20 and (name = 'Mack' or name = 'Nick')");
 199                         AssertEquals ("test#10", 1, Rows.Length);
 200                         AssertEquals ("test#11", "Mack", Rows [0] [0]);
 201
 202                         Rows = Child.Select ("not (Name = 'Jack')");
 203                         AssertEquals ("test#12", 6, Rows.Length);
 204                 }
 205
 206                 [Test]
 207                 public void Select2 ()
 208                 {
 209                         DataSet Set = new DataSet ();
 210                         DataTable Child = new DataTable ("Child");
 211
 212                         Set.Tables.Add (Child);
 213
 214                         DataColumn Col3 = new DataColumn ("Name");
 215                         DataColumn Col4 = new DataColumn ("Age");
 216                         Col4.DataType = Type.GetType ("System.Int16");
 217                         Child.Columns.Add (Col3);
 218                         Child.Columns.Add (Col4);
 219
 220                         DataRow Row = Child.NewRow ();
 221                         Row [0] = "Nick";
 222                         Row [1] = 15;
 223                         Child.Rows.Add (Row);
 224
 225                         Row = Child.NewRow ();
 226                         Row [0] = "Dick";
 227                         Row [1] = 25;
 228                         Child.Rows.Add (Row);
 229
 230                         Row = Child.NewRow ();
 231                         Row [0] = "Mick";
 232                         Row [1] = 35;
 233                         Child.Rows.Add (Row);
 234
 235                         Row = Child.NewRow ();
 236                         Row [0] = "Jack";
 237                         Row [1] = 10;
 238                         Child.Rows.Add (Row);
 239
 240                         Row = Child.NewRow ();
 241                         Row [0] = "Mack";
 242                         Row [1] = 19;
 243                         Child.Rows.Add (Row);
 244
 245                         Row = Child.NewRow ();
 246                         Row [0] = "Mack";
 247                         Row [1] = 99;
 248                         Child.Rows.Add (Row);
 249
 250                         DataRow [] Rows = Child.Select ("age >= 20", "age DESC");
 251                         AssertEquals ("test#01", 3, Rows.Length);
 252                         AssertEquals ("test#02", "Mack", Rows [0] [0]);
 253                         AssertEquals ("test#03", "Mick", Rows [1] [0]);
 254                         AssertEquals ("test#04", "Dick", Rows [2] [0]);
 255
 256                         Rows = Child.Select ("age >= 20", "age asc");
 257                         AssertEquals ("test#05", 3, Rows.Length);
 258                         AssertEquals ("test#06", "Dick", Rows [0] [0]);
 259                         AssertEquals ("test#07", "Mick", Rows [1] [0]);
 260                         AssertEquals ("test#08", "Mack", Rows [2] [0]);
 261
 262                         Rows = Child.Select ("age >= 20", "name asc");
 263                         AssertEquals ("test#09", 3, Rows.Length);
 264                         AssertEquals ("test#10", "Dick", Rows [0] [0]);
 265                         AssertEquals ("test#11", "Mack", Rows [1] [0]);
 266                         AssertEquals ("test#12", "Mick", Rows [2] [0]);
 267
 268                         Rows = Child.Select ("age >= 20", "name desc");
 269                         AssertEquals ("test#09", 3, Rows.Length);
 270                         AssertEquals ("test#10", "Mick", Rows [0] [0]);
 271                         AssertEquals ("test#11", "Mack", Rows [1] [0]);
 272                         AssertEquals ("test#12", "Dick", Rows [2] [0]);
 273
 274                 }
 275
 276                 [Test]
 277                 public void SelectParsing ()
 278                 {
 279                         DataTable T = new DataTable ("test");
 280                         DataColumn C = new DataColumn ("name");
 281                         T.Columns.Add (C);
 282                         C = new DataColumn ("age");
 283                         C.DataType = typeof (int);
 284                         T.Columns.Add (C);
 285                         C = new DataColumn ("id");
 286                         T.Columns.Add (C);
 287
 288                         DataSet Set = new DataSet ("TestSet");
 289                         Set.Tables.Add (T);
 290
 291                         DataRow Row = null;
 292                         for (int i = 0; i < 100; i++) {
 293                                 Row = T.NewRow ();
 294                                 Row [0] = "human" + i;
 295                                 Row [1] = i;
 296                                 Row [2] = i;
 297                                 T.Rows.Add (Row);
 298                         }
 299
 300                         Row = T.NewRow ();
 301                         Row [0] = "h*an";
 302                         Row [1] = 1;
 303                         Row [2] = 1;
 304                         T.Rows.Add (Row);
 305
 306                         AssertEquals ("test#01", 12, T.Select ("age<=10").Length);
 307
 308                         AssertEquals ("test#02", 12, T.Select ("age\n\t<\n\t=\t\n10").Length);
 309
 310                         try {
 311                                 T.Select ("name = 1human ");
 312                                 Fail ("test#03");
 313                         } catch (Exception e) {
 314
 315                                 // missing operand after 'human' operand
 316                                 AssertEquals ("test#04", typeof (SyntaxErrorException), e.GetType ());
 317                         }
 318
 319                         try {
 320                                 T.Select ("name = 1");
 321                                 Fail ("test#05");
 322                         } catch (Exception e) {
 323
 324                                 // Cannot perform '=' operation between string and Int32
 325                                 AssertEquals ("test#06", typeof (EvaluateException), e.GetType ());
 326                         }
 327
 328                         AssertEquals ("test#07", 1, T.Select ("age = '13'").Length);
 329
 330                 }
 331
 332                 [Test]
 333                 public void SelectEscaping () {
 334                         DataTable dt = new DataTable ();
 335                         dt.Columns.Add ("SomeCol");
 336                         dt.Rows.Add (new object [] {"\t"});
 337                         dt.Rows.Add (new object [] {"\\"});
 338
 339                         AssertEquals ("test#01", 1, dt.Select (@"SomeCol='\t'").Length);
 340                         AssertEquals ("test#02", 1, dt.Select (@"SomeCol='\\'").Length);
 341
 342                         try {
 343                                 dt.Select (@"SomeCol='\x'");
 344                                 Fail("test#03");
 345                         } catch (SyntaxErrorException) {}
 346                 }
 347
 348                 [Test]
 349                 public void SelectOperators ()
 350                 {
 351                         DataTable T = new DataTable ("test");
 352                         DataColumn C = new DataColumn ("name");
 353                         T.Columns.Add (C);
 354                         C = new DataColumn ("age");
 355                         C.DataType = typeof (int);
 356                         T.Columns.Add (C);
 357                         C = new DataColumn ("id");
 358                         T.Columns.Add (C);
 359
 360                         DataSet Set = new DataSet ("TestSet");
 361                         Set.Tables.Add (T);
 362
 363                         DataRow Row = null;
 364                         for (int i = 0; i < 100; i++) {
 365                                 Row = T.NewRow ();
 366                                 Row [0] = "human" + i;
 367                                 Row [1] = i;
 368                                 Row [2] = i;
 369                                 T.Rows.Add (Row);
 370                         }
 371
 372                         Row = T.NewRow ();
 373                         Row [0] = "h*an";
 374                         Row [1] = 1;
 375                         Row [2] = 1;
 376                         T.Rows.Add (Row);
 377
 378                         AssertEquals ("test#01", 11, T.Select ("age < 10").Length);
 379                         AssertEquals ("test#02", 12, T.Select ("age <= 10").Length);
 380                         AssertEquals ("test#03", 12, T.Select ("age< =10").Length);
 381                         AssertEquals ("test#04", 89, T.Select ("age > 10").Length);
 382                         AssertEquals ("test#05", 90, T.Select ("age >= 10").Length);
 383                         AssertEquals ("test#06", 100, T.Select ("age <> 10").Length);
 384                         AssertEquals ("test#07", 3, T.Select ("name < 'human10'").Length);
 385                         AssertEquals ("test#08", 3, T.Select ("id < '10'").Length);
 386                         // FIXME: Somebody explain how this can be possible.
 387                         // it seems that it is no matter between 10 - 30. The
 388                         // result is allways 25 :-P
 389                         //AssertEquals ("test#09", 25, T.Select ("id < 10").Length);
 390
 391                 }
 392
 393                 [Test]
 394                 public void SelectExceptions ()
 395                 {
 396                         DataTable T = new DataTable ("test");
 397                         DataColumn C = new DataColumn ("name");
 398                         T.Columns.Add (C);
 399                         C = new DataColumn ("age");
 400                         C.DataType = typeof (int);
 401                         T.Columns.Add (C);
 402                         C = new DataColumn ("id");
 403                         T.Columns.Add (C);
 404
 405                         for (int i = 0; i < 100; i++) {
 406                                 DataRow Row = T.NewRow ();
 407                                 Row [0] = "human" + i;
 408                                 Row [1] = i;
 409                                 Row [2] = i;
 410                                 T.Rows.Add (Row);
 411                         }
 412
 413                         try {
 414                                 T.Select ("name = human1");
 415                                 Fail ("test#01");
 416                         } catch (Exception e) {
 417
 418                                 // column name human not found
 419                                 AssertEquals ("test#02", typeof (EvaluateException), e.GetType ());
 420                         }
 421
 422                         AssertEquals ("test#04", 1, T.Select ("id = '12'").Length);
 423                         AssertEquals ("test#05", 1, T.Select ("id = 12").Length);
 424
 425                         try {
 426                                 T.Select ("id = 1k3");
 427                                 Fail ("test#06");
 428                         } catch (Exception e) {
 429
 430                                 // no operands after k3 operator
 431                                 AssertEquals ("test#07", typeof (SyntaxErrorException), e.GetType ());
 432                         }
 433                 }
 434
 435                 [Test]
 436                 public void SelectStringOperators ()
 437                 {
 438                         DataTable T = new DataTable ("test");
 439                         DataColumn C = new DataColumn ("name");
 440                         T.Columns.Add (C);
 441                         C = new DataColumn ("age");
 442                         C.DataType = typeof (int);
 443                         T.Columns.Add (C);
 444                         C = new DataColumn ("id");
 445                         T.Columns.Add (C);
 446
 447                         DataSet Set = new DataSet ("TestSet");
 448                         Set.Tables.Add (T);
 449
 450                         DataRow Row = null;
 451                         for (int i = 0; i < 100; i++) {
 452                                 Row = T.NewRow ();
 453                                 Row [0] = "human" + i;
 454                                 Row [1] = i;
 455                                 Row [2] = i;
 456                                 T.Rows.Add (Row);
 457                         }
 458                         Row = T.NewRow ();
 459                         Row [0] = "h*an";
 460                         Row [1] = 1;
 461                         Row [2] = 1;
 462                         T.Rows.Add (Row);
 463
 464                         AssertEquals ("test#01", 1, T.Select ("name = 'human' + 1").Length);
 465
 466                         AssertEquals ("test#02", "human1", T.Select ("name = 'human' + 1") [0] ["name"]);
 467                         AssertEquals ("test#03", 1, T.Select ("name = 'human' + '1'").Length);
 468                         AssertEquals ("test#04", "human1", T.Select ("name = 'human' + '1'") [0] ["name"]);
 469                         AssertEquals ("test#05", 1, T.Select ("name = 'human' + 1 + 2").Length);
 470                         AssertEquals ("test#06", "human12", T.Select ("name = 'human' + '1' + '2'") [0] ["name"]);
 471
 472                         AssertEquals ("test#07", 1, T.Select ("name = 'huMAn' + 1").Length);
 473
 474                         Set.CaseSensitive = true;
 475                         AssertEquals ("test#08", 0, T.Select ("name = 'huMAn' + 1").Length);
 476
 477                         T.CaseSensitive = false;
 478                         AssertEquals ("test#09", 1, T.Select ("name = 'huMAn' + 1").Length);
 479
 480                         T.CaseSensitive = true;
 481                         AssertEquals ("test#10", 0, T.Select ("name = 'huMAn' + 1").Length);
 482
 483                         Set.CaseSensitive = false;
 484                         AssertEquals ("test#11", 0, T.Select ("name = 'huMAn' + 1").Length);
 485
 486                         T.CaseSensitive = false;
 487                         AssertEquals ("test#12", 1, T.Select ("name = 'huMAn' + 1").Length);
 488
 489                         AssertEquals ("test#13", 0, T.Select ("name = 'human1*'").Length);
 490                         AssertEquals ("test#14", 11, T.Select ("name like 'human1*'").Length);
 491                         AssertEquals ("test#15", 11, T.Select ("name like 'human1%'").Length);
 492
 493                         try {
 494                                 AssertEquals ("test#16", 11, T.Select ("name like 'h*an1'").Length);
 495                                 Fail ("test#16");
 496                         } catch (Exception e) {
 497
 498                                 // 'h*an1' is invalid
 499                                 AssertEquals ("test#17", typeof (EvaluateException), e.GetType ());
 500                         }
 501
 502                         try {
 503                                 AssertEquals ("test#18", 11, T.Select ("name like 'h%an1'").Length);
 504                                 Fail ("test#19");
 505                         } catch (Exception e) {
 506
 507                                 // 'h%an1' is invalid
 508                                 AssertEquals ("test#20", typeof (EvaluateException), e.GetType ());
 509                         }
 510
 511                         AssertEquals ("test#21", 0, T.Select ("name like 'h[%]an'").Length);
 512                         AssertEquals ("test#22", 1, T.Select ("name like 'h[*]an'").Length);
 513
 514                 }
 515
 516                 [Test]
 517                 public void SelectAggregates ()
 518                 {
 519                         DataTable T = new DataTable ("test");
 520                         DataColumn C = new DataColumn ("name");
 521                         T.Columns.Add (C);
 522                         C = new DataColumn ("age");
 523                         C.DataType = typeof (int);
 524                         T.Columns.Add (C);
 525                         C = new DataColumn ("id");
 526                         T.Columns.Add (C);
 527                         DataRow Row = null;
 528
 529                         for (int i = 0; i < 1000; i++) {
 530                                 Row = T.NewRow ();
 531                                 Row [0] = "human" + i;
 532                                 Row [1] = i;
 533                                 Row [2] = i;
 534                                 T.Rows.Add (Row);
 535                         }
 536
 537                         AssertEquals ("test#01", 1000, T.Select ("Sum(age) > 10").Length);
 538                         AssertEquals ("test#02", 1000, T.Select ("avg(age) = 499").Length);
 539                         AssertEquals ("test#03", 1000, T.Select ("min(age) = 0").Length);
 540                         AssertEquals ("test#04", 1000, T.Select ("max(age) = 999").Length);
 541                         AssertEquals ("test#05", 1000, T.Select ("count(age) = 1000").Length);
 542                         AssertEquals ("test#06", 1000, T.Select ("stdev(age) > 287 and stdev(age) < 289").Length);
 543                         AssertEquals ("test#07", 1000, T.Select ("var(age) < 83417 and var(age) > 83416").Length);
 544                 }
 545
 546                 [Test]
 547                 public void SelectFunctions ()
 548                 {
 549                         DataTable T = new DataTable ("test");
 550                         DataColumn C = new DataColumn ("name");
 551                         T.Columns.Add (C);
 552                         C = new DataColumn ("age");
 553                         C.DataType = typeof (int);
 554                         T.Columns.Add (C);
 555                         C = new DataColumn ("id");
 556                         T.Columns.Add (C);
 557                         DataRow Row = null;
 558
 559                         for (int i = 0; i < 1000; i++) {
 560                                 Row = T.NewRow ();
 561                                 Row [0] = "human" + i;
 562                                 Row [1] = i;
 563                                 Row [2] = i;
 564                                 T.Rows.Add (Row);
 565                         }
 566
 567                         Row = T.NewRow ();
 568                         Row [0] = "human" + "test";
 569                         Row [1] = DBNull.Value;
 570                         Row [2] = DBNull.Value;
 571                         T.Rows.Add (Row);
 572
 573                         //TODO: How to test Convert-function
 574                         AssertEquals ("test#01", 25, T.Select ("age = 5*5") [0]["age"]);
 575                         AssertEquals ("test#02", 901, T.Select ("len(name) > 7").Length);
 576                         AssertEquals ("test#03", 125, T.Select ("age = 5*5*5 AND len(name)>7") [0]["age"]);
 577                         AssertEquals ("test#04", 1, T.Select ("isnull(id, 'test') = 'test'").Length);
 578                         AssertEquals ("test#05", 1000, T.Select ("iif(id = '56', 'test', 'false') = 'false'").Length);
 579                         AssertEquals ("test#06", 1, T.Select ("iif(id = '56', 'test', 'false') = 'test'").Length);
 580                         AssertEquals ("test#07", 9, T.Select ("substring(id, 2, 3) = '23'").Length);
 581                         AssertEquals ("test#08", "123", T.Select ("substring(id, 2, 3) = '23'") [0] ["id"]);
 582                         AssertEquals ("test#09", "423", T.Select ("substring(id, 2, 3) = '23'") [3] ["id"]);
 583                         AssertEquals ("test#10", "923", T.Select ("substring(id, 2, 3) = '23'") [8] ["id"]);
 584
 585                 }
 586
 587                 [Test]
 588                 public void SelectRelations ()
 589                 {
 590                         DataSet Set = new DataSet ();
 591                         DataTable Mom = new DataTable ("Mom");
 592                         DataTable Child = new DataTable ("Child");
 593
 594                         Set.Tables.Add (Mom);
 595                         Set.Tables.Add (Child);
 596
 597                         DataColumn Col = new DataColumn ("Name");
 598                         DataColumn Col2 = new DataColumn ("ChildName");
 599                         Mom.Columns.Add (Col);
 600                         Mom.Columns.Add (Col2);
 601
 602                         DataColumn Col3 = new DataColumn ("Name");
 603                         DataColumn Col4 = new DataColumn ("Age");
 604                         Col4.DataType = Type.GetType ("System.Int16");
 605                         Child.Columns.Add (Col3);
 606                         Child.Columns.Add (Col4);
 607
 608                         DataRelation Relation = new DataRelation ("Rel", Mom.Columns [1], Child.Columns [0]);
 609                         Set.Relations.Add (Relation);
 610
 611                         DataRow Row = Mom.NewRow ();
 612                         Row [0] = "Laura";
 613                         Row [1] = "Nick";
 614                         Mom.Rows.Add (Row);
 615
 616                         Row = Mom.NewRow ();
 617                         Row [0] = "Laura";
 618                         Row [1] = "Dick";
 619                         Mom.Rows.Add (Row);
 620
 621                         Row = Mom.NewRow ();
 622                         Row [0] = "Laura";
 623                         Row [1] = "Mick";
 624                         Mom.Rows.Add (Row);
 625
 626                         Row = Mom.NewRow ();
 627                         Row [0] = "Teresa";
 628                         Row [1] = "Jack";
 629                         Mom.Rows.Add (Row);
 630
 631                         Row = Mom.NewRow ();
 632                         Row [0] = "Teresa";
 633                         Row [1] = "Mack";
 634                         Mom.Rows.Add (Row);
 635
 636                         Row = Child.NewRow ();
 637                         Row [0] = "Nick";
 638                         Row [1] = 15;
 639                         Child.Rows.Add (Row);
 640
 641                         Row = Child.NewRow ();
 642                         Row [0] = "Dick";
 643                         Row [1] = 25;
 644                         Child.Rows.Add (Row);
 645
 646                         Row = Child.NewRow ();
 647                         Row [0] = "Mick";
 648                         Row [1] = 35;
 649                         Child.Rows.Add (Row);
 650
 651                         Row = Child.NewRow ();
 652                         Row [0] = "Jack";
 653                         Row [1] = 10;
 654                         Child.Rows.Add (Row);
 655
 656                         Row = Child.NewRow ();
 657                         Row [0] = "Mack";
 658                         Row [1] = 19;
 659                         Child.Rows.Add (Row);
 660
 661                         Row = Child.NewRow ();
 662                         Row [0] = "Mack";
 663                         Row [1] = 99;
 664                         Child.Rows.Add (Row);
 665
 666                         DataRow [] Rows = Child.Select ("name = Parent.Childname");
 667                         AssertEquals ("test#01", 6, Rows.Length);
 668                         Rows = Child.Select ("Parent.childname = 'Jack'");
 669                         AssertEquals ("test#02", 1, Rows.Length);
 670
 671                         /*
 672                         try {
 673                                 // FIXME: LAMESPEC: Why the exception is thrown why... why...
 674                                 Mom.Select ("Child.Name = 'Jack'");
 675                                 Fail ("test#03");
 676                         } catch (Exception e) {
 677                                 AssertEquals ("test#04", typeof (SyntaxErrorException), e.GetType ());
 678                                 AssertEquals ("test#05", "Cannot interpret token 'Child' at position 1.", e.Message);
 679                         }
 680                         */
 681
 682                         Rows = Child.Select ("Parent.name = 'Laura'");
 683                         AssertEquals ("test#06", 3, Rows.Length);
 684
 685                         DataTable Parent2 = new DataTable ("Parent2");
 686                         Col = new DataColumn ("Name");
 687                         Col2 = new DataColumn ("ChildName");
 688
 689                         Parent2.Columns.Add (Col);
 690                         Parent2.Columns.Add (Col2);
 691                         Set.Tables.Add (Parent2);
 692
 693                         Row = Parent2.NewRow ();
 694                         Row [0] = "Laura";
 695                         Row [1] = "Nick";
 696                         Parent2.Rows.Add (Row);
 697
 698                         Row = Parent2.NewRow ();
 699                         Row [0] = "Laura";
 700                         Row [1] = "Dick";
 701                         Parent2.Rows.Add (Row);
 702
 703                         Row = Parent2.NewRow ();
 704                         Row [0] = "Laura";
 705                         Row [1] = "Mick";
 706                         Parent2.Rows.Add (Row);
 707
 708                         Row = Parent2.NewRow ();
 709                         Row [0] = "Teresa";
 710                         Row [1] = "Jack";
 711                         Parent2.Rows.Add (Row);
 712
 713                         Row = Parent2.NewRow ();
 714                         Row [0] = "Teresa";
 715                         Row [1] = "Mack";
 716                         Parent2.Rows.Add (Row);
 717
 718                         Relation = new DataRelation ("Rel2", Parent2.Columns [1], Child.Columns [0]);
 719                         Set.Relations.Add (Relation);
 720
 721                         try {
 722                                 Rows = Child.Select ("Parent.ChildName = 'Jack'");
 723                                 Fail ("test#07");
 724                         } catch (Exception e) {
 725                                 AssertEquals ("test#08", typeof (EvaluateException), e.GetType ());
 726                                 //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);
 727                         }
 728
 729                         Rows = Child.Select ("Parent(rel).ChildName = 'Jack'");
 730                         AssertEquals ("test#10", 1, Rows.Length);
 731
 732                         Rows = Child.Select ("Parent(Rel2).ChildName = 'Jack'");
 733                         AssertEquals ("test#10", 1, Rows.Length);
 734
 735                         try {
 736                                 Mom.Select ("Parent.name  = 'John'");
 737                         } catch (Exception e) {
 738                                 AssertEquals ("test#11", typeof (IndexOutOfRangeException), e.GetType ());
 739                                 AssertEquals ("test#12", "Cannot find relation 0.", e.Message);
 740                         }
 741
 742                 }
 743
 744                 [Test]
 745                 public void SelectRowState()
 746                 {
 747                         DataTable d = new DataTable();
 748                         d.Columns.Add (new DataColumn ("aaa"));
 749                         DataRow [] rows = d.Select (null, null, DataViewRowState.Deleted);
 750                         AssertEquals(0, rows.Length);
 751                         d.Rows.Add (new object [] {"bbb"});
 752                         d.Rows.Add (new object [] {"bbb"});
 753                         rows = d.Select (null, null, DataViewRowState.Deleted);
 754                         AssertEquals(0, rows.Length);
 755                 }
 756
 757                 [Test]
 758                 public void ToStringTest()
 759                 {
 760                         DataTable dt = new DataTable();
 761                         dt.Columns.Add("Col1",typeof(int));
 762
 763                         dt.TableName = "Mytable";
 764                         dt.DisplayExpression = "Col1";
 765
 766
 767                         string cmpr = dt.TableName + " + " + dt.DisplayExpression;
 768                         AssertEquals(cmpr,dt.ToString());
 769                 }
 770
 771                 [Test]
 772                 public void PrimaryKey ()
 773                 {
 774                         DataTable dt = new DataTable ();
 775                         DataColumn Col = new DataColumn ();
 776                         Col.AllowDBNull = false;
 777                         Col.DataType = typeof (int);
 778                         dt.Columns.Add (Col);
 779                         dt.Columns.Add ();
 780                         dt.Columns.Add ();
 781                         dt.Columns.Add ();
 782
 783                         AssertEquals ("test#01", 0, dt.PrimaryKey.Length);
 784
 785                         dt.PrimaryKey = new DataColumn [] {dt.Columns [0]};
 786                         AssertEquals ("test#02", 1, dt.PrimaryKey.Length);
 787                         AssertEquals ("test#03", "Column1", dt.PrimaryKey [0].ColumnName);
 788
 789                         dt.PrimaryKey = null;
 790                         AssertEquals ("test#04", 0, dt.PrimaryKey.Length);
 791
 792                         Col = new DataColumn ("failed");
 793
 794                         try {
 795                                 dt.PrimaryKey = new DataColumn [] {Col};
 796                                 Fail ("test#05");
 797                         } catch (Exception e) {
 798                                 AssertEquals ("test#06", typeof (ArgumentException), e.GetType ());
 799                                 AssertEquals ("test#07", "Column must belong to a table.", e.Message);
 800                         }
 801
 802                         DataTable dt2 = new DataTable ();
 803                         dt2.Columns.Add ();
 804
 805                         try {
 806                                 dt.PrimaryKey = new DataColumn [] {dt2.Columns [0]};
 807                                 Fail ("test#08");
 808                         } catch (Exception e) {
 809                                 AssertEquals ("test#09", typeof (ArgumentException), e.GetType ());
 810                                 AssertEquals ("test#10", "PrimaryKey columns do not belong to this table.", e.Message);
 811                         }
 812
 813
 814                         AssertEquals ("test#11", 0, dt.Constraints.Count);
 815
 816                         dt.PrimaryKey = new DataColumn [] {dt.Columns [0], dt.Columns [1]};
 817                         AssertEquals ("test#12", 2, dt.PrimaryKey.Length);
 818                         AssertEquals ("test#13", 1, dt.Constraints.Count);
 819                         AssertEquals ("test#14", true, dt.Constraints [0] is UniqueConstraint);
 820                         AssertEquals ("test#15", "Column1", dt.PrimaryKey [0].ColumnName);
 821                         AssertEquals ("test#16", "Column2", dt.PrimaryKey [1].ColumnName);
 822
 823                 }
 824
 825                 [Test]
 826                 public void PropertyExceptions ()
 827                 {
 828                         DataSet set = new DataSet ();
 829                         DataTable table = new DataTable ();
 830                         DataTable table1 =  new DataTable ();
 831                         set.Tables.Add (table);
 832                         set.Tables.Add (table1);
 833
 834                         DataColumn col = new DataColumn ();
 835                         col.ColumnName = "Id";
 836                         col.DataType = Type.GetType ("System.Int32");
 837                         table.Columns.Add (col);
 838                         UniqueConstraint uc = new UniqueConstraint ("UK1", table.Columns[0] );
 839                         table.Constraints.Add (uc);
 840                         table.CaseSensitive = false;
 841
 842                         col = new DataColumn ();
 843                         col.ColumnName = "Name";
 844                         col.DataType = Type.GetType ("System.String");
 845                         table.Columns.Add (col);
 846
 847                         col = new DataColumn ();
 848                         col.ColumnName = "Id";
 849                         col.DataType = Type.GetType ("System.Int32");
 850                         table1.Columns.Add (col);
 851                         col = new DataColumn ();
 852                         col.ColumnName = "Name";
 853                         col.DataType = Type.GetType ("System.String");
 854                         table1.Columns.Add (col);
 855
 856                         DataRelation dr = new DataRelation ("DR", table.Columns[0], table1.Columns[0]);
 857                         set.Relations.Add (dr);
 858
 859                         try {
 860                                 table.CaseSensitive = true;
 861                                 table1.CaseSensitive = true;
 862                                 Fail ("#A01");
 863                         }
 864                         catch (Exception e) {
 865                                 if (e.GetType () != typeof (AssertionException))
 866                                         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);
 867                                 else
 868                                         Console.WriteLine (e);
 869                         }
 870                         try {
 871                                 CultureInfo cultureInfo = new CultureInfo ("en-gb");
 872                                 table.Locale = cultureInfo;
 873                                 table1.Locale = cultureInfo;
 874                                 Fail ("#A03");
 875                         }
 876                         catch (Exception e) {
 877                                  if (e.GetType () != typeof (AssertionException))
 878                                         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);
 879                                 else
 880                                         Console.WriteLine (e);
 881                         }
 882                         try {
 883                                 table.Prefix = "Prefix#1";
 884                                 Fail ("#A05");
 885                         }
 886                         catch (Exception e){
 887                                 if (e.GetType () != typeof (AssertionException))
 888                                         AssertEquals ("#A06", "Prefix 'Prefix#1' is not valid, because it contains special characters.",e.Message);
 889                                 else
 890                                         Console.WriteLine (e);
 891
 892                         }
 893                 }
 894
 895                 [Test]
 896                 public void GetErrors ()
 897                 {
 898                         DataTable table = new DataTable ();
 899
 900                         DataColumn col = new DataColumn ();
 901                         col.ColumnName = "Id";
 902                         col.DataType = Type.GetType ("System.Int32");
 903                         table.Columns.Add (col);
 904
 905                         col = new DataColumn ();
 906                         col.ColumnName = "Name";
 907                         col.DataType = Type.GetType ("System.String");
 908                         table.Columns.Add (col);
 909
 910                         DataRow row = table.NewRow ();
 911                         row ["Id"] = 147;
 912                         row ["name"] = "Abc";
 913                         row.RowError = "Error#1";
 914                         table.Rows.Add (row);
 915
 916                         AssertEquals ("#A01", 1, table.GetErrors ().Length);
 917                         AssertEquals ("#A02", "Error#1", (table.GetErrors ())[0].RowError);
 918                 }
 919 #if NET_2_0
 920                 [Test]
 921                 public void NewRowAddedTest ()
 922                 {
 923                         DataTable table = new DataTable ();
 924
 925                         DataColumn col = new DataColumn ();
 926                         col.ColumnName = "Id";
 927                         col.DataType = Type.GetType ("System.Int32");
 928                         table.Columns.Add (col);
 929
 930                         col = new DataColumn ();
 931                         col.ColumnName = "Name";
 932                         col.DataType = Type.GetType ("System.String");
 933                         table.Columns.Add (col);
 934
 935                         _tableNewRowAddedEventFired = false;
 936                         table.TableNewRow += new DataTableNewRowEventHandler (OnTableNewRowAdded);
 937                         DataRow row = table.NewRow ();
 938                         row ["Id"] = 147;
 939                         row ["name"] = "Abc";
 940                         table.Rows.Add (row);
 941
 942                         AssertEquals ("#NewRowAdded Event #01", true, _tableNewRowAddedEventFired);
 943                 }
 944 #endif
 945                 [Test]
 946                 public void CloneCopyTest ()
 947                 {
 948                         DataTable table = new DataTable ();
 949                         table.TableName = "Table#1";
 950                         DataTable table1 = new DataTable ();
 951                         table1.TableName = "Table#2";
 952
 953                         table.AcceptChanges ();
 954
 955                         DataSet set = new DataSet ("Data Set#1");
 956                         set.DataSetName = "Dataset#1";
 957                         set.Tables.Add (table);
 958                         set.Tables.Add (table1);
 959
 960                         DataColumn col = new DataColumn ();
 961                         col.ColumnName = "Id";
 962                         col.DataType = Type.GetType ("System.Int32");
 963                         table.Columns.Add (col);
 964                         UniqueConstraint uc = new UniqueConstraint ("UK1", table.Columns[0] );
 965                         table.Constraints.Add (uc);
 966
 967                         col = new DataColumn ();
 968                         col.ColumnName = "Id";
 969                         col.DataType = Type.GetType ("System.Int32");
 970                         table1.Columns.Add (col);
 971
 972                         col = new DataColumn ();
 973                         col.ColumnName = "Name";
 974                         col.DataType = Type.GetType ("System.String");
 975                         table.Columns.Add (col);
 976
 977                         col = new DataColumn ();
 978                         col.ColumnName = "Name";
 979                         col.DataType = Type.GetType ("System.String");
 980                         table1.Columns.Add (col);
 981                         DataRow row = table.NewRow ();
 982                         row ["Id"] = 147;
 983                         row ["name"] = "Abc";
 984                         row.RowError = "Error#1";
 985                         table.Rows.Add (row);
 986
 987                         row = table.NewRow ();
 988                         row ["Id"] = 47;
 989                         row ["name"] = "Efg";
 990                         table.Rows.Add (row);
 991                         table.AcceptChanges ();
 992
 993                         table.CaseSensitive = true;
 994                         table1.CaseSensitive = true;
 995                         table.MinimumCapacity = 100;
 996                         table.Prefix = "PrefixNo:1";
 997                         table.Namespace = "Namespace#1";
 998                         table.DisplayExpression = "Id / Name + (Id * Id)";
 999                         DataColumn[] colArray = {table.Columns[0]};
1000                         table.PrimaryKey = colArray;
1001                         table.ExtendedProperties.Add ("TimeStamp", DateTime.Now);
1002 #if NET_1_1 // This prevents further tests after .NET 1.1.
1003 #else
1004                         CultureInfo cultureInfo = new CultureInfo ("en-gb");
1005                         table.Locale = cultureInfo;
1006 #endif
1007
1008                         row = table1.NewRow ();
1009                         row ["Name"] = "Abc";
1010                         row ["Id"] = 147;
1011                         table1.Rows.Add (row);
1012
1013                         row = table1.NewRow ();
1014                         row ["Id"] = 47;
1015                         row ["Name"] = "Efg";
1016                         table1.Rows.Add (row);
1017
1018                         DataRelation dr = new DataRelation ("DR", table.Columns[0], table1.Columns[0]);
1019                         set.Relations.Add (dr);
1020
1021                         //Testing properties of clone
1022                         DataTable cloneTable = table.Clone ();
1023                         AssertEquals ("#A01",true ,cloneTable.CaseSensitive);
1024                         AssertEquals ("#A02", 0 , cloneTable.ChildRelations.Count);
1025                         AssertEquals ("#A03", 0 , cloneTable.ParentRelations.Count);
1026                         AssertEquals ("#A04", 2,  cloneTable.Columns.Count);
1027                         AssertEquals ("#A05", 1, cloneTable.Constraints.Count);
1028                         AssertEquals ("#A06", "Id / Name + (Id * Id)", cloneTable.DisplayExpression);
1029                         AssertEquals ("#A07", 1 ,cloneTable.ExtendedProperties.Count);
1030                         AssertEquals ("#A08", false ,cloneTable.HasErrors);
1031 #if NET_1_1
1032 #else
1033                         AssertEquals ("#A09", 2057, cloneTable.Locale.LCID);
1034 #endif
1035                         AssertEquals ("#A10", 100, cloneTable.MinimumCapacity);
1036                         AssertEquals ("#A11","Namespace#1", cloneTable.Namespace);
1037                         AssertEquals ("#A12", "PrefixNo:1",cloneTable.Prefix);
1038                         AssertEquals ("#A13", "Id",  cloneTable.PrimaryKey[0].ColumnName);
1039                         AssertEquals ("#A14",0 , cloneTable.Rows.Count );
1040                         AssertEquals ("#A15", "Table#1", cloneTable.TableName);
1041
1042                         //Testing properties of copy
1043                         DataTable copyTable = table.Copy ();
1044                         AssertEquals ("#A16",true ,copyTable.CaseSensitive);
1045                         AssertEquals ("#A17", 0 , copyTable.ChildRelations.Count);
1046                         AssertEquals ("#A18", 0 , copyTable.ParentRelations.Count);
1047                         AssertEquals ("#A19", 2,  copyTable.Columns.Count);
1048                         AssertEquals ("#A20", 1, copyTable.Constraints.Count);
1049                         AssertEquals ("#A21", "Id / Name + (Id * Id)", copyTable.DisplayExpression);
1050                         AssertEquals ("#A22", 1 ,copyTable.ExtendedProperties.Count);
1051                         AssertEquals ("#A23", true ,copyTable.HasErrors);
1052 #if NET_1_1
1053 #else
1054                         AssertEquals ("#A24", 2057, copyTable.Locale.LCID);
1055 #endif
1056                         AssertEquals ("#A25", 100, copyTable.MinimumCapacity);
1057                         AssertEquals ("#A26","Namespace#1", copyTable.Namespace);
1058                         AssertEquals ("#A27", "PrefixNo:1",copyTable.Prefix);
1059                         AssertEquals ("#A28", "Id",  copyTable.PrimaryKey[0].ColumnName);
1060                         AssertEquals ("#A29", 2 , copyTable.Rows.Count );
1061                         AssertEquals ("#A30", "Table#1", copyTable.TableName);
1062                 }
1063
1064                 [Test]
1065                 public void LoadDataException ()
1066                 {
1067                         DataTable table = new DataTable ();
1068                         DataColumn col = new DataColumn ();
1069                         col.ColumnName = "Id";
1070                         col.DataType = Type.GetType ("System.Int32");
1071                         col.DefaultValue = 47;
1072                         table.Columns.Add (col);
1073                         UniqueConstraint uc = new UniqueConstraint ("UK1", table.Columns[0] );
1074                         table.Constraints.Add (uc);
1075
1076                         col = new DataColumn ();
1077                         col.ColumnName = "Name";
1078                         col.DataType = Type.GetType ("System.String");
1079                         col.DefaultValue = "Hello";
1080                         table.Columns.Add (col);
1081
1082                         table.BeginLoadData();
1083                         object[] row = {147, "Abc"};
1084                         DataRow newRow = table.LoadDataRow (row, true);
1085
1086                         object[] row1 = {147, "Efg"};
1087                         DataRow newRow1 = table.LoadDataRow (row1, true);
1088
1089                         object[] row2 = {143, "Hij"};
1090                         DataRow newRow2 = table.LoadDataRow (row2, true);
1091
1092                         try {
1093                                 table.EndLoadData ();
1094                                 Fail ("#A01");
1095                         }
1096                         catch (ConstraintException) {
1097                         }
1098                 }
1099                 [Test]
1100                 public void Changes () //To test GetChanges and RejectChanges
1101                 {
1102                         DataTable table = new DataTable ();
1103
1104                         DataColumn col = new DataColumn ();
1105                         col.ColumnName = "Id";
1106                         col.DataType = Type.GetType ("System.Int32");
1107                         table.Columns.Add (col);
1108                         UniqueConstraint uc = new UniqueConstraint ("UK1", table.Columns[0] );
1109                         table.Constraints.Add (uc);
1110
1111                         col = new DataColumn ();
1112                         col.ColumnName = "Name";
1113                         col.DataType = Type.GetType ("System.String");
1114                         table.Columns.Add (col);
1115
1116                         DataRow row = table.NewRow ();
1117                         row ["Id"] = 147;
1118                         row ["name"] = "Abc";
1119                         table.Rows.Add (row);
1120                         table.AcceptChanges ();
1121
1122                         row = table.NewRow ();
1123                         row ["Id"] = 47;
1124                         row ["name"] = "Efg";
1125                         table.Rows.Add (row);
1126
1127                         //Testing GetChanges
1128                         DataTable changesTable = table.GetChanges ();
1129                         AssertEquals ("#A01", 1 ,changesTable.Rows.Count);
1130                         AssertEquals ("#A02","Efg" ,changesTable.Rows[0]["Name"]);
1131                         table.AcceptChanges ();
1132                         changesTable = table.GetChanges ();
1133                         try {
1134                                 int cnt = changesTable.Rows.Count;
1135                         }
1136                         catch(Exception e) {
1137                                 if (e.GetType () != typeof (AssertionException))
1138                                         AssertEquals ("#A03",typeof(NullReferenceException) ,e.GetType ());
1139                                 else
1140                                         Console.WriteLine (e);
1141                         }
1142
1143                         //Testing RejectChanges
1144                         row = table.NewRow ();
1145                         row ["Id"] = 247;
1146                         row ["name"] = "Hij";
1147                         table.Rows.Add (row);
1148
1149                         (table.Rows [0])["Name"] = "AaBbCc";
1150                         table.RejectChanges ();
1151                         AssertEquals ("#A03", "Abc" , (table.Rows [0]) ["Name"]);
1152                         AssertEquals ("#A04", 2, table.Rows.Count);
1153                 }
1154
1155                 [Test]
1156                 public void ImportRowTest ()
1157                 {
1158                         // build source table
1159                         DataTable src = new DataTable ();
1160                         src.Columns.Add ("id", typeof (int));
1161                         src.Columns.Add ("name", typeof (string));
1162
1163                         src.PrimaryKey = new DataColumn [] {src.Columns [0]} ;
1164
1165                         src.Rows.Add (new object [] { 1, "mono 1" });
1166                         src.Rows.Add (new object [] { 2, "mono 2" });
1167                         src.Rows.Add (new object [] { 3, "mono 3" });
1168                         src.AcceptChanges ();
1169
1170                         src.Rows [0] [1] = "mono changed 1";  // modify 1st row
1171                         src.Rows [1].Delete ();              // delete 2nd row
1172                         // 3rd row is unchanged
1173                         src.Rows.Add (new object [] { 4, "mono 4" }); // add 4th row
1174
1175                         // build target table
1176                         DataTable target = new DataTable ();
1177                         target.Columns.Add ("id", typeof (int));
1178                         target.Columns.Add ("name", typeof (string));
1179
1180                         target.PrimaryKey = new DataColumn [] {target.Columns [0]} ;
1181
1182                         // import all rows
1183                         target.ImportRow (src.Rows [0]);     // import 1st row
1184                         target.ImportRow (src.Rows [1]);     // import 2nd row
1185                         target.ImportRow (src.Rows [2]);     // import 3rd row
1186                         target.ImportRow (src.Rows [3]);     // import 4th row
1187
1188                         try {
1189                                 target.ImportRow (src.Rows [2]); // import 3rd row again
1190                                 Fail ("#AA1 Should have thrown exception violativ PK");
1191                         } catch (ConstraintException e) {}
1192
1193                         // check row states
1194                         AssertEquals ("#A1", src.Rows [0].RowState, target.Rows [0].RowState);
1195                         AssertEquals ("#A2", src.Rows [1].RowState, target.Rows [1].RowState);
1196                         AssertEquals ("#A3", src.Rows [2].RowState, target.Rows [2].RowState);
1197                         AssertEquals ("#A4", src.Rows [3].RowState, target.Rows [3].RowState);
1198
1199                         // check for modified row (1st row)
1200                         AssertEquals ("#B1", (string) src.Rows [0] [1], (string) target.Rows [0] [1]);
1201                         AssertEquals ("#B2", (string) src.Rows [0] [1, DataRowVersion.Default], (string) target.Rows [0] [1, DataRowVersion.Default]);
1202                         AssertEquals ("#B3", (string) src.Rows [0] [1, DataRowVersion.Original], (string) target.Rows [0] [1, DataRowVersion.Original]);
1203                         AssertEquals ("#B4", (string) src.Rows [0] [1, DataRowVersion.Current], (string) target.Rows [0] [1, DataRowVersion.Current]);
1204                         AssertEquals ("#B5", false, target.Rows [0].HasVersion(DataRowVersion.Proposed));
1205
1206                         // check for deleted row (2nd row)
1207                         AssertEquals ("#C1", (string) src.Rows [1] [1, DataRowVersion.Original], (string) target.Rows [1] [1, DataRowVersion.Original]);
1208
1209                         // check for unchanged row (3rd row)
1210                         AssertEquals ("#D1", (string) src.Rows [2] [1], (string) target.Rows [2] [1]);
1211                         AssertEquals ("#D2", (string) src.Rows [2] [1, DataRowVersion.Default], (string) target.Rows [2] [1, DataRowVersion.Default]);
1212                         AssertEquals ("#D3", (string) src.Rows [2] [1, DataRowVersion.Original], (string) target.Rows [2] [1, DataRowVersion.Original]);
1213                         AssertEquals ("#D4", (string) src.Rows [2] [1, DataRowVersion.Current], (string) target.Rows [2] [1, DataRowVersion.Current]);
1214
1215                         // check for newly added row (4th row)
1216                         AssertEquals ("#E1", (string) src.Rows [3] [1], (string) target.Rows [3] [1]);
1217                         AssertEquals ("#E2", (string) src.Rows [3] [1, DataRowVersion.Default], (string) target.Rows [3] [1, DataRowVersion.Default]);
1218                         AssertEquals ("#E3", (string) src.Rows [3] [1, DataRowVersion.Current], (string) target.Rows [3] [1, DataRowVersion.Current]);
1219                 }
1220
1221                 [Test]
1222                 public void ImportRowDetachedTest ()
1223                 {
1224                         DataTable table = new DataTable ();
1225                         DataColumn col = new DataColumn ();
1226                         col.ColumnName = "Id";
1227                         col.DataType = Type.GetType ("System.Int32");
1228                         table.Columns.Add (col);
1229
1230                         table.PrimaryKey = new DataColumn [] {col};
1231
1232                         col = new DataColumn ();
1233                         col.ColumnName = "Name";
1234                         col.DataType = Type.GetType ("System.String");
1235                         table.Columns.Add (col);
1236
1237                         DataRow row = table.NewRow ();
1238                         row ["Id"] = 147;
1239                         row ["name"] = "Abc";
1240
1241                         // keep silent as ms.net ;-), though this is not useful.
1242                         table.ImportRow (row);
1243
1244                         //if RowState is detached, then dont import the row.
1245                         AssertEquals ("#1", 0, table.Rows.Count);
1246                 }
1247
1248                 [Test]
1249                 public void ImportRowDeletedTest ()
1250                 {
1251                         DataTable table = new DataTable ();
1252                         table.Columns.Add ("col", typeof (int));
1253                         table.Columns.Add ("col1", typeof (int));
1254
1255                         DataRow row = table.Rows.Add (new object[] {1,2});
1256                         table.PrimaryKey = new DataColumn[] {table.Columns[0]};
1257                         table.AcceptChanges ();
1258
1259                         // If row is in Deleted state, then ImportRow loads the
1260                         // row.
1261                         row.Delete ();
1262                         table.ImportRow (row);
1263                         AssertEquals ("#1", 2, table.Rows.Count);
1264
1265                         // Both the deleted rows shud be now gone
1266                         table.AcceptChanges ();
1267                         AssertEquals ("#2", 0, table.Rows.Count);
1268
1269                         //just add another row
1270                         row = table.Rows.Add (new object[] {1,2});
1271                         // no exception shud be thrown
1272                         table.AcceptChanges ();
1273
1274                         // If row is in Deleted state, then ImportRow loads the
1275                         // row and validate only on RejectChanges
1276                         row.Delete ();
1277                         table.ImportRow (row);
1278                         AssertEquals ("#3", 2, table.Rows.Count);
1279                         AssertEquals ("#4", DataRowState.Deleted, table.Rows[1].RowState);
1280
1281                         try {
1282                                 table.RejectChanges ();
1283                                 Fail ("#5");
1284                         } catch (ConstraintException e) {
1285                         }
1286                 }
1287
1288                 [Test]
1289                 public void ClearReset () //To test Clear and Reset methods
1290                 {
1291                         DataTable table = new DataTable ("table");
1292                         DataTable table1 = new DataTable ("table1");
1293
1294                         DataSet set = new DataSet ();
1295                         set.Tables.Add (table);
1296                         set.Tables.Add (table1);
1297
1298                         table.Columns.Add ("Id", typeof (int));
1299                         table.Columns.Add ("Name", typeof (string));
1300                         table.Constraints.Add (new UniqueConstraint ("UK1", table.Columns [0]));
1301                         table.CaseSensitive = false;
1302
1303                         table1.Columns.Add ("Id", typeof (int));
1304                         table1.Columns.Add ("Name", typeof (string));
1305
1306                         DataRelation dr = new DataRelation ("DR", table.Columns[0], table1.Columns[0]);
1307                         set.Relations.Add (dr);
1308
1309                         DataRow row = table.NewRow ();
1310                         row ["Id"] = 147;
1311                         row ["name"] = "Roopa";
1312                         table.Rows.Add (row);
1313
1314                         row = table.NewRow ();
1315                         row ["Id"] = 47;
1316                         row ["Name"] = "roopa";
1317                         table.Rows.Add (row);
1318
1319                         AssertEquals (2, table.Rows.Count);
1320                         AssertEquals (1, table.ChildRelations.Count);
1321                         try {
1322                                 table.Reset ();
1323                                 Fail ("#A01, should have thrown ArgumentException");
1324                         }
1325                         catch (ArgumentException) {
1326                         }
1327                         AssertEquals ("#CT01", 0, table.Rows.Count);
1328                         AssertEquals ("#CT02", 0, table.ChildRelations.Count);
1329                         AssertEquals ("#CT03", 0, table.ParentRelations.Count);
1330                         AssertEquals ("#CT04", 0, table.Constraints.Count);
1331
1332                         table1.Reset ();
1333                         AssertEquals ("#A05", 0, table1.Rows.Count);
1334                         AssertEquals ("#A06", 0, table1.Constraints.Count);
1335                         AssertEquals ("#A07", 0, table1.ParentRelations.Count);
1336
1337                         // clear test
1338                         table.Clear ();
1339                         AssertEquals ("#A08", 0, table.Rows.Count);
1340 #if NET_1_1
1341                         AssertEquals ("#A09", 0, table.Constraints.Count);
1342 #else
1343                         AssertEquals ("#A09", 1, table.Constraints.Count);
1344 #endif
1345                         AssertEquals ("#A10", 0, table.ChildRelations.Count);
1346
1347                 }
1348
1349                 [Test]
1350                 public void ClearTest ()
1351                 {
1352                         DataTable table = new DataTable ("test");
1353                         table.Columns.Add ("id", typeof (int));
1354                         table.Columns.Add ("name", typeof (string));
1355
1356                         table.PrimaryKey = new DataColumn [] { table.Columns [0] } ;
1357
1358                         table.Rows.Add (new object [] { 1, "mono 1" });
1359                         table.Rows.Add (new object [] { 2, "mono 2" });
1360                         table.Rows.Add (new object [] { 3, "mono 3" });
1361                         table.Rows.Add (new object [] { 4, "mono 4" });
1362
1363                         table.AcceptChanges ();
1364 #if NET_2_0
1365                         _tableClearedEventFired = false;
1366                         table.TableCleared += new DataTableClearEventHandler (OnTableCleared);
1367                         _tableClearingEventFired = false;
1368                         table.TableClearing += new DataTableClearEventHandler (OnTableClearing);
1369 #endif // NET_2_0
1370
1371                         table.Clear ();
1372 #if NET_2_0
1373                         AssertEquals ("#3 should have fired cleared event", true, _tableClearingEventFired);
1374                         AssertEquals ("#0 should have fired cleared event", true, _tableClearedEventFired);
1375 #endif // NET_2_0
1376
1377                         DataRow r = table.Rows.Find (1);
1378                         AssertEquals ("#1 should have cleared", true, r == null);
1379
1380                         // try adding new row. indexes should have cleared
1381                         table.Rows.Add (new object [] { 2, "mono 2" });
1382                         AssertEquals ("#2 should add row", 1, table.Rows.Count);
1383                 }
1384 #if NET_2_0
1385                 private bool _tableClearedEventFired = false;
1386                 private void OnTableCleared (object src, DataTableClearEventArgs args)
1387                 {
1388                         _tableClearedEventFired = true;
1389                 }
1390                 private bool _tableClearingEventFired = false;
1391                 private void OnTableClearing (object src, DataTableClearEventArgs args)
1392                 {
1393                         _tableClearingEventFired = true;
1394                 }
1395                 private bool _tableNewRowAddedEventFired = false;
1396                 private void OnTableNewRowAdded (object src, DataTableNewRowEventArgs args)
1397                 {
1398                         _tableNewRowAddedEventFired = true;
1399                 }
1400 #endif // NET_2_0
1401
1402
1403 #if NET_2_0
1404                 [Test]
1405                 public void TestWriteXmlSchema1 ()
1406                 {
1407                         DataTable dt = new DataTable("TestWriteXmlSchema");
1408                         dt.Columns.Add("Col1", typeof(int));
1409                         dt.Columns.Add("Col2", typeof(int));
1410                         DataRow dr = dt.NewRow();
1411                         dr[0] = 10;
1412                         dr[1] = 20;
1413                         dt.Rows.Add (dr);
1414                         DataTable dt1 = new DataTable("HelloWorld");
1415                         dt1.Columns.Add("T1", typeof(int));
1416                         dt1.Columns.Add("T2", typeof(int));
1417                         DataRow dr1 = dt1.NewRow();
1418                         dr1[0] = 10;
1419                         dr1[1] = 20;
1420                         dt1.Rows.Add(dr1);
1421                         TextWriter writer = new StringWriter ();
1422                         dt.WriteXmlSchema (writer);
1423                         string TextString = writer.ToString ();
1424                         string substring = TextString.Substring (0, TextString.IndexOf(EOL));
1425                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1426                         AssertEquals ("test#01", "<?xml version=\"1.0\" encoding=\"utf-16\"?>", substring);
1427
1428                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1429                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1430                         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);
1431                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1432                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1433                         AssertEquals ("test#03", "  <xs:element name=\"NewDataSet\" msdata:IsDataSet=\"true\" msdata:MainDataTable=\"TestWriteXmlSchema\" msdata:UseCurrentLocale=\"true\">", substring);
1434                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1435                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1436                         AssertEquals ("test#04", "    <xs:complexType>", substring);
1437
1438                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1439                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1440                         AssertEquals ("test#05", "      <xs:choice minOccurs=\"0\" maxOccurs=\"unbounded\">", substring);
1441
1442                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1443                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1444                         AssertEquals ("test#06", "        <xs:element name=\"TestWriteXmlSchema\">", substring);
1445
1446                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1447                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1448                         AssertEquals ("test#07", "          <xs:complexType>", substring);
1449
1450                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1451                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1452                         AssertEquals ("test#08", "            <xs:sequence>", substring);
1453
1454                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1455                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1456                         AssertEquals ("test#09", "              <xs:element name=\"Col1\" type=\"xs:int\" minOccurs=\"0\" />", substring);
1457
1458                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1459                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1460                         AssertEquals ("test#10", "              <xs:element name=\"Col2\" type=\"xs:int\" minOccurs=\"0\" />", substring);
1461
1462                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1463                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1464                         AssertEquals ("test#11", "            </xs:sequence>", substring);
1465
1466                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1467                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1468                         AssertEquals ("test#12", "          </xs:complexType>", substring);
1469
1470                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1471                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1472                         AssertEquals ("test#13", "        </xs:element>", substring);
1473
1474
1475                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1476                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1477                         AssertEquals ("test#14", "      </xs:choice>", substring);
1478
1479                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1480                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1481                         AssertEquals ("test#15", "    </xs:complexType>", substring);
1482
1483                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1484                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1485                         AssertEquals ("test#16", "  </xs:element>", substring);
1486                         AssertEquals ("test#17", "</xs:schema>", TextString);
1487                 }
1488                 [Test]
1489                 public void TestWriteXmlSchema2()
1490                 {
1491                         DataTable dt = new DataTable("TestWriteXmlSchema");
1492                         dt.Columns.Add("Col1", typeof(int));
1493                         dt.Columns.Add("Col2", typeof(int));
1494                         DataRow dr = dt.NewRow();
1495                         dr[0] = 10;
1496                         dr[1] = 20;
1497                         dt.Rows.Add (dr);
1498                         DataTable dt1 = new DataTable("HelloWorld");
1499                         dt1.Columns.Add("T1", typeof(int));
1500                         dt1.Columns.Add("T2", typeof(int));
1501                         DataRow dr1 = dt1.NewRow();
1502                         dr1[0] = 10;
1503                         dr1[1] = 20;
1504                         dt1.Rows.Add(dr1);
1505                         DataSet ds = new DataSet();
1506                         ds.Tables.Add(dt);
1507                         ds.Tables.Add(dt1);
1508                         DataRelation rel = new DataRelation("Relation1", dt.Columns["Col1"], dt1.Columns["T1"]);
1509                         ds.Relations.Add(rel);
1510                         TextWriter writer = new StringWriter ();
1511                         dt.WriteXmlSchema (writer);
1512                         string TextString = writer.ToString ();
1513                         string substring = TextString.Substring (0, TextString.IndexOf(EOL));
1514                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1515                         AssertEquals ("test#01", "<?xml version=\"1.0\" encoding=\"utf-16\"?>", substring);
1516
1517                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1518                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1519                         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);
1520                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1521                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1522                         AssertEquals ("test#03", "  <xs:element name=\"NewDataSet\" msdata:IsDataSet=\"true\" msdata:MainDataTable=\"TestWriteXmlSchema\" msdata:UseCurrentLocale=\"true\">", substring);
1523                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1524                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1525                         AssertEquals ("test#04", "    <xs:complexType>", substring);
1526
1527                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1528                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1529                         AssertEquals ("test#05", "      <xs:choice minOccurs=\"0\" maxOccurs=\"unbounded\">", substring);
1530
1531                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1532                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1533                         AssertEquals ("test#06", "        <xs:element name=\"TestWriteXmlSchema\">", substring);
1534
1535                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1536                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1537                         AssertEquals ("test#07", "          <xs:complexType>", substring);
1538
1539                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1540                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1541                         AssertEquals ("test#08", "            <xs:sequence>", substring);
1542
1543                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1544                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1545                         AssertEquals ("test#09", "              <xs:element name=\"Col1\" type=\"xs:int\" minOccurs=\"0\" />", substring);
1546
1547                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1548                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1549                         AssertEquals ("test#10", "              <xs:element name=\"Col2\" type=\"xs:int\" minOccurs=\"0\" />", substring);
1550
1551                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1552                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1553                         AssertEquals ("test#11", "            </xs:sequence>", substring);
1554
1555                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1556                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1557                         AssertEquals ("test#12", "          </xs:complexType>", substring);
1558
1559                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1560                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1561                         AssertEquals ("test#13", "        </xs:element>", substring);
1562
1563                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1564                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1565                         AssertEquals ("test#14", "      </xs:choice>", substring);
1566
1567                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1568                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1569                         AssertEquals ("test#15", "    </xs:complexType>", substring);
1570
1571                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1572                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1573                         AssertEquals ("test#16", "    <xs:unique name=\"Constraint1\">", substring);
1574
1575                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1576                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1577                         AssertEquals ("test#17", "      <xs:selector xpath=\".//TestWriteXmlSchema\" />", substring);
1578
1579                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1580                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1581                         AssertEquals ("test#18", "      <xs:field xpath=\"Col1\" />", substring);
1582
1583                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1584                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1585                         AssertEquals ("test#19", "    </xs:unique>", substring);
1586
1587                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1588                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1589                         AssertEquals ("test#20", "  </xs:element>", substring);
1590                         AssertEquals ("test#21", "</xs:schema>", TextString);
1591                 }
1592                 [Test]
1593                 public void TestWriteXmlSchema3()
1594                 {
1595                         DataTable dt = new DataTable("TestWriteXmlSchema");
1596                         dt.Columns.Add("Col1", typeof(int));
1597                         dt.Columns.Add("Col2", typeof(int));
1598                         DataRow dr = dt.NewRow();
1599                         dr[0] = 10;
1600                         dr[1] = 20;
1601                         dt.Rows.Add (dr);
1602                         DataTable dt1 = new DataTable("HelloWorld");
1603                         dt1.Columns.Add("T1", typeof(int));
1604                         dt1.Columns.Add("T2", typeof(int));
1605                         DataRow dr1 = dt1.NewRow();
1606                         dr1[0] = 10;
1607                         dr1[1] = 20;
1608                         dt1.Rows.Add(dr1);
1609                         DataSet ds = new DataSet();
1610                         ds.Tables.Add(dt);
1611                         ds.Tables.Add(dt1);
1612                         DataRelation rel = new DataRelation("Relation1", dt.Columns["Col1"], dt1.Columns["T1"]);
1613                         ds.Relations.Add(rel);
1614                         TextWriter writer = new StringWriter ();
1615                         dt.WriteXmlSchema (writer, true);
1616                         string TextString = writer.ToString ();
1617                         string substring = TextString.Substring (0, TextString.IndexOf(EOL));
1618                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1619                         AssertEquals ("test#01", "<?xml version=\"1.0\" encoding=\"utf-16\"?>", substring);
1620
1621                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1622                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1623                         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);
1624                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1625                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1626                         AssertEquals ("test#03", "  <xs:element name=\"NewDataSet\" msdata:IsDataSet=\"true\" msdata:MainDataTable=\"TestWriteXmlSchema\" msdata:UseCurrentLocale=\"true\">", substring);
1627                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1628                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1629                         AssertEquals ("test#04", "    <xs:complexType>", substring);
1630
1631                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1632                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1633                         AssertEquals ("test#05", "      <xs:choice minOccurs=\"0\" maxOccurs=\"unbounded\">", substring);
1634
1635                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1636                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1637                         AssertEquals ("test#06", "        <xs:element name=\"TestWriteXmlSchema\">", substring);
1638
1639                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1640                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1641                         AssertEquals ("test#07", "          <xs:complexType>", substring);
1642
1643                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1644                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1645                         AssertEquals ("test#08", "            <xs:sequence>", substring);
1646
1647                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1648                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1649                         AssertEquals ("test#09", "              <xs:element name=\"Col1\" type=\"xs:int\" minOccurs=\"0\" />", substring);
1650
1651                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1652                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1653                         AssertEquals ("test#10", "              <xs:element name=\"Col2\" type=\"xs:int\" minOccurs=\"0\" />", substring);
1654
1655                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1656                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1657                         AssertEquals ("test#11", "            </xs:sequence>", substring);
1658
1659                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1660                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1661                         AssertEquals ("test#12", "          </xs:complexType>", substring);
1662
1663                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1664                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1665                         AssertEquals ("test#13", "        </xs:element>", substring);
1666
1667                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1668                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1669                         AssertEquals ("test#14", "        <xs:element name=\"HelloWorld\">", substring);
1670
1671                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1672                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1673                         AssertEquals ("test#15", "          <xs:complexType>", substring);
1674
1675                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1676                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1677                         AssertEquals ("test#16", "            <xs:sequence>", substring);
1678
1679                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1680                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1681                         AssertEquals ("test#17", "              <xs:element name=\"T1\" type=\"xs:int\" minOccurs=\"0\" />", substring);
1682
1683                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1684                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1685                         AssertEquals ("test#18", "              <xs:element name=\"T2\" type=\"xs:int\" minOccurs=\"0\" />", substring);
1686
1687                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1688                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1689                         AssertEquals ("test#19", "            </xs:sequence>", substring);
1690
1691                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1692                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1693                         AssertEquals ("test#20", "          </xs:complexType>", substring);
1694
1695                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1696                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1697                         AssertEquals ("test#21", "        </xs:element>", substring);
1698
1699                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1700                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1701                         AssertEquals ("test#22", "      </xs:choice>", substring);
1702
1703                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1704                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1705                         AssertEquals ("test#23", "    </xs:complexType>", substring);
1706
1707                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1708                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1709                         AssertEquals ("test#24", "    <xs:unique name=\"Constraint1\">", substring);
1710
1711                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1712                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1713                         AssertEquals ("test#25", "      <xs:selector xpath=\".//TestWriteXmlSchema\" />", substring);
1714
1715                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1716                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1717                         AssertEquals ("test#26", "      <xs:field xpath=\"Col1\" />", substring);
1718
1719                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1720                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1721                         AssertEquals ("test#27", "    </xs:unique>", substring);
1722
1723                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1724                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1725                         AssertEquals ("test#28", "    <xs:keyref name=\"Relation1\" refer=\"Constraint1\">", substring);
1726
1727                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1728                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1729                         AssertEquals ("test#29", "      <xs:selector xpath=\".//HelloWorld\" />", substring);
1730
1731                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1732                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1733                         AssertEquals ("test#30", "      <xs:field xpath=\"T1\" />", substring);
1734
1735                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1736                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1737                         AssertEquals ("test#31", "    </xs:keyref>", substring);
1738
1739                         substring = TextString.Substring (0, TextString.IndexOf(EOL));
1740                         TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1741                         AssertEquals ("test#32", "  </xs:element>", substring);
1742                         AssertEquals ("test#33", "</xs:schema>", TextString);
1743                 }
1744 #endif
1745                 [Test]
1746                 public void Serialize ()
1747                 {
1748                         MemoryStream fs = new MemoryStream ();
1749
1750                         // Construct a BinaryFormatter and use it
1751                         // to serialize the data to the stream.
1752                         BinaryFormatter formatter = new BinaryFormatter();
1753
1754                         // Create an array with multiple elements refering to
1755                         // the one Singleton object.
1756                         DataTable dt = new DataTable();
1757
1758
1759                         dt.Columns.Add(new DataColumn("Id", typeof(string)));
1760                         dt.Columns.Add(new DataColumn("ContactName", typeof(string)));
1761                         dt.Columns.Add(new DataColumn("ContactTitle", typeof(string)));
1762                         dt.Columns.Add(new DataColumn("ContactAreaCode", typeof(string)));
1763                         dt.Columns.Add(new DataColumn("ContactPhone", typeof(string)));
1764
1765                         DataRow loRowToAdd;
1766                         loRowToAdd = dt.NewRow();
1767                         loRowToAdd[0] = "a";
1768                         loRowToAdd[1] = "b";
1769                         loRowToAdd[2] = "c";
1770                         loRowToAdd[3] = "d";
1771                         loRowToAdd[4] = "e";
1772
1773                         dt.Rows.Add(loRowToAdd);
1774
1775                         DataTable[] dtarr = new DataTable[] {dt};
1776
1777                         // Serialize the array elements.
1778                         formatter.Serialize(fs, dtarr);
1779
1780                         // Deserialize the array elements.
1781                         fs.Position = 0;
1782                         DataTable[] a2 = (DataTable[]) formatter.Deserialize(fs);
1783
1784                         DataSet ds = new DataSet();
1785                         ds.Tables.Add(a2[0]);
1786
1787                         StringWriter sw = new StringWriter ();
1788                         ds.WriteXml(sw);
1789                         XmlDocument doc = new XmlDocument ();
1790                         doc.LoadXml (sw.ToString ());
1791                         AssertEquals (5, doc.DocumentElement.FirstChild.ChildNodes.Count);
1792                 }
1793
1794                 [Test]
1795                 [ExpectedException (typeof (DataException))]
1796                 public void SetPrimaryKeyAssertsNonNull ()
1797                 {
1798                         DataTable dt = new DataTable ("table");
1799                         dt.Columns.Add ("col1");
1800                         dt.Columns.Add ("col2");
1801                         dt.Constraints.Add (new UniqueConstraint (dt.Columns [0]));
1802                         dt.Rows.Add (new object [] {1, 3});
1803                         dt.Rows.Add (new object [] {DBNull.Value, 3});
1804
1805                         dt.PrimaryKey = new DataColumn [] {dt.Columns [0]};
1806                 }
1807
1808                 [Test]
1809                 [ExpectedException (typeof (NoNullAllowedException))]
1810                 public void PrimaryKeyColumnChecksNonNull ()
1811                 {
1812                         DataTable dt = new DataTable ("table");
1813                         dt.Columns.Add ("col1");
1814                         dt.Columns.Add ("col2");
1815                         dt.Constraints.Add (new UniqueConstraint (dt.Columns [0]));
1816                         dt.PrimaryKey = new DataColumn [] {dt.Columns [0]};
1817                         dt.Rows.Add (new object [] {1, 3});
1818                         dt.Rows.Add (new object [] {DBNull.Value, 3});
1819                 }
1820
1821                 [Test]
1822                 public void PrimaryKey_CheckSetsAllowDBNull ()
1823                 {
1824                         DataTable table = new DataTable ();
1825                         DataColumn col1 = table.Columns.Add ("col1", typeof (int));
1826                         DataColumn col2 = table.Columns.Add ("col2", typeof (int));
1827
1828                         AssertEquals ("#1" , true, col1.AllowDBNull);
1829                         AssertEquals ("#2" , true, col2.AllowDBNull);
1830                         AssertEquals ("#3" , false, col2.Unique);
1831                         AssertEquals ("#4" , false, col2.Unique);
1832
1833                         table.PrimaryKey = new DataColumn[] {col1,col2};
1834                         AssertEquals ("#5" , false, col1.AllowDBNull);
1835                         AssertEquals ("#6" , false, col2.AllowDBNull);
1836                         // LAMESPEC or bug ??
1837                         AssertEquals ("#7" , false, col1.Unique);
1838                         AssertEquals ("#8" , false, col2.Unique);
1839                 }
1840
1841                 void RowChanging (object o, DataRowChangeEventArgs e)
1842                 {
1843                         AssertEquals ("changing.Action", rowChangingExpectedAction, e.Action);
1844                         rowChangingRowChanging = true;
1845                 }
1846
1847                 void RowChanged (object o, DataRowChangeEventArgs e)
1848                 {
1849                         AssertEquals ("changed.Action", rowChangingExpectedAction, e.Action);
1850                         rowChangingRowChanged = true;
1851                 }
1852
1853                 bool rowChangingRowChanging, rowChangingRowChanged;
1854                 DataRowAction rowChangingExpectedAction;
1855
1856                 [Test]
1857                 public void RowChanging ()
1858                 {
1859                         DataTable dt = new DataTable ("table");
1860                         dt.Columns.Add ("col1");
1861                         dt.Columns.Add ("col2");
1862                         dt.RowChanging += new DataRowChangeEventHandler (RowChanging);
1863                         dt.RowChanged += new DataRowChangeEventHandler (RowChanged);
1864                         rowChangingExpectedAction = DataRowAction.Add;
1865                         dt.Rows.Add (new object [] {1, 2});
1866                         Assert ("changing,Added", rowChangingRowChanging);
1867                         Assert ("changed,Added", rowChangingRowChanged);
1868                         rowChangingExpectedAction = DataRowAction.Change;
1869                         dt.Rows [0] [0] = 2;
1870                         Assert ("changing,Changed", rowChangingRowChanging);
1871                         Assert ("changed,Changed", rowChangingRowChanged);
1872                 }
1873
1874                  [Test]
1875                 public void CloneSubClassTest()
1876                 {
1877                         MyDataTable dt1 = new MyDataTable();
1878                         MyDataTable dt = (MyDataTable)(dt1.Clone());
1879                         AssertEquals("A#01",2,MyDataTable.count);
1880                 }
1881
1882                 DataRowAction rowActionChanging = DataRowAction.Nothing;
1883                 DataRowAction rowActionChanged  = DataRowAction.Nothing;
1884                 [Test]
1885                 public void AcceptChangesTest ()
1886                 {
1887                         DataTable dt = new DataTable ("test");
1888                         dt.Columns.Add ("id", typeof (int));
1889                         dt.Columns.Add ("name", typeof (string));
1890
1891                         dt.Rows.Add (new object [] { 1, "mono 1" });
1892
1893                         dt.RowChanged  += new DataRowChangeEventHandler (OnRowChanged);
1894                         dt.RowChanging += new DataRowChangeEventHandler (OnRowChanging);
1895
1896                         try {
1897                                 rowActionChanged = rowActionChanging = DataRowAction.Nothing;
1898                                 dt.AcceptChanges ();
1899
1900                                 AssertEquals ("#1 should have fired event and set action to commit",
1901                                               DataRowAction.Commit, rowActionChanging);
1902                                 AssertEquals ("#2 should have fired event and set action to commit",
1903                                               DataRowAction.Commit, rowActionChanged);
1904
1905                         } finally {
1906                                 dt.RowChanged  -= new DataRowChangeEventHandler (OnRowChanged);
1907                                 dt.RowChanging -= new DataRowChangeEventHandler (OnRowChanging);
1908
1909                         }
1910                 }
1911
1912                 [Test]
1913                 public void ColumnObjectTypeTest() {
1914                         DataTable dt = new DataTable();
1915                         dt.Columns.Add("Series Label", typeof(SqlInt32));
1916                         dt.Rows.Add(new object[] {"sss"});
1917                         AssertEquals(1, dt.Rows.Count);
1918                 }
1919
1920 #if NET_2_0
1921                 private bool tableInitialized;
1922                 [Test]
1923                 public void TableInitializedEventTest1 () {
1924                         DataTable dt = new DataTable();
1925                         tableInitialized = false;
1926                         dt.Initialized += new EventHandler (OnTableInitialized);
1927                         dt.Columns.Add("Series Label", typeof(SqlInt32));
1928                         dt.Rows.Add(new object[] {"sss"});
1929                         AssertEquals("TableInitialized #01", tableInitialized, false);
1930                         dt.Initialized -= new EventHandler (OnTableInitialized);
1931                 }
1932                 [Test]
1933                 public void TableInitializedEventTest2 () {
1934                         DataTable dt = new DataTable();
1935                         dt.BeginInit ();
1936                         tableInitialized = false;
1937                         dt.Initialized += new EventHandler (OnTableInitialized);
1938                         dt.Columns.Add("Series Label", typeof(SqlInt32));
1939                         dt.Rows.Add(new object[] {"sss"});
1940                         dt.EndInit ();
1941                         dt.Initialized -= new EventHandler (OnTableInitialized);
1942                         AssertEquals("TableInitialized #02", tableInitialized, true);
1943                 }
1944                 [Test]
1945                 public void TableInitializedEventTest3 () {
1946                         DataTable dt = new DataTable();
1947                         tableInitialized = true;
1948                         dt.Initialized += new EventHandler (OnTableInitialized);
1949                         dt.Columns.Add("Series Label", typeof(SqlInt32));
1950                         dt.Rows.Add(new object[] {"sss"});
1951                         AssertEquals("TableInitialized #03", tableInitialized, dt.IsInitialized);
1952                         dt.Initialized -= new EventHandler (OnTableInitialized);
1953                 }
1954                 [Test]
1955                 public void TableInitializedEventTest4 () {
1956                         DataTable dt = new DataTable();
1957                         AssertEquals("TableInitialized #04", true, dt.IsInitialized);
1958                         dt.BeginInit ();
1959                         tableInitialized = false;
1960                         dt.Initialized += new EventHandler (OnTableInitialized);
1961                         dt.Columns.Add("Series Label", typeof(SqlInt32));
1962                         dt.Rows.Add(new object[] {"sss"});
1963                         AssertEquals("TableInitialized #05", false, dt.IsInitialized);
1964                         dt.EndInit ();
1965                         NUnit.Framework.Assert.IsTrue (dt.IsInitialized, "TableInitialized #06");
1966                         NUnit.Framework.Assert.IsTrue (tableInitialized, "TableInitialized #07");
1967                         dt.Initialized -= new EventHandler (OnTableInitialized);
1968                 }
1969
1970                 private void OnTableInitialized (object src, EventArgs args)
1971                 {
1972                         tableInitialized = true;
1973                 }
1974
1975 #endif
1976
1977                 public void OnRowChanging (object src, DataRowChangeEventArgs args)
1978                 {
1979                         rowActionChanging = args.Action;
1980                 }
1981
1982                 public void OnRowChanged (object src, DataRowChangeEventArgs args)
1983                 {
1984                         rowActionChanged = args.Action;
1985                 }
1986
1987 #if NET_2_0
1988                 private DataTable dt;
1989                 private void localSetup () {
1990                         dt = new DataTable ("test");
1991                         dt.Columns.Add ("id", typeof (int));
1992                         dt.Columns.Add ("name", typeof (string));
1993                         dt.PrimaryKey = new DataColumn[] { dt.Columns["id"] };
1994
1995                         dt.Rows.Add (new object[] { 1, "mono 1" });
1996                         dt.Rows.Add (new object[] { 2, "mono 2" });
1997                         dt.Rows.Add (new object[] { 3, "mono 3" });
1998
1999                         dt.AcceptChanges ();
2000                 }
2001
2002                 #region DataTable.CreateDataReader Tests
2003
2004                 [Test]
2005                 public void CreateDataReader1 () {
2006                         localSetup ();
2007                         DataTableReader dtr = dt.CreateDataReader ();
2008                         Assert ("HasRows", dtr.HasRows);
2009                         AssertEquals ("CountCols", dt.Columns.Count, dtr.FieldCount);
2010                         int ri = 0;
2011                         while (dtr.Read ()) {
2012                                 for (int i = 0; i < dtr.FieldCount; i++) {
2013                                         AssertEquals ("RowData-" + ri + "-" + i, dt.Rows[ri][i],
2014                                                 dtr[i]);
2015                                 }
2016                                 ri++;
2017                         }
2018                 }
2019
2020                 [Test]
2021                 public void CreateDataReader2 () {
2022                         localSetup ();
2023                         DataTableReader dtr = dt.CreateDataReader ();
2024                         Assert ("HasRows", dtr.HasRows);
2025                         AssertEquals ("CountCols", dt.Columns.Count, dtr.FieldCount);
2026                         dtr.Read ();
2027                         AssertEquals ("RowData0-0", 1, dtr[0]);
2028                         AssertEquals ("RowData0-1", "mono 1", dtr[1]);
2029                         dtr.Read ();
2030                         AssertEquals ("RowData1-0", 2, dtr[0]);
2031                         AssertEquals ("RowData1-1", "mono 2", dtr[1]);
2032                         dtr.Read ();
2033                         AssertEquals ("RowData2-0", 3, dtr[0]);
2034                         AssertEquals ("RowData2-1", "mono 3", dtr[1]);
2035                 }
2036
2037                 #endregion // DataTable.CreateDataReader Tests
2038
2039                 #region DataTable.Load Tests
2040
2041                 [Test]
2042                 public void Load_Basic () {
2043                         localSetup ();
2044                         DataTable dtLoad = new DataTable ("LoadBasic");
2045                         dtLoad.Columns.Add ("id", typeof (int));
2046                         dtLoad.Columns.Add ("name", typeof (string));
2047                         dtLoad.Columns["id"].ReadOnly = true;
2048                         dtLoad.Columns["name"].ReadOnly = true;
2049                         dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2050                         dtLoad.Rows.Add (new object[] { 1, "load 1" });
2051                         dtLoad.Rows.Add (new object[] { 2, "load 2" });
2052                         dtLoad.Rows.Add (new object[] { 3, "load 3" });
2053                         dtLoad.AcceptChanges ();
2054                         DataTableReader dtr = dt.CreateDataReader ();
2055                         dtLoad.Load (dtr);
2056                         AssertEquals ("NColumns", 2, dtLoad.Columns.Count);
2057                         AssertEquals ("NRows", 3, dtLoad.Rows.Count);
2058                         AssertEquals ("RowData0-0", 1, dtLoad.Rows[0][0]);
2059                         AssertEquals ("RowData0-1", "mono 1", dtLoad.Rows[0][1]);
2060                         AssertEquals ("RowData1-0", 2, dtLoad.Rows[1][0]);
2061                         AssertEquals ("RowData1-1", "mono 2", dtLoad.Rows[1][1]);
2062                         AssertEquals ("RowData2-0", 3, dtLoad.Rows[2][0]);
2063                         AssertEquals ("RowData2-1", "mono 3", dtLoad.Rows[2][1]);
2064                 }
2065
2066                 [Test]
2067                 public void Load_NoSchema () {
2068                         localSetup ();
2069                         DataTable dtLoad = new DataTable ("LoadNoSchema");
2070                         DataTableReader dtr = dt.CreateDataReader ();
2071                         dtLoad.Load (dtr);
2072                         AssertEquals ("NColumns", 2, dtLoad.Columns.Count);
2073                         AssertEquals ("NRows", 3, dtLoad.Rows.Count);
2074                         AssertEquals ("RowData0-0", 1, dtLoad.Rows[0][0]);
2075                         AssertEquals ("RowData0-1", "mono 1", dtLoad.Rows[0][1]);
2076                         AssertEquals ("RowData1-0", 2, dtLoad.Rows[1][0]);
2077                         AssertEquals ("RowData1-1", "mono 2", dtLoad.Rows[1][1]);
2078                         AssertEquals ("RowData2-0", 3, dtLoad.Rows[2][0]);
2079                         AssertEquals ("RowData2-1", "mono 3", dtLoad.Rows[2][1]);
2080                 }
2081
2082                 internal struct fillErrorStruct {
2083                         internal string error;
2084                         internal string tableName;
2085                         internal int rowKey;
2086                         internal bool contFlag;
2087                         internal void init (string tbl, int row, bool cont, string err) {
2088                                 tableName = tbl;
2089                                 rowKey = row;
2090                                 contFlag = cont;
2091                                 error = err;
2092                         }
2093                 }
2094                 private fillErrorStruct[] fillErr = new fillErrorStruct[3];
2095                 private int fillErrCounter;
2096                 private void fillErrorHandler (object sender, FillErrorEventArgs e) {
2097                         e.Continue = fillErr[fillErrCounter].contFlag;
2098                         AssertEquals ("fillErr-T", fillErr[fillErrCounter].tableName, e.DataTable.TableName);
2099                         //AssertEquals ("fillErr-R", fillErr[fillErrCounter].rowKey, e.Values[0]);
2100                         AssertEquals ("fillErr-C", fillErr[fillErrCounter].contFlag, e.Continue);
2101                         //AssertEquals ("fillErr-E", fillErr[fillErrCounter].error, e.Errors.Message);
2102                         fillErrCounter++;
2103                 }
2104
2105                 [Test]
2106                 [ExpectedException (typeof (ArgumentException))]
2107                 public void Load_Incompatible () {
2108                         localSetup ();
2109                         DataTable dtLoad = new DataTable ("LoadIncompatible");
2110                         dtLoad.Columns.Add ("name", typeof (double));
2111                         DataTableReader dtr = dt.CreateDataReader ();
2112                         dtLoad.Load (dtr);
2113                 }
2114                 [Test]
2115                 // Load doesn't have a third overload in System.Data
2116                 // and is commented-out below
2117                 public void Load_IncompatibleEHandlerT () {
2118                         fillErrCounter = 0;
2119                         fillErr[0].init ("LoadIncompatible", 1, true,
2120                                  "Input string was not in a correct format.Couldn't store <mono 1> in name Column.  Expected type is Double.");
2121                         fillErr[1].init ("LoadIncompatible", 2, true,
2122                                 "Input string was not in a correct format.Couldn't store <mono 2> in name Column.  Expected type is Double.");
2123                         fillErr[2].init ("LoadIncompatible", 3, true,
2124                                 "Input string was not in a correct format.Couldn't store <mono 3> in name Column.  Expected type is Double.");
2125                         localSetup ();
2126                         DataTable dtLoad = new DataTable ("LoadIncompatible");
2127                         dtLoad.Columns.Add ("name", typeof (double));
2128                         DataTableReader dtr = dt.CreateDataReader ();
2129                         dtLoad.Load (dtr,LoadOption.PreserveChanges,fillErrorHandler);
2130                 }
2131                 [Test]
2132                 // Load doesn't have a third overload in System.Data
2133                 // and is commented-out below
2134                 [ExpectedException (typeof (ArgumentException))]
2135                 public void Load_IncompatibleEHandlerF () {
2136                         fillErrCounter = 0;
2137                         fillErr[0].init ("LoadIncompatible", 1, false,
2138                                 "Input string was not in a correct format.Couldn't store <mono 1> in name Column.  Expected type is Double.");
2139                         localSetup ();
2140                         DataTable dtLoad = new DataTable ("LoadIncompatible");
2141                         dtLoad.Columns.Add ("name", typeof (double));
2142                         DataTableReader dtr = dt.CreateDataReader ();
2143                         dtLoad.Load (dtr, LoadOption.PreserveChanges, fillErrorHandler);
2144                 }
2145
2146                 [Test]
2147                 public void Load_ExtraColsEqualVal () {
2148                         localSetup ();
2149                         DataTable dtLoad = new DataTable ("LoadExtraCols");
2150                         dtLoad.Columns.Add ("id", typeof (int));
2151                         dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2152                         dtLoad.Rows.Add (new object[] { 1 });
2153                         dtLoad.Rows.Add (new object[] { 2 });
2154                         dtLoad.Rows.Add (new object[] { 3 });
2155                         dtLoad.AcceptChanges ();
2156                         DataTableReader dtr = dt.CreateDataReader ();
2157                         dtLoad.Load (dtr);
2158                         AssertEquals ("NColumns", 2, dtLoad.Columns.Count);
2159                         AssertEquals ("NRows", 3, dtLoad.Rows.Count);
2160                         AssertEquals ("RowData0-0", 1, dtLoad.Rows[0][0]);
2161                         AssertEquals ("RowData0-1", "mono 1", dtLoad.Rows[0][1]);
2162                         AssertEquals ("RowData1-0", 2, dtLoad.Rows[1][0]);
2163                         AssertEquals ("RowData1-1", "mono 2", dtLoad.Rows[1][1]);
2164                         AssertEquals ("RowData2-0", 3, dtLoad.Rows[2][0]);
2165                         AssertEquals ("RowData2-1", "mono 3", dtLoad.Rows[2][1]);
2166                 }
2167
2168                 [Test]
2169                 public void Load_ExtraColsNonEqualVal () {
2170                         localSetup ();
2171                         DataTable dtLoad = new DataTable ("LoadExtraCols");
2172                         dtLoad.Columns.Add ("id", typeof (int));
2173                         dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2174                         dtLoad.Rows.Add (new object[] { 4 });
2175                         dtLoad.Rows.Add (new object[] { 5 });
2176                         dtLoad.Rows.Add (new object[] { 6 });
2177                         dtLoad.AcceptChanges ();
2178                         DataTableReader dtr = dt.CreateDataReader ();
2179                         dtLoad.Load (dtr);
2180                         AssertEquals ("NColumns", 2, dtLoad.Columns.Count);
2181                         AssertEquals ("NRows", 6, dtLoad.Rows.Count);
2182                         AssertEquals ("RowData0-0", 4, dtLoad.Rows[0][0]);
2183                         AssertEquals ("RowData1-0", 5, dtLoad.Rows[1][0]);
2184                         AssertEquals ("RowData2-0", 6, dtLoad.Rows[2][0]);
2185                         AssertEquals ("RowData3-0", 1, dtLoad.Rows[3][0]);
2186                         AssertEquals ("RowData3-1", "mono 1", dtLoad.Rows[3][1]);
2187                         AssertEquals ("RowData4-0", 2, dtLoad.Rows[4][0]);
2188                         AssertEquals ("RowData4-1", "mono 2", dtLoad.Rows[4][1]);
2189                         AssertEquals ("RowData5-0", 3, dtLoad.Rows[5][0]);
2190                         AssertEquals ("RowData5-1", "mono 3", dtLoad.Rows[5][1]);
2191                 }
2192
2193                 [Test]
2194                 [ExpectedException (typeof (ConstraintException))]
2195                 public void Load_MissingColsNonNullable () {
2196                         localSetup ();
2197                         DataTable dtLoad = new DataTable ("LoadMissingCols");
2198                         dtLoad.Columns.Add ("id", typeof (int));
2199                         dtLoad.Columns.Add ("name", typeof (string));
2200                         dtLoad.Columns.Add ("missing", typeof (string));
2201                         dtLoad.Columns["missing"].AllowDBNull = false;
2202                         dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2203                         dtLoad.Rows.Add (new object[] { 4, "mono 4", "miss4" });
2204                         dtLoad.Rows.Add (new object[] { 5, "mono 5", "miss5" });
2205                         dtLoad.Rows.Add (new object[] { 6, "mono 6", "miss6" });
2206                         dtLoad.AcceptChanges ();
2207                         DataTableReader dtr = dt.CreateDataReader ();
2208                         dtLoad.Load (dtr);
2209                 }
2210
2211                 [Test]
2212                 public void Load_MissingColsDefault () {
2213                         localSetup ();
2214                         DataTable dtLoad = new DataTable ("LoadMissingCols");
2215                         dtLoad.Columns.Add ("id", typeof (int));
2216                         dtLoad.Columns.Add ("name", typeof (string));
2217                         dtLoad.Columns.Add ("missing", typeof (string));
2218                         dtLoad.Columns["missing"].AllowDBNull = false;
2219                         dtLoad.Columns["missing"].DefaultValue = "DefaultValue";
2220                         dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2221                         dtLoad.Rows.Add (new object[] { 4, "mono 4", "miss4" });
2222                         dtLoad.Rows.Add (new object[] { 5, "mono 5", "miss5" });
2223                         dtLoad.Rows.Add (new object[] { 6, "mono 6", "miss6" });
2224                         dtLoad.AcceptChanges ();
2225                         DataTableReader dtr = dt.CreateDataReader ();
2226                         dtLoad.Load (dtr);
2227                         AssertEquals ("NColumns", 3, dtLoad.Columns.Count);
2228                         AssertEquals ("NRows", 6, dtLoad.Rows.Count);
2229                         AssertEquals ("RowData0-0", 4, dtLoad.Rows[0][0]);
2230                         AssertEquals ("RowData0-1", "mono 4", dtLoad.Rows[0][1]);
2231                         AssertEquals ("RowData0-2", "miss4", dtLoad.Rows[0][2]);
2232                         AssertEquals ("RowData1-0", 5, dtLoad.Rows[1][0]);
2233                         AssertEquals ("RowData1-1", "mono 5", dtLoad.Rows[1][1]);
2234                         AssertEquals ("RowData1-2", "miss5", dtLoad.Rows[1][2]);
2235                         AssertEquals ("RowData2-0", 6, dtLoad.Rows[2][0]);
2236                         AssertEquals ("RowData2-1", "mono 6", dtLoad.Rows[2][1]);
2237                         AssertEquals ("RowData2-2", "miss6", dtLoad.Rows[2][2]);
2238                         AssertEquals ("RowData3-0", 1, dtLoad.Rows[3][0]);
2239                         AssertEquals ("RowData3-1", "mono 1", dtLoad.Rows[3][1]);
2240                         AssertEquals ("RowData3-2", "DefaultValue", dtLoad.Rows[3][2]);
2241                         AssertEquals ("RowData4-0", 2, dtLoad.Rows[4][0]);
2242                         AssertEquals ("RowData4-1", "mono 2", dtLoad.Rows[4][1]);
2243                         AssertEquals ("RowData4-2", "DefaultValue", dtLoad.Rows[4][2]);
2244                         AssertEquals ("RowData5-0", 3, dtLoad.Rows[5][0]);
2245                         AssertEquals ("RowData5-1", "mono 3", dtLoad.Rows[5][1]);
2246                         AssertEquals ("RowData5-2", "DefaultValue", dtLoad.Rows[5][2]);
2247                 }
2248
2249                 [Test]
2250                 public void Load_MissingColsNullable () {
2251                         localSetup ();
2252                         DataTable dtLoad = new DataTable ("LoadMissingCols");
2253                         dtLoad.Columns.Add ("id", typeof (int));
2254                         dtLoad.Columns.Add ("name", typeof (string));
2255                         dtLoad.Columns.Add ("missing", typeof (string));
2256                         dtLoad.Columns["missing"].AllowDBNull = true;
2257                         dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2258                         dtLoad.Rows.Add (new object[] { 4, "mono 4", "miss4" });
2259                         dtLoad.Rows.Add (new object[] { 5, "mono 5", "miss5" });
2260                         dtLoad.Rows.Add (new object[] { 6, "mono 6", "miss6" });
2261                         dtLoad.AcceptChanges ();
2262                         DataTableReader dtr = dt.CreateDataReader ();
2263                         dtLoad.Load (dtr);
2264                         AssertEquals ("NColumns", 3, dtLoad.Columns.Count);
2265                         AssertEquals ("NRows", 6, dtLoad.Rows.Count);
2266                         AssertEquals ("RowData0-0", 4, dtLoad.Rows[0][0]);
2267                         AssertEquals ("RowData0-1", "mono 4", dtLoad.Rows[0][1]);
2268                         AssertEquals ("RowData0-2", "miss4", dtLoad.Rows[0][2]);
2269                         AssertEquals ("RowData1-0", 5, dtLoad.Rows[1][0]);
2270                         AssertEquals ("RowData1-1", "mono 5", dtLoad.Rows[1][1]);
2271                         AssertEquals ("RowData1-2", "miss5", dtLoad.Rows[1][2]);
2272                         AssertEquals ("RowData2-0", 6, dtLoad.Rows[2][0]);
2273                         AssertEquals ("RowData2-1", "mono 6", dtLoad.Rows[2][1]);
2274                         AssertEquals ("RowData2-2", "miss6", dtLoad.Rows[2][2]);
2275                         AssertEquals ("RowData3-0", 1, dtLoad.Rows[3][0]);
2276                         AssertEquals ("RowData3-1", "mono 1", dtLoad.Rows[3][1]);
2277                         //AssertEquals ("RowData3-2", null, dtLoad.Rows[3][2]);
2278                         AssertEquals ("RowData4-0", 2, dtLoad.Rows[4][0]);
2279                         AssertEquals ("RowData4-1", "mono 2", dtLoad.Rows[4][1]);
2280                         //AssertEquals ("RowData4-2", null, dtLoad.Rows[4][2]);
2281                         AssertEquals ("RowData5-0", 3, dtLoad.Rows[5][0]);
2282                         AssertEquals ("RowData5-1", "mono 3", dtLoad.Rows[5][1]);
2283                         //AssertEquals ("RowData5-2", null, dtLoad.Rows[5][2]);
2284                 }
2285
2286                 private DataTable setupRowState () {
2287                         DataTable tbl = new DataTable ("LoadRowStateChanges");
2288                         tbl.RowChanged += new DataRowChangeEventHandler (dtLoad_RowChanged);
2289                         tbl.RowChanging += new DataRowChangeEventHandler (dtLoad_RowChanging);
2290                         tbl.Columns.Add ("id", typeof (int));
2291                         tbl.Columns.Add ("name", typeof (string));
2292                         tbl.PrimaryKey = new DataColumn[] { tbl.Columns["id"] };
2293                         tbl.Rows.Add (new object[] { 1, "RowState 1" });
2294                         tbl.Rows.Add (new object[] { 2, "RowState 2" });
2295                         tbl.Rows.Add (new object[] { 3, "RowState 3" });
2296                         tbl.AcceptChanges ();
2297                         // Update Table with following changes: Row0 unmodified,
2298                         // Row1 modified, Row2 deleted, Row3 added, Row4 not-present.
2299                         tbl.Rows[1]["name"] = "Modify 2";
2300                         tbl.Rows[2].Delete ();
2301                         DataRow row = tbl.NewRow ();
2302                         row["id"] = 4;
2303                         row["name"] = "Add 4";
2304                         tbl.Rows.Add (row);
2305                         return (tbl);
2306                 }
2307
2308                 private DataRowAction[] rowChangeAction = new DataRowAction[5];
2309                 private bool checkAction = false;
2310                 private int rowChagedCounter, rowChangingCounter;
2311                 private void rowActionInit (DataRowAction[] act) {
2312                         checkAction = true;
2313                         rowChagedCounter = 0;
2314                         rowChangingCounter = 0;
2315                         for (int i = 0; i < 5; i++)
2316                                 rowChangeAction[i] = act[i];
2317                 }
2318                 private void rowActionEnd () {
2319                         checkAction = false;
2320                 }
2321                 private void dtLoad_RowChanged (object sender, DataRowChangeEventArgs e) {
2322                         if (checkAction) {
2323                                 AssertEquals ("RowChanged" + rowChagedCounter,
2324                                         rowChangeAction[rowChagedCounter], e.Action);
2325                                 rowChagedCounter++;
2326                         }
2327                 }
2328                 private void dtLoad_RowChanging (object sender, DataRowChangeEventArgs e) {
2329                         if (checkAction) {
2330                                 AssertEquals ("RowChanging" + rowChangingCounter,
2331                                         rowChangeAction[rowChangingCounter], e.Action);
2332                                 rowChangingCounter++;
2333                         }
2334                 }
2335
2336                 [Test]
2337                 public void Load_RowStateChangesDefault () {
2338                         localSetup ();
2339                         dt.Rows.Add (new object[] { 4, "mono 4" });
2340                         dt.Rows.Add (new object[] { 5, "mono 5" });
2341                         dt.AcceptChanges ();
2342                         DataTableReader dtr = dt.CreateDataReader ();
2343                         DataTable dtLoad = setupRowState ();
2344                         DataRowAction[] dra = new DataRowAction[] {
2345                                 DataRowAction.ChangeCurrentAndOriginal,
2346                                 DataRowAction.ChangeOriginal,
2347                                 DataRowAction.ChangeOriginal,
2348                                 DataRowAction.ChangeOriginal,
2349                                 DataRowAction.ChangeCurrentAndOriginal};
2350                         rowActionInit (dra);
2351                         dtLoad.Load (dtr);
2352                         rowActionEnd ();
2353                         // asserting Unchanged Row0
2354                         AssertEquals ("RowData0-C", "mono 1",
2355                                 dtLoad.Rows[0][1,DataRowVersion.Current]);
2356                         AssertEquals ("RowData0-O", "mono 1",
2357                                 dtLoad.Rows[0][1,DataRowVersion.Original]);
2358                         AssertEquals ("RowState0", DataRowState.Unchanged,
2359                                 dtLoad.Rows[0].RowState);
2360                         // asserting Modified Row1
2361                         AssertEquals ("RowData1-C", "Modify 2",
2362                                 dtLoad.Rows[1][1, DataRowVersion.Current]);
2363                         AssertEquals ("RowData1-O", "mono 2",
2364                                 dtLoad.Rows[1][1, DataRowVersion.Original]);
2365                         AssertEquals ("RowState1", DataRowState.Modified,
2366                                 dtLoad.Rows[1].RowState);
2367                         // asserting Deleted Row2
2368                         AssertEquals ("RowData1-O", "mono 3",
2369                                 dtLoad.Rows[2][1, DataRowVersion.Original]);
2370                         AssertEquals ("RowState2", DataRowState.Deleted,
2371                                 dtLoad.Rows[2].RowState);
2372                         // asserting Added Row3
2373                         AssertEquals ("RowData3-C", "Add 4",
2374                                 dtLoad.Rows[3][1, DataRowVersion.Current]);
2375                         AssertEquals ("RowData3-O", "mono 4",
2376                                 dtLoad.Rows[3][1, DataRowVersion.Original]);
2377                         AssertEquals ("RowState3", DataRowState.Modified,
2378                                 dtLoad.Rows[3].RowState);
2379                         // asserting Unpresent Row4
2380                         AssertEquals ("RowData4-C", "mono 5",
2381                                 dtLoad.Rows[4][1, DataRowVersion.Current]);
2382                         AssertEquals ("RowData4-O", "mono 5",
2383                                 dtLoad.Rows[4][1, DataRowVersion.Original]);
2384                         AssertEquals ("RowState4", DataRowState.Unchanged,
2385                                 dtLoad.Rows[4].RowState);
2386                 }
2387
2388                 [Test]
2389                 [ExpectedException (typeof (VersionNotFoundException))]
2390                 public void Load_RowStateChangesDefaultDelete () {
2391                         localSetup ();
2392                         DataTable dtLoad = new DataTable ("LoadRowStateChanges");
2393                         dtLoad.Columns.Add ("id", typeof (int));
2394                         dtLoad.Columns.Add ("name", typeof (string));
2395                         dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2396                         dtLoad.Rows.Add (new object[] { 1, "RowState 1" });
2397                         dtLoad.Rows.Add (new object[] { 2, "RowState 2" });
2398                         dtLoad.Rows.Add (new object[] { 3, "RowState 3" });
2399                         dtLoad.AcceptChanges ();
2400                         dtLoad.Rows[2].Delete ();
2401                         DataTableReader dtr = dt.CreateDataReader ();
2402                         dtLoad.Load (dtr);
2403                         AssertEquals ("RowData2-C", " ",
2404                                 dtLoad.Rows[2][1, DataRowVersion.Current]);
2405                 }
2406
2407                 [Test]
2408                 public void Load_RowStatePreserveChanges () {
2409                         localSetup ();
2410                         dt.Rows.Add (new object[] { 4, "mono 4" });
2411                         dt.Rows.Add (new object[] { 5, "mono 5" });
2412                         dt.AcceptChanges ();
2413                         DataTableReader dtr = dt.CreateDataReader ();
2414                         DataTable dtLoad = setupRowState ();
2415                         DataRowAction[] dra = new DataRowAction[] {
2416                                 DataRowAction.ChangeCurrentAndOriginal,
2417                                 DataRowAction.ChangeOriginal,
2418                                 DataRowAction.ChangeOriginal,
2419                                 DataRowAction.ChangeOriginal,
2420                                 DataRowAction.ChangeCurrentAndOriginal};
2421                         rowActionInit (dra);
2422                         dtLoad.Load (dtr, LoadOption.PreserveChanges);
2423                         rowActionEnd ();
2424                         // asserting Unchanged Row0
2425                         AssertEquals ("RowData0-C", "mono 1",
2426                                 dtLoad.Rows[0][1, DataRowVersion.Current]);
2427                         AssertEquals ("RowData0-O", "mono 1",
2428                                 dtLoad.Rows[0][1, DataRowVersion.Original]);
2429                         AssertEquals ("RowState0", DataRowState.Unchanged,
2430                                 dtLoad.Rows[0].RowState);
2431                         // asserting Modified Row1
2432                         AssertEquals ("RowData1-C", "Modify 2",
2433                                 dtLoad.Rows[1][1, DataRowVersion.Current]);
2434                         AssertEquals ("RowData1-O", "mono 2",
2435                                 dtLoad.Rows[1][1, DataRowVersion.Original]);
2436                         AssertEquals ("RowState1", DataRowState.Modified,
2437                                 dtLoad.Rows[1].RowState);
2438                         // asserting Deleted Row2
2439                         AssertEquals ("RowData1-O", "mono 3",
2440                                 dtLoad.Rows[2][1, DataRowVersion.Original]);
2441                         AssertEquals ("RowState2", DataRowState.Deleted,
2442                                 dtLoad.Rows[2].RowState);
2443                         // asserting Added Row3
2444                         AssertEquals ("RowData3-C", "Add 4",
2445                                 dtLoad.Rows[3][1, DataRowVersion.Current]);
2446                         AssertEquals ("RowData3-O", "mono 4",
2447                                 dtLoad.Rows[3][1, DataRowVersion.Original]);
2448                         AssertEquals ("RowState3", DataRowState.Modified,
2449                                 dtLoad.Rows[3].RowState);
2450                         // asserting Unpresent Row4
2451                         AssertEquals ("RowData4-C", "mono 5",
2452                                 dtLoad.Rows[4][1, DataRowVersion.Current]);
2453                         AssertEquals ("RowData4-O", "mono 5",
2454                                 dtLoad.Rows[4][1, DataRowVersion.Original]);
2455                         AssertEquals ("RowState4", DataRowState.Unchanged,
2456                                 dtLoad.Rows[4].RowState);
2457                 }
2458
2459                 [Test]
2460                 [ExpectedException (typeof (VersionNotFoundException))]
2461                 public void Load_RowStatePreserveChangesDelete () {
2462                         localSetup ();
2463                         DataTable dtLoad = new DataTable ("LoadRowStateChanges");
2464                         dtLoad.Columns.Add ("id", typeof (int));
2465                         dtLoad.Columns.Add ("name", typeof (string));
2466                         dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2467                         dtLoad.Rows.Add (new object[] { 1, "RowState 1" });
2468                         dtLoad.Rows.Add (new object[] { 2, "RowState 2" });
2469                         dtLoad.Rows.Add (new object[] { 3, "RowState 3" });
2470                         dtLoad.AcceptChanges ();
2471                         dtLoad.Rows[2].Delete ();
2472                         DataTableReader dtr = dt.CreateDataReader ();
2473                         dtLoad.Load (dtr,LoadOption.PreserveChanges);
2474                         AssertEquals ("RowData2-C", " ",
2475                                 dtLoad.Rows[2][1, DataRowVersion.Current]);
2476                 }
2477
2478                 [Test]
2479                 public void Load_RowStateOverwriteChanges () {
2480                         localSetup ();
2481                         dt.Rows.Add (new object[] { 4, "mono 4" });
2482                         dt.Rows.Add (new object[] { 5, "mono 5" });
2483                         dt.AcceptChanges ();
2484                         DataTableReader dtr = dt.CreateDataReader ();
2485                         DataTable dtLoad = setupRowState ();
2486                         DataRowAction[] dra = new DataRowAction[] {
2487                                 DataRowAction.ChangeCurrentAndOriginal,
2488                                 DataRowAction.ChangeCurrentAndOriginal,
2489                                 DataRowAction.ChangeCurrentAndOriginal,
2490                                 DataRowAction.ChangeCurrentAndOriginal,
2491                                 DataRowAction.ChangeCurrentAndOriginal};
2492                         rowActionInit (dra);
2493                         dtLoad.Load (dtr, LoadOption.OverwriteChanges);
2494                         rowActionEnd ();
2495                         // asserting Unchanged Row0
2496                         AssertEquals ("RowData0-C", "mono 1",
2497                                 dtLoad.Rows[0][1, DataRowVersion.Current]);
2498                         AssertEquals ("RowData0-O", "mono 1",
2499                                 dtLoad.Rows[0][1, DataRowVersion.Original]);
2500                         AssertEquals ("RowState0", DataRowState.Unchanged,
2501                                 dtLoad.Rows[0].RowState);
2502                         // asserting Modified Row1
2503                         AssertEquals ("RowData1-C", "mono 2",
2504                                 dtLoad.Rows[1][1, DataRowVersion.Current]);
2505                         AssertEquals ("RowData1-O", "mono 2",
2506                                 dtLoad.Rows[1][1, DataRowVersion.Original]);
2507                         AssertEquals ("RowState1", DataRowState.Unchanged,
2508                                 dtLoad.Rows[1].RowState);
2509                         // asserting Deleted Row2
2510                         AssertEquals ("RowData1-C", "mono 3",
2511                                 dtLoad.Rows[2][1, DataRowVersion.Current]);
2512                         AssertEquals ("RowData1-O", "mono 3",
2513                                 dtLoad.Rows[2][1, DataRowVersion.Original]);
2514                         AssertEquals ("RowState2", DataRowState.Unchanged,
2515                                 dtLoad.Rows[2].RowState);
2516                         // asserting Added Row3
2517                         AssertEquals ("RowData3-C", "mono 4",
2518                                 dtLoad.Rows[3][1, DataRowVersion.Current]);
2519                         AssertEquals ("RowData3-O", "mono 4",
2520                                 dtLoad.Rows[3][1, DataRowVersion.Original]);
2521                         AssertEquals ("RowState3", DataRowState.Unchanged,
2522                                 dtLoad.Rows[3].RowState);
2523                         // asserting Unpresent Row4
2524                         AssertEquals ("RowData4-C", "mono 5",
2525                                 dtLoad.Rows[4][1, DataRowVersion.Current]);
2526                         AssertEquals ("RowData4-O", "mono 5",
2527                                 dtLoad.Rows[4][1, DataRowVersion.Original]);
2528                         AssertEquals ("RowState4", DataRowState.Unchanged,
2529                                 dtLoad.Rows[4].RowState);
2530                 }
2531
2532                 [Test]
2533                 public void Load_RowStateUpsert () {
2534                         localSetup ();
2535                         dt.Rows.Add (new object[] { 4, "mono 4" });
2536                         dt.Rows.Add (new object[] { 5, "mono 5" });
2537                         dt.AcceptChanges ();
2538                         DataTableReader dtr = dt.CreateDataReader ();
2539                         DataTable dtLoad = setupRowState ();
2540                         // Notice rowChange-Actions only occur 5 times, as number
2541                         // of actual rows, ignoring row duplication of the deleted row.
2542                         DataRowAction[] dra = new DataRowAction[] {
2543                                 DataRowAction.Change,
2544                                 DataRowAction.Change,
2545                                 DataRowAction.Add,
2546                                 DataRowAction.Change,
2547                                 DataRowAction.Add};
2548                         rowActionInit (dra);
2549                         dtLoad.Load (dtr, LoadOption.Upsert);
2550                         rowActionEnd ();
2551                         // asserting Unchanged Row0
2552                         AssertEquals ("RowData0-C", "mono 1",
2553                                 dtLoad.Rows[0][1, DataRowVersion.Current]);
2554                         AssertEquals ("RowData0-O", "RowState 1",
2555                                 dtLoad.Rows[0][1, DataRowVersion.Original]);
2556                         AssertEquals ("RowState0", DataRowState.Modified,
2557                                 dtLoad.Rows[0].RowState);
2558                         // asserting Modified Row1
2559                         AssertEquals ("RowData1-C", "mono 2",
2560                                 dtLoad.Rows[1][1, DataRowVersion.Current]);
2561                         AssertEquals ("RowData1-O", "RowState 2",
2562                                 dtLoad.Rows[1][1, DataRowVersion.Original]);
2563                         AssertEquals ("RowState1", DataRowState.Modified,
2564                                 dtLoad.Rows[1].RowState);
2565                         // asserting Deleted Row2 and "Deleted-Added" Row4
2566                         AssertEquals ("RowData2-O", "RowState 3",
2567                                 dtLoad.Rows[2][1, DataRowVersion.Original]);
2568                         AssertEquals ("RowState2", DataRowState.Deleted,
2569                                 dtLoad.Rows[2].RowState);
2570                         AssertEquals ("RowData4-C", "mono 3",
2571                                 dtLoad.Rows[4][1, DataRowVersion.Current]);
2572                         AssertEquals ("RowState4", DataRowState.Added,
2573                                 dtLoad.Rows[4].RowState);
2574                         // asserting Added Row3
2575                         AssertEquals ("RowData3-C", "mono 4",
2576                                 dtLoad.Rows[3][1, DataRowVersion.Current]);
2577                         AssertEquals ("RowState3", DataRowState.Added,
2578                                 dtLoad.Rows[3].RowState);
2579                         // asserting Unpresent Row5
2580                         // Notice row4 is used for added row of deleted row2 and so
2581                         // unpresent row4 moves to row5
2582                         AssertEquals ("RowData5-C", "mono 5",
2583                                 dtLoad.Rows[5][1, DataRowVersion.Current]);
2584                         AssertEquals ("RowState5", DataRowState.Added,
2585                                 dtLoad.Rows[5].RowState);
2586                 }
2587
2588                 [Test]
2589                 public void Load_RowStateUpsertDuplicateKey1 () {
2590                         localSetup ();
2591                         dt.Rows.Add (new object[] { 4, "mono 4" });
2592                         DataTable dtLoad = new DataTable ("LoadRowStateChanges");
2593                         dtLoad.Columns.Add ("id", typeof (int));
2594                         dtLoad.Columns.Add ("name", typeof (string));
2595                         dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2596                         dtLoad.Rows.Add (new object[] { 1, "RowState 1" });
2597                         dtLoad.Rows.Add (new object[] { 2, "RowState 2" });
2598                         dtLoad.Rows.Add (new object[] { 3, "RowState 3" });
2599                         dtLoad.AcceptChanges ();
2600                         dtLoad.Rows[2].Delete ();
2601                         DataTableReader dtr = dt.CreateDataReader ();
2602                         dtLoad.Load (dtr, LoadOption.Upsert);
2603                         dtLoad.Rows[3][1] = "NEWVAL";
2604                         AssertEquals ("A-RowState2", DataRowState.Deleted,
2605                                 dtLoad.Rows[2].RowState);
2606                         AssertEquals ("A-RowData2-id", 3,
2607                                 dtLoad.Rows[2][0, DataRowVersion.Original]);
2608                         AssertEquals ("A-RowData2-name", "RowState 3",
2609                                 dtLoad.Rows[2][1, DataRowVersion.Original]);
2610                         AssertEquals ("A-RowState3", DataRowState.Added,
2611                                 dtLoad.Rows[3].RowState);
2612                         AssertEquals ("A-RowData3-id", 3,
2613                                 dtLoad.Rows[3][0, DataRowVersion.Current]);
2614                         AssertEquals ("A-RowData3-name", "NEWVAL",
2615                                 dtLoad.Rows[3][1, DataRowVersion.Current]);
2616                         AssertEquals ("A-RowState4", DataRowState.Added,
2617                                 dtLoad.Rows[4].RowState);
2618                         AssertEquals ("A-RowData4-id", 4,
2619                                 dtLoad.Rows[4][0, DataRowVersion.Current]);
2620                         AssertEquals ("A-RowData4-name", "mono 4",
2621                                 dtLoad.Rows[4][1, DataRowVersion.Current]);
2622
2623                         dtLoad.AcceptChanges ();
2624
2625                         AssertEquals ("B-RowState2", DataRowState.Unchanged,
2626                                 dtLoad.Rows[2].RowState);
2627                         AssertEquals ("B-RowData2-id", 3,
2628                                 dtLoad.Rows[2][0, DataRowVersion.Current]);
2629                         AssertEquals ("B-RowData2-name", "NEWVAL",
2630                                 dtLoad.Rows[2][1, DataRowVersion.Current]);
2631                         AssertEquals ("B-RowState3", DataRowState.Unchanged,
2632                                 dtLoad.Rows[3].RowState);
2633                         AssertEquals ("B-RowData3-id", 4,
2634                                 dtLoad.Rows[3][0, DataRowVersion.Current]);
2635                         AssertEquals ("B-RowData3-name", "mono 4",
2636                                 dtLoad.Rows[3][1, DataRowVersion.Current]);
2637                 }
2638
2639                 [Test]
2640                 [ExpectedException (typeof (IndexOutOfRangeException))]
2641                 public void Load_RowStateUpsertDuplicateKey2 () {
2642                         localSetup ();
2643                         dt.Rows.Add (new object[] { 4, "mono 4" });
2644                         DataTable dtLoad = new DataTable ("LoadRowStateChanges");
2645                         dtLoad.Columns.Add ("id", typeof (int));
2646                         dtLoad.Columns.Add ("name", typeof (string));
2647                         dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2648                         dtLoad.Rows.Add (new object[] { 1, "RowState 1" });
2649                         dtLoad.Rows.Add (new object[] { 2, "RowState 2" });
2650                         dtLoad.Rows.Add (new object[] { 3, "RowState 3" });
2651                         dtLoad.AcceptChanges ();
2652                         dtLoad.Rows[2].Delete ();
2653                         DataTableReader dtr = dt.CreateDataReader ();
2654                         dtLoad.Load (dtr, LoadOption.Upsert);
2655                         dtLoad.AcceptChanges ();
2656                         AssertEquals ("RowData4", " ", dtLoad.Rows[4][1]);
2657                 }
2658
2659                 [Test]
2660                 [ExpectedException (typeof (VersionNotFoundException))]
2661                 public void Load_RowStateUpsertDelete1 () {
2662                         localSetup ();
2663                         DataTable dtLoad = new DataTable ("LoadRowStateChanges");
2664                         dtLoad.Columns.Add ("id", typeof (int));
2665                         dtLoad.Columns.Add ("name", typeof (string));
2666                         dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2667                         dtLoad.Rows.Add (new object[] { 1, "RowState 1" });
2668                         dtLoad.Rows.Add (new object[] { 2, "RowState 2" });
2669                         dtLoad.Rows.Add (new object[] { 3, "RowState 3" });
2670                         dtLoad.AcceptChanges ();
2671                         dtLoad.Rows[2].Delete ();
2672                         DataTableReader dtr = dt.CreateDataReader ();
2673                         dtLoad.Load (dtr, LoadOption.Upsert);
2674                         AssertEquals ("RowData2-C", " ",
2675                                 dtLoad.Rows[2][1, DataRowVersion.Current]);
2676                 }
2677
2678                 [Test]
2679                 [ExpectedException (typeof (VersionNotFoundException))]
2680                 public void Load_RowStateUpsertDelete2 () {
2681                         localSetup ();
2682                         DataTable dtLoad = new DataTable ("LoadRowStateChanges");
2683                         dtLoad.Columns.Add ("id", typeof (int));
2684                         dtLoad.Columns.Add ("name", typeof (string));
2685                         dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2686                         dtLoad.Rows.Add (new object[] { 1, "RowState 1" });
2687                         dtLoad.Rows.Add (new object[] { 2, "RowState 2" });
2688                         dtLoad.Rows.Add (new object[] { 3, "RowState 3" });
2689                         dtLoad.AcceptChanges ();
2690                         dtLoad.Rows[2].Delete ();
2691                         DataTableReader dtr = dt.CreateDataReader ();
2692                         dtLoad.Load (dtr, LoadOption.Upsert);
2693                         AssertEquals ("RowData3-O", " ",
2694                                 dtLoad.Rows[3][1, DataRowVersion.Original]);
2695                 }
2696
2697                 [Test]
2698                 [ExpectedException (typeof (VersionNotFoundException))]
2699                 public void Load_RowStateUpsertAdd () {
2700                         localSetup ();
2701                         dt.Rows.Add (new object[] { 4, "mono 4" });
2702                         DataTable dtLoad = new DataTable ("LoadRowStateChanges");
2703                         dtLoad.Columns.Add ("id", typeof (int));
2704                         dtLoad.Columns.Add ("name", typeof (string));
2705                         dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2706                         dtLoad.Rows.Add (new object[] { 1, "RowState 1" });
2707                         dtLoad.Rows.Add (new object[] { 2, "RowState 2" });
2708                         dtLoad.Rows.Add (new object[] { 3, "RowState 3" });
2709                         dtLoad.AcceptChanges ();
2710                         DataRow row = dtLoad.NewRow ();
2711                         row["id"] = 4;
2712                         row["name"] = "Add 4";
2713                         dtLoad.Rows.Add (row);
2714                         DataTableReader dtr = dt.CreateDataReader ();
2715                         dtLoad.Load (dtr, LoadOption.Upsert);
2716                         AssertEquals ("RowData3-O", " ",
2717                                 dtLoad.Rows[3][1, DataRowVersion.Original]);
2718                 }
2719
2720                 [Test]
2721                 [ExpectedException (typeof (VersionNotFoundException))]
2722                 public void Load_RowStateUpsertUnpresent () {
2723                         localSetup ();
2724                         dt.Rows.Add (new object[] { 4, "mono 4" });
2725                         DataTable dtLoad = new DataTable ("LoadRowStateChanges");
2726                         dtLoad.Columns.Add ("id", typeof (int));
2727                         dtLoad.Columns.Add ("name", typeof (string));
2728                         dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2729                         dtLoad.Rows.Add (new object[] { 1, "RowState 1" });
2730                         dtLoad.Rows.Add (new object[] { 2, "RowState 2" });
2731                         dtLoad.Rows.Add (new object[] { 3, "RowState 3" });
2732                         dtLoad.AcceptChanges ();
2733                         DataTableReader dtr = dt.CreateDataReader ();
2734                         dtLoad.Load (dtr, LoadOption.Upsert);
2735                         AssertEquals ("RowData3-O", " ",
2736                                 dtLoad.Rows[3][1, DataRowVersion.Original]);
2737                 }
2738
2739                 [Test]
2740                 public void Load_RowStateUpsertUnchangedEqualVal () {
2741                         localSetup ();
2742                         DataTable dtLoad = new DataTable ("LoadRowStateChanges");
2743                         dtLoad.Columns.Add ("id", typeof (int));
2744                         dtLoad.Columns.Add ("name", typeof (string));
2745                         dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2746                         dtLoad.Rows.Add (new object[] { 1, "mono 1" });
2747                         dtLoad.AcceptChanges ();
2748                         DataTableReader dtr = dt.CreateDataReader ();
2749                         DataRowAction[] dra = new DataRowAction[] {
2750                                 DataRowAction.Nothing,// REAL action
2751                                 DataRowAction.Nothing,// dummy
2752                                 DataRowAction.Nothing,// dummy
2753                                 DataRowAction.Nothing,// dummy
2754                                 DataRowAction.Nothing};// dummy
2755                         rowActionInit (dra);
2756                         dtLoad.Load (dtr, LoadOption.Upsert);
2757                         rowActionEnd ();
2758                         AssertEquals ("RowData0-C", "mono 1",
2759                                 dtLoad.Rows[0][1, DataRowVersion.Current]);
2760                         AssertEquals ("RowData0-O", "mono 1",
2761                                 dtLoad.Rows[0][1, DataRowVersion.Original]);
2762                         AssertEquals ("RowState0", DataRowState.Unchanged,
2763                                 dtLoad.Rows[0].RowState);
2764                 }
2765
2766                 [Test]
2767                 public void LoadDataRow_LoadOptions () {
2768                         // LoadDataRow is covered in detail (without LoadOptions) in DataTableTest2
2769                         // LoadOption tests are covered in detail in DataTable.Load().
2770                         // Therefore only minimal tests of LoadDataRow with LoadOptions are covered here.
2771                         DataTable dt;
2772                         DataRow dr;
2773                         dt = CreateDataTableExample ();
2774                         dt.PrimaryKey = new DataColumn[] { dt.Columns[0] };     //add ParentId as Primary Key
2775                         dt.Columns["String1"].DefaultValue = "Default";
2776
2777                         dr = dt.Select ("ParentId=1")[0];
2778
2779                         //Update existing row with LoadOptions = OverwriteChanges
2780                         dt.BeginLoadData ();
2781                         dt.LoadDataRow (new object[] { 1, null, "Changed" },
2782                                 LoadOption.OverwriteChanges);
2783                         dt.EndLoadData ();
2784
2785                         // LoadDataRow(update1) - check column String2
2786                         AssertEquals ("DT72-C", "Changed",
2787                                 dr["String2", DataRowVersion.Current]);
2788                         AssertEquals ("DT72-O", "Changed",
2789                                 dr["String2", DataRowVersion.Original]);
2790
2791                         // LoadDataRow(update1) - check row state
2792                         AssertEquals ("DT73-LO", DataRowState.Unchanged, dr.RowState);
2793
2794                         //Add New row with LoadOptions = Upsert
2795                         dt.BeginLoadData ();
2796                         dt.LoadDataRow (new object[] { 99, null, "Changed" },
2797                                 LoadOption.Upsert);
2798                         dt.EndLoadData ();
2799
2800                         // LoadDataRow(insert1) - check column String2
2801                         dr = dt.Select ("ParentId=99")[0];
2802                         AssertEquals ("DT75-C", "Changed",
2803                                 dr["String2", DataRowVersion.Current]);
2804
2805                         // LoadDataRow(insert1) - check row state
2806                         AssertEquals ("DT76-LO", DataRowState.Added, dr.RowState);
2807                 }
2808
2809                 public static DataTable CreateDataTableExample () {
2810                         DataTable dtParent = new DataTable ("Parent");
2811
2812                         dtParent.Columns.Add ("ParentId", typeof (int));
2813                         dtParent.Columns.Add ("String1", typeof (string));
2814                         dtParent.Columns.Add ("String2", typeof (string));
2815
2816                         dtParent.Columns.Add ("ParentDateTime", typeof (DateTime));
2817                         dtParent.Columns.Add ("ParentDouble", typeof (double));
2818                         dtParent.Columns.Add ("ParentBool", typeof (bool));
2819
2820                         dtParent.Rows.Add (new object[] { 1, "1-String1", "1-String2", new DateTime (2005, 1, 1, 0, 0, 0, 0), 1.534, true });
2821                         dtParent.Rows.Add (new object[] { 2, "2-String1", "2-String2", new DateTime (2004, 1, 1, 0, 0, 0, 1), -1.534, true });
2822                         dtParent.Rows.Add (new object[] { 3, "3-String1", "3-String2", new DateTime (2003, 1, 1, 0, 0, 1, 0), double.MinValue * 10000, false });
2823                         dtParent.Rows.Add (new object[] { 4, "4-String1", "4-String2", new DateTime (2002, 1, 1, 0, 1, 0, 0), double.MaxValue / 10000, true });
2824                         dtParent.Rows.Add (new object[] { 5, "5-String1", "5-String2", new DateTime (2001, 1, 1, 1, 0, 0, 0), 0.755, true });
2825                         dtParent.Rows.Add (new object[] { 6, "6-String1", "6-String2", new DateTime (2000, 1, 1, 0, 0, 0, 0), 0.001, false });
2826                         dtParent.AcceptChanges ();
2827                         return dtParent;
2828                 }
2829
2830                 #endregion // DataTable.Load Tests
2831
2832                 #region Read/Write XML Tests
2833
2834                 [Test]
2835                 //[Category ("NotWorking")]
2836                 public void ReadXmlSchema () {
2837                         DataTable Table = new DataTable ();
2838                         Table.ReadXmlSchema ("Test/System.Data/own_schema1.xsd");
2839
2840                         AssertEquals ("test#02", "test_table", Table.TableName);
2841                         AssertEquals ("test#03", "", Table.Namespace);
2842                         AssertEquals ("test#04", 2, Table.Columns.Count);
2843                         AssertEquals ("test#05", 0, Table.Rows.Count);
2844                         AssertEquals ("test#06", false, Table.CaseSensitive);
2845                         AssertEquals ("test#07", 1, Table.Constraints.Count);
2846                         AssertEquals ("test#08", "", Table.Prefix);
2847
2848                         Constraint cons = Table.Constraints[0];
2849                         AssertEquals ("test#09", "Constraint1", cons.ConstraintName.ToString ());
2850                         AssertEquals ("test#10", "Constraint1", cons.ToString ());
2851
2852                         DataColumn column = Table.Columns[0];
2853                         AssertEquals ("test#11", true, column.AllowDBNull);
2854                         AssertEquals ("test#12", false, column.AutoIncrement);
2855                         AssertEquals ("test#13", 0L, column.AutoIncrementSeed);
2856                         AssertEquals ("test#14", 1L, column.AutoIncrementStep);
2857                         AssertEquals ("test#15", "test", column.Caption);
2858                         AssertEquals ("test#16", "Element", column.ColumnMapping.ToString ());
2859                         AssertEquals ("test#17", "first", column.ColumnName);
2860                         AssertEquals ("test#18", "System.String", column.DataType.ToString ());
2861                         AssertEquals ("test#19", "test_default_value", column.DefaultValue.ToString ());
2862                         AssertEquals ("test#20", false, column.DesignMode);
2863                         AssertEquals ("test#21", "", column.Expression);
2864                         AssertEquals ("test#22", 100, column.MaxLength);
2865                         AssertEquals ("test#23", "", column.Namespace);
2866                         AssertEquals ("test#24", 0, column.Ordinal);
2867                         AssertEquals ("test#25", "", column.Prefix);
2868                         AssertEquals ("test#26", false, column.ReadOnly);
2869                         AssertEquals ("test#27", true, column.Unique);
2870
2871                         DataColumn column2 = Table.Columns[1];
2872                         AssertEquals ("test#28", true, column2.AllowDBNull);
2873                         AssertEquals ("test#29", false, column2.AutoIncrement);
2874                         AssertEquals ("test#30", 0L, column2.AutoIncrementSeed);
2875                         AssertEquals ("test#31", 1L, column2.AutoIncrementStep);
2876                         AssertEquals ("test#32", "second", column2.Caption);
2877                         AssertEquals ("test#33", "Element", column2.ColumnMapping.ToString ());
2878                         AssertEquals ("test#34", "second", column2.ColumnName);
2879                         AssertEquals ("test#35", "System.Data.SqlTypes.SqlGuid", column2.DataType.ToString ());
2880                         AssertEquals ("test#36", "Null", column2.DefaultValue.ToString ());
2881                         AssertEquals ("test#37", false, column2.DesignMode);
2882                         AssertEquals ("test#38", "", column2.Expression);
2883                         AssertEquals ("test#39", -1, column2.MaxLength);
2884                         AssertEquals ("test#40", "", column2.Namespace);
2885                         AssertEquals ("test#41", 1, column2.Ordinal);
2886                         AssertEquals ("test#42", "", column2.Prefix);
2887                         AssertEquals ("test#43", false, column2.ReadOnly);
2888                         AssertEquals ("test#44", false, column2.Unique);
2889
2890                         DataTable Table2 = new DataTable ();
2891                         Table2.ReadXmlSchema ("Test/System.Data/own_schema2.xsd");
2892
2893                         AssertEquals ("test#45", "second_test_table", Table2.TableName);
2894                         AssertEquals ("test#46", "", Table2.Namespace);
2895                         AssertEquals ("test#47", 1, Table2.Columns.Count);
2896                         AssertEquals ("test#48", 0, Table2.Rows.Count);
2897                         AssertEquals ("test#49", false, Table2.CaseSensitive);
2898                         AssertEquals ("test#50", 1, Table2.Constraints.Count);
2899                         AssertEquals ("test#51", "", Table2.Prefix);
2900
2901                         DataColumn column3 = Table2.Columns[0];
2902                         AssertEquals ("test#52", true, column3.AllowDBNull);
2903                         AssertEquals ("test#53", false, column3.AutoIncrement);
2904                         AssertEquals ("test#54", 0L, column3.AutoIncrementSeed);
2905                         AssertEquals ("test#55", 1L, column3.AutoIncrementStep);
2906                         AssertEquals ("test#56", "second_first", column3.Caption);
2907                         AssertEquals ("test#57", "Element", column3.ColumnMapping.ToString ());
2908                         AssertEquals ("test#58", "second_first", column3.ColumnName);
2909                         AssertEquals ("test#59", "System.String", column3.DataType.ToString ());
2910                         AssertEquals ("test#60", "default_value", column3.DefaultValue.ToString ());
2911                         AssertEquals ("test#61", false, column3.DesignMode);
2912                         AssertEquals ("test#62", "", column3.Expression);
2913                         AssertEquals ("test#63", 100, column3.MaxLength);
2914                         AssertEquals ("test#64", "", column3.Namespace);
2915                         AssertEquals ("test#65", 0, column3.Ordinal);
2916                         AssertEquals ("test#66", "", column3.Prefix);
2917                         AssertEquals ("test#67", false, column3.ReadOnly);
2918                         AssertEquals ("test#68", true, column3.Unique);
2919                 }
2920
2921                 [Test]
2922                 public void ReadXmlSchema_2 () {
2923                         DataTable dt = new DataTable ();
2924                         string xmlData = string.Empty;
2925                         xmlData += "<?xml version=\"1.0\"?>";
2926                         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\">";
2927                         xmlData += "<xs:element name=\"SiteConfiguration\" msdata:IsDataSet=\"true\" msdata:EnforceConstraints=\"False\">";
2928                         xmlData += "<xs:complexType>";
2929                         xmlData += "<xs:choice  minOccurs=\"0\" maxOccurs=\"unbounded\">";
2930                         xmlData += "<xs:element name=\"Tab\">";
2931                         xmlData += "<xs:complexType>";
2932                         xmlData += "<xs:sequence>";
2933                         xmlData += "<xs:element name=\"Module\" minOccurs=\"0\" maxOccurs=\"unbounded\">";
2934                         xmlData += "<xs:complexType>";
2935                         xmlData += "<xs:attribute name=\"ModuleId\" form=\"unqualified\" type=\"xs:int\" />";
2936                         xmlData += "</xs:complexType>";
2937                         xmlData += "</xs:element>";
2938                         xmlData += "</xs:sequence>";
2939                         xmlData += "<xs:attribute name=\"TabId\" form=\"unqualified\" type=\"xs:int\" />";
2940                         xmlData += "</xs:complexType>";
2941                         xmlData += "</xs:element>";
2942                         xmlData += "</xs:choice>";
2943                         xmlData += "</xs:complexType>";
2944                         xmlData += "<xs:key name=\"TabKey\" msdata:PrimaryKey=\"true\">";
2945                         xmlData += "<xs:selector xpath=\".//mstns:Tab\" />";
2946                         xmlData += "<xs:field xpath=\"@TabId\" />";
2947                         xmlData += "</xs:key>";
2948                         xmlData += "<xs:key name=\"ModuleKey\" msdata:PrimaryKey=\"true\">";
2949                         xmlData += "<xs:selector xpath=\".//mstns:Module\" />";
2950                         xmlData += "<xs:field xpath=\"@ModuleID\" />";
2951                         xmlData += "</xs:key>";
2952                         xmlData += "</xs:element>";
2953                         xmlData += "</xs:schema>";
2954                         dt.ReadXmlSchema (new StringReader (xmlData));
2955                 }
2956
2957                 [Test]
2958                 public void ReadXmlSchema_ByStream () {
2959                         DataSet ds1 = new DataSet ();
2960                         ds1.Tables.Add (DataProvider.CreateParentDataTable ());
2961                         ds1.Tables.Add (DataProvider.CreateChildDataTable ());
2962
2963                         MemoryStream ms1 = new MemoryStream ();
2964                         MemoryStream ms2 = new MemoryStream ();
2965                         //write xml  schema only
2966                         //ds1.WriteXmlSchema (ms);
2967                         ds1.Tables[0].WriteXmlSchema (ms1);
2968                         ds1.Tables[1].WriteXmlSchema (ms2);
2969
2970                         MemoryStream ms11 = new MemoryStream (ms1.GetBuffer ());
2971                         MemoryStream ms22 = new MemoryStream (ms2.GetBuffer ());
2972                         //copy schema
2973                         //DataSet ds2 = new DataSet ();
2974                         DataTable dt1 = new DataTable ();
2975                         DataTable dt2 = new DataTable ();
2976
2977                         //ds2.ReadXmlSchema (ms1);
2978                         dt1.ReadXmlSchema (ms11);
2979                         dt2.ReadXmlSchema (ms22);
2980
2981                         //check xml schema
2982                         // ReadXmlSchema - Tables count
2983                         //Assert.AreEqual (ds2.Tables.Count, ds1.Tables.Count, "DS269");
2984
2985                         // ReadXmlSchema - Tables 0 Col count
2986                         AssertEquals ("DS270", ds1.Tables[0].Columns.Count, dt1.Columns.Count);
2987
2988                         // ReadXmlSchema - Tables 1 Col count
2989                         AssertEquals ("DS271", ds1.Tables[1].Columns.Count, dt2.Columns.Count);
2990
2991                         //check some colummns types
2992                         // ReadXmlSchema - Tables 0 Col type
2993                         AssertEquals ("DS272", ds1.Tables[0].Columns[0].GetType (), dt1.Columns[0].GetType ());
2994
2995                         // ReadXmlSchema - Tables 1 Col type
2996                         AssertEquals ("DS273", ds1.Tables[1].Columns[3].GetType (), dt2.Columns[3].GetType ());
2997
2998                         //check that no data exists
2999                         // ReadXmlSchema - Table 1 row count
3000                         AssertEquals ("DS274",0, dt1.Rows.Count);
3001
3002                         // ReadXmlSchema - Table 2 row count
3003                         AssertEquals ("DS275",0, dt2.Rows.Count);
3004                 }
3005
3006                 [Test]
3007                 //[Category ("NotWorking")]
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 }