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