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

   1
   2 // DataTableReaderTest.cs - NUnit Test Cases for testing the DataTableReader
   3 //
   4 // Authors:
   5 //   Sureshkumar T <tsureshkumar@novell.com>
   6 //
   7 //
   8
   9 //
  10 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
  11 //
  12 // Permission is hereby granted, free of charge, to any person obtaining
  13 // a copy of this software and associated documentation files (the
  14 // "Software"), to deal in the Software without restriction, including
  15 // without limitation the rights to use, copy, modify, merge, publish,
  16 // distribute, sublicense, and/or sell copies of the Software, and to
  17 // permit persons to whom the Software is furnished to do so, subject to
  18 // the following conditions:
  19 //
  20 // The above copyright notice and this permission notice shall be
  21 // included in all copies or substantial portions of the Software.
  22 //
  23 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  27 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  28 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  29 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  30 //
  31
  32
  33 using System;
  34 using System.Data;
  35 using System.Data.Common;
  36 using System.Collections;
  37
  38 using NUnit.Framework;
  39
  40 namespace MonoTests.System.Data
  41 {
  42         [TestFixture]
  43         public class DataTableReaderTest
  44         {
  45                 DataTable dt;
  46
  47                 [SetUp]
  48                 public void Setup ()
  49                 {
  50                         dt = new DataTable ("test");
  51                         dt.Columns.Add ("id", typeof (int));
  52                         dt.Columns.Add ("name", typeof (string));
  53                         dt.PrimaryKey = new DataColumn [] { dt.Columns ["id"] };
  54
  55                         dt.Rows.Add (new object [] { 1, "mono 1" });
  56                         dt.Rows.Add (new object [] { 2, "mono 2" });
  57                         dt.Rows.Add (new object [] { 3, "mono 3" });
  58
  59                         dt.AcceptChanges ();
  60
  61                 }
  62
  63                 #region Positive Tests
  64                 [Test]
  65                 public void CtorTest ()
  66                 {
  67                         dt.Rows [1].Delete ();
  68                         DataTableReader reader = new DataTableReader (dt);
  69                         try {
  70
  71                                 int i = 0;
  72                                 while (reader.Read ())
  73                                         i++;
  74                                 reader.Close ();
  75
  76                                 Assert.AreEqual (2, i, "no. of rows iterated is wrong");
  77                         } finally {
  78                                 if (reader != null && !reader.IsClosed)
  79                                         reader.Close ();
  80                         }
  81                 }
  82
  83                 [Test]
  84                 [ExpectedException (typeof (InvalidOperationException))]
  85                 public void RowInAccessibleTest ()
  86                 {
  87
  88                         DataTableReader reader = new DataTableReader (dt);
  89                         try {
  90                                 reader.Read ();
  91                                 reader.Read (); // 2nd row
  92                                 dt.Rows [1].Delete ();
  93                                 string value = reader [1].ToString ();
  94                         } finally {
  95                                 if (reader != null && !reader.IsClosed)
  96                                         reader.Close ();
  97                         }
  98                 }
  99
 100                 [Test]
 101                 public void IgnoreDeletedRowsDynamicTest ()
 102                 {
 103
 104                         DataTableReader reader = new DataTableReader (dt);
 105                         try {
 106                                 reader.Read (); // first row
 107                                 dt.Rows [1].Delete ();
 108                                 reader.Read (); // it should be 3rd row
 109                                 string value = reader [0].ToString ();
 110                                 Assert.AreEqual ("3", value, "#1 reader should have moved to 3rd row");
 111                         } finally {
 112                                 if (reader != null && !reader.IsClosed)
 113                                         reader.Close ();
 114                         }
 115                 }
 116
 117                 [Test]
 118                 public void SeeTheModifiedTest ()
 119                 {
 120                         DataTableReader reader = new DataTableReader (dt);
 121                         try {
 122                                 reader.Read (); // first row
 123                                 dt.Rows [1] ["name"] = "mono changed";
 124                                 reader.Read ();
 125                                 string value = reader [1].ToString ();
 126                                 Assert.AreEqual ("mono changed", value, "#2 reader should have moved to 3rd row");
 127                         } finally {
 128                                 if (reader != null && !reader.IsClosed)
 129                                         reader.Close ();
 130                         }
 131                 }
 132
 133                 [Test]
 134                 public void SchemaTest ()
 135                 {
 136                         DataTable another = new DataTable ("another");
 137                         another.Columns.Add ("x", typeof (string));
 138
 139                         another.Rows.Add (new object [] {"test 1" });
 140                         another.Rows.Add (new object [] {"test 2" });
 141                         another.Rows.Add (new object [] {"test 3" });
 142
 143                         DataTableReader reader = new DataTableReader (new DataTable [] { dt, another });
 144                         try {
 145                                 DataTable schema = reader.GetSchemaTable ();
 146
 147                                 Assert.AreEqual (dt.Columns.Count, schema.Rows.Count, "#1 should be same");
 148                                 Assert.AreEqual (dt.Columns [1].DataType.ToString (), schema.Rows [1] ["DataType"].ToString (), "#2 data type should match");
 149
 150                                 reader.NextResult (); //schema should change here
 151                                 schema = reader.GetSchemaTable ();
 152
 153                                 Assert.AreEqual (another.Columns.Count, schema.Rows.Count, "#3 should be same");
 154                                 Assert.AreEqual (another.Columns [0].DataType.ToString (), schema.Rows [0] ["DataType"].ToString (), "#4 data type should match");
 155
 156                         } finally {
 157                                 if (reader != null && !reader.IsClosed)
 158                                         reader.Close ();
 159                         }
 160                 }
 161
 162                 [Test]
 163                 public void MultipleResultSetsTest ()
 164                 {
 165                         DataTable dt1 = new DataTable ("test2");
 166                         dt1.Columns.Add ("x", typeof (string));
 167                         dt1.Rows.Add (new object [] {"test"} );
 168                         dt1.Rows.Add (new object [] {"test1"} );
 169                         dt1.AcceptChanges ();
 170
 171                         DataTable [] collection = new DataTable [] { dt, dt1 } ;
 172
 173                         DataTableReader reader = new DataTableReader (collection);
 174                         try {
 175                                 int i = 0;
 176                                 do {
 177                                         while (reader.Read ())
 178                                                 i++;
 179                                 } while (reader.NextResult ());
 180
 181                                 Assert.AreEqual (5, i, "#1 rows should be of both the tables");
 182                         } finally {
 183                                 if (reader != null && !reader.IsClosed)
 184                                         reader.Close ();
 185                         }
 186                 }
 187
 188                 [Test]
 189                 public void GetTest ()
 190                 {
 191                         dt.Columns.Add ("nullint", typeof (int));
 192                         dt.Rows [0] ["nullint"] = 333;
 193
 194                         DataTableReader reader = new DataTableReader (dt);
 195                         try {
 196                                 reader.Read ();
 197
 198                                 int ordinal = reader.GetOrdinal ("nullint");
 199                                 // Get by name
 200                                 Assert.AreEqual (1, (int) reader ["id"], "#1 should be able to get by name");
 201                                 Assert.AreEqual (333, reader.GetInt32 (ordinal), "#2 should get int32");
 202                                 Assert.AreEqual ("System.Int32", reader.GetDataTypeName (ordinal), "#3 data type should match");
 203                         } finally {
 204                                 if (reader != null && !reader.IsClosed)
 205                                         reader.Close ();
 206                         }
 207                 }
 208
 209                 [Test]
 210                 [ExpectedException (typeof (InvalidOperationException))]
 211                 public void CloseTest ()
 212                 {
 213                         DataTableReader reader = new DataTableReader (dt);
 214                         try {
 215                                 int i = 0;
 216                                 while (reader.Read () && i < 1)
 217                                         i++;
 218                                 reader.Close ();
 219                                 reader.Read ();
 220                         } finally {
 221                                 if (reader != null && !reader.IsClosed)
 222                                         reader.Close ();
 223                         }
 224                 }
 225
 226                 [Test]
 227                 public void GetOrdinalTest ()
 228                 {
 229                         DataTableReader reader = new DataTableReader (dt);
 230                         try {
 231                                 Assert.AreEqual (1, reader.GetOrdinal ("name"), "#1 get ordinal should work even" +
 232                                                  " without calling Read");
 233                         } finally {
 234                                 if (reader != null && !reader.IsClosed)
 235                                         reader.Close ();
 236                         }
 237                 }
 238                 #endregion // Positive Tests
 239
 240
 241                 #region Negative Tests
 242                 [Test]
 243                 public void NoRowsTest ()
 244                 {
 245                         dt.Rows.Clear ();
 246                         dt.AcceptChanges ();
 247
 248                         DataTableReader reader = new DataTableReader (dt);
 249                         try {
 250
 251                                 Assert.IsFalse (reader.Read (), "#1 there are no rows");
 252                                 Assert.IsFalse (reader.NextResult (), "#2 there are no further resultsets");
 253                         } finally {
 254                                 if (reader != null && !reader.IsClosed)
 255                                         reader.Close ();
 256                         }
 257                 }
 258
 259                 [Test]
 260                 [ExpectedException (typeof (ArgumentException))]
 261                 public void NoTablesTest ()
 262                 {
 263                         DataTableReader reader = new DataTableReader (new DataTable [] {});
 264                         try {
 265                                 reader.Read ();
 266                         } finally {
 267                                 if (reader != null && !reader.IsClosed)
 268                                         reader.Close ();
 269                         }
 270                 }
 271
 272                 [Test]
 273                 [ExpectedException (typeof (InvalidOperationException))]
 274                 public void ReadAfterClosedTest ()
 275                 {
 276                         DataTableReader reader = new DataTableReader (dt);
 277                         try {
 278                                 reader.Read ();
 279                                 reader.Close ();
 280                                 reader.Read ();
 281                         } finally {
 282                                 if (reader != null && !reader.IsClosed)
 283                                         reader.Close ();
 284                         }
 285                 }
 286
 287                 [Test]
 288                 [ExpectedException (typeof (InvalidOperationException))]
 289                 public void AccessAfterClosedTest ()
 290                 {
 291                         DataTableReader reader = new DataTableReader (dt);
 292                         try {
 293                                 reader.Read ();
 294                                 reader.Close ();
 295                                 int i = (int) reader [0];
 296                                 i++; // to supress warning
 297                         } finally {
 298                                 if (reader != null && !reader.IsClosed)
 299                                         reader.Close ();
 300                         }
 301                 }
 302
 303                 [Test]
 304                 [ExpectedException (typeof (InvalidOperationException))]
 305                 public void AccessBeforeReadTest ()
 306                 {
 307                         DataTableReader reader = new DataTableReader (dt);
 308                         try {
 309                                 int i = (int) reader [0];
 310                                 i++; // to supress warning
 311                         } finally {
 312                                 if (reader != null && !reader.IsClosed)
 313                                         reader.Close ();
 314                         }
 315                 }
 316
 317                 [Test]
 318                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
 319                 public void InvalidIndexTest ()
 320                 {
 321                         DataTableReader reader = new DataTableReader (dt);
 322                         try {
 323                                 reader.Read ();
 324                                 int i = (int) reader [90]; // kidding, ;-)
 325                                 i++; // to supress warning
 326                         } finally {
 327                                 if (reader != null && !reader.IsClosed)
 328                                         reader.Close ();
 329                         }
 330                 }
 331
 332                 [Test]
 333                 public void DontSeeTheEarlierRowsTest ()
 334                 {
 335                         DataTableReader reader = new DataTableReader (dt);
 336                         try {
 337                                 reader.Read (); // first row
 338                                 reader.Read (); // second row
 339
 340                                 // insert a row at position 0
 341                                 DataRow r = dt.NewRow ();
 342                                 r [0] = 0;
 343                                 r [1] = "adhi bagavan";
 344                                 dt.Rows.InsertAt (r, 0);
 345
 346                                 Assert.AreEqual (2, (int) reader.GetInt32 (0), "#1 should not alter the position");
 347                         } finally {
 348                                 if (reader != null && !reader.IsClosed)
 349                                         reader.Close ();
 350                         }
 351                 }
 352
 353                 [Test]
 354                 public void AddBeforePointTest ()
 355                 {
 356                         DataTableReader reader = new DataTableReader (dt);
 357                         try {
 358                                 reader.Read (); // first row
 359                                 reader.Read (); // second row
 360                                 DataRow r = dt.NewRow ();
 361                                 r [0] = 0;
 362                                 r [1] = "adhi bagavan";
 363                                 dt.Rows.InsertAt (r, 0);
 364                                 dt.Rows.Add (new object [] { 4, "mono 4"}); // should not affect the counter
 365                                 Assert.AreEqual (2, (int) reader [0], "#1 should not affect the current position");
 366                         } finally {
 367                                 if (reader != null && !reader.IsClosed)
 368                                         reader.Close ();
 369                         }
 370                 }
 371
 372                 [Test]
 373                 public void AddAtPointTest ()
 374                 {
 375                         DataTableReader reader = new DataTableReader (dt);
 376                         try {
 377                                 reader.Read (); // first row
 378                                 reader.Read (); // second row
 379                                 DataRow r = dt.NewRow ();
 380                                 r [0] = 0;
 381                                 r [1] = "same point";
 382                                 dt.Rows.InsertAt (r, 1);
 383                                 dt.Rows.Add (new object [] { 4, "mono 4"}); // should not affect the counter
 384                                 Assert.AreEqual (2, (int) reader [0], "#1 should not affect the current position");
 385                         } finally {
 386                                 if (reader != null && !reader.IsClosed)
 387                                         reader.Close ();
 388                         }
 389                 }
 390
 391                 [Test]
 392                 public void DeletePreviousAndAcceptChangesTest ()
 393                 {
 394                         DataTableReader reader = new DataTableReader (dt);
 395                         try {
 396                                 reader.Read (); // first row
 397                                 reader.Read (); // second row
 398                                 dt.Rows [0].Delete ();
 399                                 dt.AcceptChanges ();
 400                                 Assert.AreEqual (2, (int) reader [0], "#1 should not affect the current position");
 401                         } finally {
 402                                 if (reader != null && !reader.IsClosed)
 403                                         reader.Close ();
 404                         }
 405
 406                 }
 407
 408                 [Test]
 409                 public void DeleteCurrentAndAcceptChangesTest2 ()
 410                 {
 411                         DataTableReader reader = new DataTableReader (dt);
 412                         try {
 413                                 reader.Read (); // first row
 414                                 reader.Read (); // second row
 415                                 dt.Rows [1].Delete (); // delete row, where reader points to
 416                                 dt.AcceptChanges (); // accept the action
 417                                 Assert.AreEqual (1, (int) reader [0], "#1 should point to the first row");
 418                         } finally {
 419                                 if (reader != null && !reader.IsClosed)
 420                                         reader.Close ();
 421                         }
 422                 }
 423
 424                 [Test]
 425                 [ExpectedException (typeof (InvalidOperationException))]
 426                 public void DeleteFirstCurrentAndAcceptChangesTest ()
 427                 {
 428                         DataTableReader reader = new DataTableReader (dt);
 429                         try {
 430                                 reader.Read (); // first row
 431                                 dt.Rows [0].Delete (); // delete row, where reader points to
 432                                 dt.AcceptChanges (); // accept the action
 433                                 Assert.AreEqual (2, (int) reader [0], "#1 should point to the first row");
 434                         } finally {
 435                                 if (reader != null && !reader.IsClosed)
 436                                         reader.Close ();
 437                         }
 438                 }
 439
 440                 [Test]
 441                 public void DeleteLastAndAcceptChangesTest2 ()
 442                 {
 443                         DataTableReader reader = new DataTableReader (dt);
 444                         try {
 445                                 reader.Read (); // first row
 446                                 reader.Read (); // second row
 447                                 reader.Read (); // third row
 448                                 dt.Rows [2].Delete (); // delete row, where reader points to
 449                                 dt.AcceptChanges (); // accept the action
 450                                 Assert.AreEqual (2, (int) reader [0], "#1 should point to the first row");
 451                         } finally {
 452                                 if (reader != null && !reader.IsClosed)
 453                                         reader.Close ();
 454                         }
 455                 }
 456
 457                 [Test]
 458                 public void ClearTest ()
 459                 {
 460                         DataTableReader reader = null;
 461                         try {
 462                                 reader = new DataTableReader (dt);
 463                                 reader.Read (); // first row
 464                                 reader.Read (); // second row
 465                                 dt.Clear ();
 466                                 try {
 467                                         int i = (int) reader [0];
 468                                         i++; // supress warning
 469                                         Assert.Fail("#1 should have thrown RowNotInTableException");
 470                                 } catch (RowNotInTableException) {}
 471
 472                                 // clear and add test
 473                                 reader.Close ();
 474                                 reader = new DataTableReader (dt);
 475                                 reader.Read (); // first row
 476                                 reader.Read (); // second row
 477                                 dt.Clear ();
 478                                 dt.Rows.Add (new object [] {8, "mono 8"});
 479                                 dt.AcceptChanges ();
 480                                 bool success = reader.Read ();
 481                                 Assert.IsFalse (success, "#2 is always invalid");
 482
 483                                 // clear when reader is not read yet
 484                                 reader.Close ();
 485                                 reader = new DataTableReader (dt);
 486                                 dt.Clear ();
 487                                 dt.Rows.Add (new object [] {8, "mono 8"});
 488                                 dt.AcceptChanges ();
 489                                 success = reader.Read ();
 490                                 Assert.IsTrue (success, "#3 should add");
 491                         } finally {
 492                                 if (reader != null && !reader.IsClosed)
 493                                         reader.Close ();
 494                         }
 495
 496                 }
 497
 498                 [Test]
 499                 public void MultipleDeleteTest ()
 500                 {
 501                         dt.Rows.Add (new object [] {4, "mono 4"});
 502                         dt.Rows.Add (new object [] {5, "mono 5"});
 503                         dt.Rows.Add (new object [] {6, "mono 6"});
 504                         dt.Rows.Add (new object [] {7, "mono 7"});
 505                         dt.Rows.Add (new object [] {8, "mono 8"});
 506                         dt.AcceptChanges ();
 507
 508                         DataTableReader reader = new DataTableReader (dt);
 509                         try {
 510                                 reader.Read (); // first row
 511                                 reader.Read ();
 512                                 reader.Read ();
 513                                 reader.Read ();
 514                                 reader.Read ();
 515
 516                                 dt.Rows [3].Delete ();
 517                                 dt.Rows [1].Delete ();
 518                                 dt.Rows [2].Delete ();
 519                                 dt.Rows [0].Delete ();
 520                                 dt.Rows [6].Delete ();
 521                                 dt.AcceptChanges ();
 522
 523                                 Assert.AreEqual (5, (int) reader [0], "#1 should keep pointing to 5");
 524                         } finally {
 525                                 if (reader != null && !reader.IsClosed)
 526                                         reader.Close ();
 527                         }
 528                 }
 529                 #endregion // Negative Tests
 530
 531                 [Test]
 532                 public void TestSchemaTable()
 533                 {
 534                         DataSet ds = new DataSet();
 535                         DataTable testTable = new DataTable ("TestTable1");
 536                         DataTable testTable1 = new DataTable ();
 537
 538                         testTable.Namespace = "TableNamespace";
 539
 540                         testTable1.Columns.Add ("col1", typeof(int));
 541                         testTable1.Columns.Add ("col2", typeof(int));
 542                         ds.Tables.Add (testTable);
 543                         ds.Tables.Add (testTable1);
 544
 545                         //create a col for standard datatype
 546
 547                         testTable.Columns.Add ("col_string");
 548                         testTable.Columns.Add ("col_string_fixed");
 549                         testTable.Columns ["col_string_fixed"].MaxLength = 10;
 550                         testTable.Columns.Add ("col_int", typeof(int));
 551                         testTable.Columns.Add ("col_decimal", typeof(decimal));
 552                         testTable.Columns.Add ("col_datetime", typeof(DateTime));
 553                         testTable.Columns.Add ("col_float", typeof (float));
 554
 555                         // Check for col constraints/properties
 556                         testTable.Columns.Add ("col_readonly").ReadOnly = true;
 557
 558                         testTable.Columns.Add ("col_autoincrement", typeof(Int64)).AutoIncrement = true;
 559                         testTable.Columns ["col_autoincrement"].AutoIncrementStep = 5;
 560                         testTable.Columns ["col_autoincrement"].AutoIncrementSeed = 10;
 561
 562                         testTable.Columns.Add ("col_pk");
 563                         testTable.PrimaryKey = new DataColumn[] {testTable.Columns ["col_pk"]};
 564
 565                         testTable.Columns.Add ("col_unique");
 566                         testTable.Columns ["col_unique"].Unique = true;
 567
 568                         testTable.Columns.Add ("col_defaultvalue");
 569                         testTable.Columns ["col_defaultvalue"].DefaultValue = "DefaultValue";
 570
 571                         testTable.Columns.Add ("col_expression_local", typeof(int));
 572                         testTable.Columns ["col_expression_local"].Expression = "col_int*5";
 573
 574                         ds.Relations.Add ("rel", new DataColumn[] {testTable1.Columns ["col1"]},
 575                                         new DataColumn[] {testTable.Columns ["col_int"]}, false);
 576                         testTable.Columns.Add ("col_expression_ext");
 577                         testTable.Columns ["col_expression_ext"].Expression = "parent.col2";
 578
 579                         testTable.Columns.Add ("col_namespace");
 580                         testTable.Columns ["col_namespace"].Namespace = "ColumnNamespace";
 581
 582                         testTable.Columns.Add ("col_mapping");
 583                         testTable.Columns ["col_mapping"].ColumnMapping = MappingType.Attribute;
 584
 585                         DataTable schemaTable = testTable.CreateDataReader ().GetSchemaTable ();
 586
 587                         Assert.AreEqual (25, schemaTable.Columns.Count, "#1");
 588                         Assert.AreEqual (testTable.Columns.Count, schemaTable.Rows.Count, "#2");
 589
 590                         //True for all rows
 591                         for (int i = 0; i < schemaTable.Rows.Count; ++i) {
 592                                 Assert.AreEqual (testTable.TableName, schemaTable.Rows [i]["BaseTableName"], i+"_#3");
 593                                 Assert.AreEqual (ds.DataSetName, schemaTable.Rows [i]["BaseCatalogName"], i+"_#4");
 594                                 Assert.AreEqual (DBNull.Value, schemaTable.Rows [i]["BaseSchemaName"], i+"_#5");
 595                                 Assert.AreEqual (schemaTable.Rows [i]["BaseColumnName"], schemaTable.Rows [i]["ColumnName"], i+"_#6");
 596                                 Assert.IsFalse ((bool)schemaTable.Rows [i]["IsRowVersion"], i+"_#7");
 597                         }
 598
 599                         Assert.AreEqual ("col_string", schemaTable.Rows [0]["ColumnName"], "#8");
 600                         Assert.AreEqual (typeof(string), schemaTable.Rows [0]["DataType"], "#9");
 601                         Assert.AreEqual (-1, schemaTable.Rows [0]["ColumnSize"], "#10");
 602                         Assert.AreEqual (0, schemaTable.Rows [0]["ColumnOrdinal"], "#11");
 603                         // ms.net contradicts documented behavior
 604                         Assert.IsFalse ((bool)schemaTable.Rows [0]["IsLong"], "#12");
 605
 606                         Assert.AreEqual ("col_string_fixed", schemaTable.Rows [1]["ColumnName"], "#13");
 607                         Assert.AreEqual (typeof(string), schemaTable.Rows [1]["DataType"], "#14");
 608                         Assert.AreEqual (10, schemaTable.Rows [1]["ColumnSize"], "#15");
 609                         Assert.AreEqual (1, schemaTable.Rows [1]["ColumnOrdinal"], "#16");
 610                         Assert.IsFalse ((bool)schemaTable.Rows [1]["IsLong"], "#17");
 611
 612                         Assert.AreEqual ("col_int", schemaTable.Rows [2]["ColumnName"], "#18");
 613                         Assert.AreEqual (typeof(int), schemaTable.Rows [2]["DataType"], "#19");
 614                         Assert.AreEqual (DBNull.Value, schemaTable.Rows [2]["NumericPrecision"], "#20");
 615                         Assert.AreEqual (DBNull.Value, schemaTable.Rows [2]["NumericScale"], "#21");
 616                         Assert.AreEqual (-1, schemaTable.Rows [2]["ColumnSize"], "#22");
 617                         Assert.AreEqual (2, schemaTable.Rows [2]["ColumnOrdinal"], "#23");
 618
 619                         Assert.AreEqual ("col_decimal", schemaTable.Rows [3]["ColumnName"], "#24");
 620                         Assert.AreEqual (typeof(decimal), schemaTable.Rows [3]["DataType"], "#25");
 621                         // When are the Precision and Scale Values set ?
 622                         Assert.AreEqual (DBNull.Value, schemaTable.Rows [3]["NumericPrecision"], "#26");
 623                         Assert.AreEqual (DBNull.Value, schemaTable.Rows [3]["NumericScale"], "#27");
 624                         Assert.AreEqual (-1, schemaTable.Rows [3]["ColumnSize"], "#28");
 625                         Assert.AreEqual (3, schemaTable.Rows [3]["ColumnOrdinal"], "#29");
 626
 627                         Assert.AreEqual ("col_datetime", schemaTable.Rows [4]["ColumnName"], "#30");
 628                         Assert.AreEqual (typeof(DateTime), schemaTable.Rows [4]["DataType"], "#31");
 629                         Assert.AreEqual (4, schemaTable.Rows [4]["ColumnOrdinal"], "#32");
 630
 631                         Assert.AreEqual ("col_float", schemaTable.Rows [5]["ColumnName"], "#33");
 632                         Assert.AreEqual (typeof(float), schemaTable.Rows [5]["DataType"], "#34");
 633                         Assert.AreEqual (5, schemaTable.Rows [5]["ColumnOrdinal"], "#35");
 634                         Assert.AreEqual (DBNull.Value, schemaTable.Rows [5]["NumericPrecision"], "#36");
 635                         Assert.AreEqual (DBNull.Value, schemaTable.Rows [5]["NumericScale"], "#37");
 636                         Assert.AreEqual (-1, schemaTable.Rows [5]["ColumnSize"], "#38");
 637
 638                         Assert.AreEqual ("col_readonly", schemaTable.Rows [6]["ColumnName"], "#39");
 639                         Assert.IsTrue ((bool)schemaTable.Rows [6]["IsReadOnly"], "#40");
 640
 641                         Assert.AreEqual ("col_autoincrement", schemaTable.Rows [7]["ColumnName"], "#9");
 642                         Assert.IsTrue ((bool)schemaTable.Rows [7]["IsAutoIncrement"], "#41");
 643                         Assert.AreEqual (10, schemaTable.Rows [7]["AutoIncrementSeed"], "#42");
 644                         Assert.AreEqual (5, schemaTable.Rows [7]["AutoIncrementStep"], "#43");
 645                         Assert.IsFalse ((bool)schemaTable.Rows [7]["IsReadOnly"], "#44");
 646
 647                         Assert.AreEqual ("col_pk", schemaTable.Rows [8]["ColumnName"], "#45");
 648                         Assert.IsTrue ((bool)schemaTable.Rows [8]["IsKey"], "#46");
 649                         Assert.IsTrue ((bool)schemaTable.Rows [8]["IsUnique"], "#47");
 650
 651                         Assert.AreEqual ("col_unique", schemaTable.Rows [9]["ColumnName"], "#48");
 652                         Assert.IsTrue ((bool)schemaTable.Rows [9]["IsUnique"], "#49");
 653
 654                         Assert.AreEqual ("col_defaultvalue", schemaTable.Rows [10]["ColumnName"], "#50");
 655                         Assert.AreEqual ("DefaultValue", schemaTable.Rows [10]["DefaultValue"], "#51");
 656
 657                         Assert.AreEqual ("col_expression_local", schemaTable.Rows [11]["ColumnName"], "#52");
 658                         Assert.AreEqual ("col_int*5", schemaTable.Rows [11]["Expression"], "#53");
 659                         Assert.IsTrue ((bool)schemaTable.Rows [11]["IsReadOnly"], "#54");
 660
 661                         // if expression depends on a external col, then set Expression as null..
 662                         Assert.AreEqual ("col_expression_ext", schemaTable.Rows [12]["ColumnName"], "#55");
 663                         Assert.AreEqual (DBNull.Value, schemaTable.Rows [12]["Expression"], "#56");
 664                         Assert.IsTrue ((bool)schemaTable.Rows [12]["IsReadOnly"], "#57");
 665
 666                         Assert.AreEqual ("col_namespace", schemaTable.Rows [13]["ColumnName"], "#58");
 667                         Assert.AreEqual ("TableNamespace", schemaTable.Rows [13]["BaseTableNamespace"], "#59");
 668                         Assert.AreEqual ("TableNamespace", schemaTable.Rows [12]["BaseColumnNamespace"], "#60");
 669                         Assert.AreEqual ("ColumnNamespace", schemaTable.Rows [13]["BaseColumnNamespace"], "#61");
 670
 671                         Assert.AreEqual ("col_mapping", schemaTable.Rows [14]["ColumnName"], "#62");
 672                         Assert.AreEqual (MappingType.Element, (MappingType)schemaTable.Rows [13]["ColumnMapping"], "#63");
 673                         Assert.AreEqual (MappingType.Attribute, (MappingType)schemaTable.Rows [14]["ColumnMapping"], "#64");
 674                 }
 675
 676                 [Test]
 677                 public void TestExceptionIfSchemaChanges ()
 678                 {
 679                         DataTable table = new DataTable ();
 680                         table.Columns.Add ("col1");
 681                         DataTableReader rdr = table.CreateDataReader ();
 682                         Assert.AreEqual (1, rdr.GetSchemaTable().Rows.Count, "#1");
 683
 684                         table.Columns [0].ColumnName = "newcol1";
 685                         try {
 686                                 rdr.GetSchemaTable ();
 687                                 Assert.Fail ("#0");
 688                         } catch (InvalidOperationException e) {
 689                                 // Never premise English.
 690                                 //Assert.AreEqual ("Schema of current DataTable '" + table.TableName +
 691                                 //              "' in DataTableReader has changed, DataTableReader is invalid.", e.Message, "#1");
 692                         }
 693
 694                         rdr = table.CreateDataReader ();
 695                         rdr.GetSchemaTable (); //no exception
 696                         table.Columns.Add ("col2");
 697                         try {
 698                                 rdr.GetSchemaTable ();
 699                                 Assert.Fail ("#1");
 700                         } catch (InvalidOperationException e) {
 701                                 // Never premise English.
 702                                 //Assert.AreEqual ("Schema of current DataTable '" + table.TableName +
 703                                 //              "' in DataTableReader has changed, DataTableReader is invalid.", e.Message, "#1");
 704                         }
 705                 }
 706
 707                 [Test]
 708                 public void EnumeratorTest ()
 709                 {
 710                         DataTable table = new DataTable ();
 711                         table.Columns.Add ("col1", typeof(int));
 712                         table.Rows.Add (new object[] {0});
 713                         table.Rows.Add (new object[] {1});
 714
 715                         DataTableReader rdr = table.CreateDataReader ();
 716                         IEnumerator enmr = rdr.GetEnumerator ();
 717
 718                         table.Rows.Add (new object[] {2});
 719                         table.Rows.RemoveAt (0);
 720
 721                         //Test if the Enumerator is stable
 722                         int i = 1;
 723                         while (enmr.MoveNext ()) {
 724                                 DbDataRecord rec = (DbDataRecord)enmr.Current;
 725                                 Assert.AreEqual (i, rec.GetInt32 (0), "#2_" + i);
 726                                 i++;
 727                         }
 728                 }
 729
 730                 [Test]
 731                 public void GetCharsTest()
 732                 {
 733                         dt.Columns.Add ("col2", typeof (char[]));
 734
 735                         dt.Rows.Clear ();
 736                         dt.Rows.Add (new object[] {1, "string", "string".ToCharArray()});
 737                         dt.Rows.Add (new object[] {2, "string1", null});
 738                         DataTableReader rdr = dt.CreateDataReader ();
 739
 740                         rdr.Read ();
 741
 742                         try {
 743                                 rdr.GetChars (1, 0, null, 0, 10);
 744                                 Assert.Fail ("#1");
 745                         } catch (InvalidCastException e) {
 746                                 // Never premise English.
 747                                 //Assert.AreEqual ("Unable to cast object of type 'System.String'" +
 748                                 //      " to type 'System.Char[]'.", e.Message, "#1");
 749                         }
 750                         char[] char_arr = null;
 751                         long len = 0;
 752
 753                         len =  rdr.GetChars (2, 0, null, 0, 0);
 754                         Assert.AreEqual(6, len, "#2");
 755
 756                         char_arr = new char [len];
 757                         len = rdr.GetChars (2, 0, char_arr, 0, 0);
 758                         Assert.AreEqual(0, len, "#3");
 759
 760                         len = rdr.GetChars (2, 0, null, 0, 0);
 761                         char_arr = new char [len+2];
 762                         len = rdr.GetChars (2, 0, char_arr, 2, 100);
 763                         Assert.AreEqual (6, len, "#4");
 764                         char[] val = (char[])rdr.GetValue (2);
 765                         for (int i = 0; i < len; ++i)
 766                                 Assert.AreEqual (val[i], char_arr[i+2], "#5_"+i);
 767                 }
 768
 769                 [Test]
 770                 public void GetProviderSpecificTests()
 771                 {
 772                         DataTableReader rdr = dt.CreateDataReader ();
 773                         while (rdr.Read ()) {
 774                                 object[] values = new object [rdr.FieldCount];
 775                                 object[] pvalues = new object [rdr.FieldCount];
 776                                 rdr.GetValues (values);
 777                                 rdr.GetProviderSpecificValues (pvalues);
 778
 779                                 for (int i = 0; i < rdr.FieldCount; ++i) {
 780                                         Assert.AreEqual(values [i], pvalues [i], "#1");
 781                                         Assert.AreEqual(rdr.GetValue (i), rdr.GetProviderSpecificValue (i), "#2");
 782                                         Assert.AreEqual(rdr.GetFieldType (i), rdr.GetProviderSpecificFieldType (i), "#3");
 783                                 }
 784                         }
 785                 }
 786
 787                 [Test]
 788                 public void GetNameTest()
 789                 {
 790                         DataTableReader rdr = dt.CreateDataReader();
 791                         for (int i = 0; i < dt.Columns.Count; ++i)
 792                                 Assert.AreEqual(dt.Columns[i].ColumnName, rdr.GetName(i), "#1_" + i);
 793                 }
 794         }
 795 }
 796