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