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

   1 // DataRowTest.cs - NUnit Test Cases for System.DataRow
   2 //
   3 // Authors:
   4 //   Franklin Wise (gracenote@earthlink.net)
   5 //   Daniel Morgan <danmorg@sc.rr.com>
   6 //   Roopa Wilson (rowilson@novell.com)
   7 //
   8 // (C) Copyright 2002 Franklin Wise
   9 // (C) Copyright 2003 Daniel Morgan
  10 // (C) Copyright 2003 Martin Willemoes Hansen
  11 // (C) Copyright 2004 Novell Inc.
  12 //
  13
  14 using NUnit.Framework;
  15 using System;
  16 using System.Data;
  17
  18 namespace MonoTests.System.Data
  19 {
  20         [TestFixture]
  21         public class DataRowTest : Assertion {
  22
  23                 private DataTable _tbl;
  24                 private DataTable table;
  25                 private DataRow row;
  26
  27                 [SetUp]
  28                 public void GetReady() {
  29                         _tbl = new DataTable();
  30                         table = MakeTable ();
  31                         row = table.NewRow ();
  32                         row ["FName"] = "Hello";
  33                         row ["LName"] = "World";
  34                         table.Rows.Add (row);
  35                 }
  36
  37                 private DataTable MakeTable ()
  38                 {
  39                         DataTable namesTable = new DataTable ("Names");
  40                         DataColumn idColumn = new  DataColumn ();
  41
  42
  43                         idColumn.DataType = System.Type.GetType ("System.Int32");
  44                         idColumn.ColumnName = "Id";
  45                         idColumn.AutoIncrement = true;
  46                         namesTable.Columns.Add (idColumn);
  47
  48
  49                         DataColumn fNameColumn = new DataColumn ();
  50                         fNameColumn.DataType = System.Type.GetType ("System.String");
  51                         fNameColumn.ColumnName = "Fname";
  52                         fNameColumn.DefaultValue = "Fname";
  53                         namesTable.Columns.Add (fNameColumn);
  54
  55                         DataColumn lNameColumn = new DataColumn ();
  56                         lNameColumn.DataType = System.Type.GetType ("System.String");
  57                         lNameColumn.ColumnName = "LName";
  58                         lNameColumn.DefaultValue="LName";
  59                         namesTable.Columns.Add (lNameColumn);
  60
  61
  62                         // Set the primary key for the table
  63                         DataColumn [] keys = new DataColumn [1];
  64                         keys [0] = idColumn;
  65                         namesTable.PrimaryKey = keys;
  66                         // Return the new DataTable.
  67                         return namesTable;
  68                 }
  69
  70                 [Test]
  71                 public void SetColumnErrorTest ()
  72                 {
  73                         string errorString;
  74                         errorString = "Some error!";
  75                         // Set the error for the specified column of the row.
  76                         row.SetColumnError (1, errorString);
  77                         GetColumnErrorTest ();
  78                         GetAllErrorsTest ();
  79                 }
  80
  81                 private  void GetColumnErrorTest ()
  82                 {
  83                         // Print the error of a specified column.
  84                         AssertEquals ("#A01", "Some error!", row.GetColumnError (1));
  85                 }
  86
  87                 private void GetAllErrorsTest ()
  88                 {
  89                         DataColumn [] colArr;
  90
  91                         if (row.HasErrors) {
  92                                 colArr = row.GetColumnsInError ();
  93
  94                                 for (int i = 0; i < colArr.Length; i++) {
  95                                         AssertEquals ("#A02", table.Columns [1], colArr [i]);
  96                                 }
  97                                 row.ClearErrors ();
  98                         }
  99                 }
 100
 101                 [Test]
 102                 public void RowEditTest()
 103                 {
 104                         DeleteRowTest ();
 105                         EditModeTest ();
 106                         ParentRowTest ();
 107                 }
 108
 109                 private void DeleteRowTest ()
 110                 {
 111                         DataRow newRow;
 112
 113
 114                         for (int i = 1; i <= 2; i++) {
 115                                 newRow = table.NewRow ();
 116                                 newRow ["FName"] = "Name " + i;
 117                                 newRow ["LName"] = " Last Name" + i;
 118                                 table.Rows.Add (newRow);
 119                         }
 120                         table.AcceptChanges ();
 121
 122                         int cnt = 1;
 123                         for (int i = 1; i < table.Rows.Count; i++) {
 124                                 DataRow r = table.Rows [i];
 125                                 AssertEquals ("#A03", "Name " + cnt, r ["fName"]);
 126                                 cnt++;
 127                         }
 128
 129
 130                         // Create a DataView with the table.
 131                         DataRowCollection rc = table.Rows;
 132                         rc [0].Delete ();
 133                         rc [2].Delete ();
 134
 135
 136                         AssertEquals ("#A04", "Deleted", rc [0].RowState.ToString ());
 137                         AssertEquals ("#A05", "Deleted", rc [2].RowState.ToString ());
 138
 139
 140                         // Accept changes
 141                         table.AcceptChanges ();
 142                         AssertEquals ("#A06", "Name 1", (table.Rows [0]) [1]);
 143                         try  {
 144                                 Console.WriteLine (rc [2]);
 145                                 Fail ("#A07");
 146                         }
 147                         catch (Exception e) {
 148                                 AssertEquals ("#A08", "There is no row at position 2.", e.Message);
 149                         }
 150                 }
 151
 152                 private void EditModeTest ()
 153                 {
 154                         try {
 155                                 //Clear all existing values from table
 156                                 for (int i = 0; i < table.Rows.Count; i++) {
 157                                         table.Rows[i].Delete ();
 158                                 }
 159                                 table.AcceptChanges ();
 160                                 row = table.NewRow ();
 161                                 row["FName"] = "My FName";
 162                                 table.Rows.Add (row);
 163
 164
 165                                 // Stage 1
 166                                 //Initially: After Add (Row) But Before Accept Changes");
 167                                 AssertEquals ("#A09", "My FName", row [1, DataRowVersion.Default]);
 168                                 AssertEquals ("#A10", "LName", row [2, DataRowVersion.Default]);
 169
 170                                 AssertEquals ("#A11", "My FName", row [1, DataRowVersion.Current]);
 171                                 AssertEquals ("#A12", "LName", row [2, DataRowVersion.Current]);
 172
 173                                 try {
 174                                         Console.WriteLine (row [1, DataRowVersion.Original]);
 175                                         Console.WriteLine (row [1, DataRowVersion.Proposed]);
 176                                         Fail ("#A13");
 177                                 }
 178                                 catch (Exception e) {
 179                                         if (e.GetType () != typeof (AssertionException)) {
 180                                                 AssertEquals ("#A14", typeof (VersionNotFoundException), e.GetType ());
 181                                         }
 182                                 }
 183
 184                                 // Stage 2
 185                                 //After Accept Changes
 186                                 table.AcceptChanges ();
 187                                 AssertEquals ("#A15", "My FName", row [1, DataRowVersion.Default]);
 188                                 AssertEquals ("#A16", "LName", row [2, DataRowVersion.Default]);
 189
 190
 191                                 AssertEquals ("#A17", "My FName", row [1, DataRowVersion.Current]);
 192                                 AssertEquals ("#A18", "LName", row [2, DataRowVersion.Current]);
 193
 194                                 try {
 195                                         Console.WriteLine (row [1, DataRowVersion.Proposed]);
 196                                         Fail ("#A19");
 197                                 }
 198                                 catch (Exception e) {
 199                                         if (e.GetType () != typeof (AssertionException)) {
 200                                                 AssertEquals ("#A20", typeof (VersionNotFoundException), e.GetType ());
 201                                         }
 202                                 }
 203
 204
 205                                 // Stage 3                                 // Edit Mode
 206                                 table.Rows [0].BeginEdit ();
 207                                 table.Rows [0] ["LName"] = "My LName";
 208
 209                                 AssertEquals ("#A21", "My FName", row [1, DataRowVersion.Default]);
 210                                 AssertEquals ("#A22", "My LName", row [2, DataRowVersion.Default]);
 211
 212                                 AssertEquals ("#A23", "My FName", row [1, DataRowVersion.Current]);
 213                                 AssertEquals ("#A24", "LName", row [2, DataRowVersion.Current]);
 214
 215
 216                                 AssertEquals ("#A25", "My FName", row [1, DataRowVersion.Original]);                                AssertEquals ("#A26", "LName", row [2, DataRowVersion.Original]);
 217
 218                                 AssertEquals ("#A26", "My FName", row [1, DataRowVersion.Proposed]);
 219                                 AssertEquals ("#A27", "My LName", row [2, DataRowVersion.Proposed]);
 220
 221
 222                                 // Stage 4
 223                                 //After Edit sessions
 224                                 for (int i=0; i < table.Rows.Count;i++)
 225                                         table.Rows [i].EndEdit ();
 226                                 AssertEquals ("#A28", "My FName", row [1, DataRowVersion.Default]);
 227                                 AssertEquals ("#A29", "My LName", row [2, DataRowVersion.Default]);
 228
 229                                 AssertEquals ("#A30", "My FName", row [1, DataRowVersion.Original]);                                AssertEquals ("#A31", "LName", row [2, DataRowVersion.Original]);
 230
 231
 232                                 AssertEquals ("#A32", "My FName", row [1, DataRowVersion.Current]);
 233                                 AssertEquals ("#A33", "My LName", row [2, DataRowVersion.Current]);
 234
 235                                 try {
 236                                         Console.WriteLine (row [1, DataRowVersion.Proposed]);
 237                                         Fail ("#A34");
 238                                 }
 239                                 catch (Exception e) {
 240                                         if (e.GetType ()!=typeof (AssertionException)) {
 241                                                 AssertEquals ("#A35", typeof (VersionNotFoundException), e.GetType ());
 242                                         }
 243                                 }
 244
 245                                 //Stage 5
 246                                 //After Accept Changes
 247                                 AssertEquals ("#A36", "My FName", row [1, DataRowVersion.Default]);
 248                                 AssertEquals ("#A37", "My LName", row [2, DataRowVersion.Default]);
 249
 250
 251                                 AssertEquals ("#A38", "My FName", row [1, DataRowVersion.Original]);                                AssertEquals ("#A39", "My LName", row [2, DataRowVersion.Original]);
 252
 253                                 AssertEquals ("#A40", "My FName", row [1, DataRowVersion.Current]);
 254                                 AssertEquals ("#A41", "My LName", row [2, DataRowVersion.Current]);
 255
 256
 257                                 try {
 258                                         Console.WriteLine (row [1, DataRowVersion.Proposed]);
 259                                         Fail ("#A42");
 260                                 }
 261                                 catch (Exception e) {
 262                                                 if (e.GetType () != typeof (AssertionException)) {
 263                                                         AssertEquals ("#A43", typeof (VersionNotFoundException),
 264                                                                 e.GetType ());
 265                                                 }
 266                                         }
 267
 268
 269                         }
 270                         catch (Exception e){
 271                                 Console.WriteLine (e + "" + e.StackTrace);
 272                         }
 273                 }
 274                 private void ParentRowTest (){
 275
 276                         //Clear all existing values from table
 277                         for (int i = 0; i < table.Rows.Count; i++) {
 278                                         table.Rows[i].Delete ();
 279                         }
 280                         table.AcceptChanges ();
 281                         row = table.NewRow ();
 282                         row["FName"] = "My FName";
 283                         row["Id"] = 0;
 284                         table.Rows.Add (row);
 285
 286                         DataTable tableC = new DataTable ("Child");
 287                         DataColumn colC;
 288                         DataRow rowC;
 289
 290                         colC = new DataColumn ();
 291                         colC.DataType = System.Type.GetType ("System.Int32");
 292                         colC.ColumnName = "Id";
 293                         colC.AutoIncrement=true;
 294                         tableC.Columns.Add (colC);
 295
 296
 297                         colC = new DataColumn ();
 298                         colC.DataType = System.Type.GetType ("System.String");
 299                         colC.ColumnName = "Name";
 300                         tableC.Columns.Add (colC);
 301
 302                         rowC = tableC.NewRow ();
 303                         rowC["Name"] = "My FName";
 304                         tableC.Rows.Add (rowC);
 305                         DataSet ds = new DataSet ();
 306                         ds.Tables.Add (table);
 307                         ds.Tables.Add (tableC);
 308                         DataRelation dr = new DataRelation ("PO", table.Columns ["Id"], tableC.Columns ["Id"]);
 309                         ds.Relations.Add (dr);
 310
 311                         rowC.SetParentRow (table.Rows [0], dr);
 312
 313                         AssertEquals ("#A44", table.Rows [0], (tableC.Rows [0]).GetParentRow (dr));
 314                 }
 315
 316
 317                 // tests item at row, column in table to be DBNull.Value
 318                 private void DBNullTest (string message, DataTable dt, int row, int column)
 319                 {
 320                         object val = dt.Rows[row].ItemArray[column];
 321                         AssertEquals(message, DBNull.Value, val);
 322                 }
 323
 324                 // tests item at row, column in table to be null
 325                 private void NullTest (string message, DataTable dt, int row, int column)
 326                 {
 327                         object val = dt.Rows[row].ItemArray[column];
 328                         AssertEquals(message, null, val);
 329                 }
 330
 331                 // tests item at row, column in table to be
 332                 private void ValueTest (string message, DataTable dt, int row, int column, object value)
 333                 {
 334                         object val = dt.Rows[row].ItemArray[column];
 335                         AssertEquals(message, value, val);
 336                 }
 337
 338                 // test set null, DBNull.Value, and ItemArray short count
 339                 [Test]
 340                 public void NullInItemArray ()
 341                 {
 342                         string zero = "zero";
 343                         string one = "one";
 344                         string two = "two";
 345
 346                         DataTable table = new DataTable();
 347                         table.Columns.Add(new DataColumn(zero, typeof(string)));
 348                         table.Columns.Add(new DataColumn(one, typeof(string)));
 349                         table.Columns.Add(new DataColumn(two, typeof(string)));
 350
 351                         object[] obj = new object[3];
 352                         // -- normal -----------------
 353                         obj[0] = zero;
 354                         obj[1] = one;
 355                         obj[2] = two;
 356                         // results:
 357                         //   table.Rows[0].ItemArray.ItemArray[0] = "zero"
 358                         //   table.Rows[0].ItemArray.ItemArray[1] = "one"
 359                         //   table.Rows[0].ItemArray.ItemArray[2] = "two"
 360
 361                         DataRow row = table.NewRow();
 362
 363                         try {
 364                                 row.ItemArray = obj;
 365                         }
 366                         catch(Exception e1) {
 367                                 Fail("DR1: Exception Caught: " + e1);
 368                         }
 369
 370                         table.Rows.Add(row);
 371
 372                         // -- null ----------
 373                         obj[1] = null;
 374                         // results:
 375                         //   table.Rows[1].ItemArray.ItemArray[0] = "zero"
 376                         //   table.Rows[1].ItemArray.ItemArray[1] = DBNull.Value
 377                         //   table.Rows[1].ItemArray.ItemArray[2] = "two"
 378
 379                         row = table.NewRow();
 380
 381                         try {
 382                                 row.ItemArray = obj;
 383                         }
 384                         catch(Exception e2) {
 385                                 Fail("DR2: Exception Caught: " + e2);
 386                         }
 387
 388                         table.Rows.Add(row);
 389
 390                         // -- DBNull.Value -------------
 391                         obj[1] = DBNull.Value;
 392                         // results:
 393                         //   table.Rows[2].ItemArray.ItemArray[0] = "zero"
 394                         //   table.Rows[2].ItemArray.ItemArray[1] = DBNull.Value
 395                         //   table.Rows[2].ItemArray.ItemArray[2] = "two"
 396
 397                         row = table.NewRow();
 398
 399                         try {
 400                                 row.ItemArray = obj;
 401                         }
 402                         catch(Exception e3) {
 403                                 Fail("DR3: Exception Caught: " + e3);
 404                         }
 405
 406                         table.Rows.Add(row);
 407
 408                         // -- object array smaller than number of columns -----
 409                         string abc = "abc";
 410                         string def = "def";
 411                         obj = new object[2];
 412                         obj[0] = abc;
 413                         obj[1] = def;
 414                         // results:
 415                         //   table.Rows[3].ItemArray.ItemArray[0] = "abc"
 416                         //   table.Rows[3].ItemArray.ItemArray[1] = "def"
 417                         //   table.Rows[3].ItemArray.ItemArray[2] = DBNull.Value;
 418
 419                         row = table.NewRow();
 420
 421                         try {
 422                                 row.ItemArray = obj;
 423                         }
 424                         catch(Exception e3) {
 425                                 Fail("DR4: Exception Caught: " + e3);
 426                         }
 427
 428                         table.Rows.Add(row);
 429
 430                         // -- normal -----------------
 431                         ValueTest("DR5: normal value test", table, 0, 0, zero);
 432                         ValueTest("DR6: normal value test", table, 0, 1, one);
 433                         ValueTest("DR7: normal value test", table, 0, 2, two);
 434
 435                         // -- null ----------
 436                         ValueTest("DR8: null value test", table, 1, 0, zero);
 437                         ValueTest("DR9: null value test", table, 1, 1, DBNull.Value);
 438                         ValueTest("DR10: null value test", table, 1, 2, two);
 439
 440                         // -- DBNull.Value -------------
 441                         ValueTest("DR11: DBNull.Value value test", table, 2, 0, zero);
 442                         ValueTest("DR12: DBNull.Value value test", table, 2, 1, DBNull.Value);
 443                         ValueTest("DR13: DBNull.Value value test", table, 2, 2, two);
 444
 445                         // -- object array smaller than number of columns -----
 446                         ValueTest("DR14: array smaller value test", table, 3, 0, abc);
 447                         ValueTest("DR15: array smaller value test", table, 3, 1, def);
 448                         ValueTest("DR16: array smaller value test", table, 3, 2, DBNull.Value);
 449                 }
 450
 451                 // test DefaultValue when setting ItemArray
 452                 [Test]
 453                 public void DefaultValueInItemArray () {
 454                         string zero = "zero";
 455
 456                         DataTable table = new DataTable();
 457                         table.Columns.Add(new DataColumn("zero", typeof(string)));
 458
 459                         DataColumn column = new DataColumn("num", typeof(int));
 460                         column.DefaultValue = 15;
 461                         table.Columns.Add(column);
 462
 463                         object[] obj = new object[2];
 464                         // -- normal -----------------
 465                         obj[0] = "zero";
 466                         obj[1] = 8;
 467                         // results:
 468                         //   table.Rows[0].ItemArray.ItemArray[0] = "zero"
 469                         //   table.Rows[0].ItemArray.ItemArray[1] = 8
 470
 471                         DataRow row = table.NewRow();
 472
 473                         try {
 474                                 row.ItemArray = obj;
 475                         }
 476                         catch(Exception e1) {
 477                                 Fail("DR17: Exception Caught: " + e1);
 478                         }
 479
 480                         table.Rows.Add(row);
 481
 482                         // -- null ----------
 483                         obj[1] = null;
 484                         // results:
 485                         //   table.Rows[1].ItemArray.ItemArray[0] = "zero"
 486                         //   table.Rows[1].ItemArray.ItemArray[1] = 15
 487
 488                         row = table.NewRow();
 489
 490                         try {
 491                                 row.ItemArray = obj;
 492                         }
 493                         catch(Exception e2) {
 494                                 Fail("DR18: Exception Caught: " + e2);
 495                         }
 496
 497                         table.Rows.Add(row);
 498
 499                         // -- DBNull.Value -------------
 500                         obj[1] = DBNull.Value;
 501                         // results:
 502                         //   table.Rows[2].ItemArray.ItemArray[0] = "zero"
 503                         //   table.Rows[2].ItemArray.ItemArray[1] = DBNull.Value
 504                         //      even though internally, the v
 505
 506                         row = table.NewRow();
 507
 508                         try {
 509                                 row.ItemArray = obj;
 510                         }
 511                         catch(Exception e3) {
 512                                 Fail("DR19: Exception Caught: " + e3);
 513                         }
 514
 515                         table.Rows.Add(row);
 516
 517                         // -- object array smaller than number of columns -----
 518                         string abc = "abc";
 519                         string def = "def";
 520                         obj = new object[2];
 521                         obj[0] = abc;
 522                         // results:
 523                         //   table.Rows[3].ItemArray.ItemArray[0] = "abc"
 524                         //   table.Rows[3].ItemArray.ItemArray[1] = DBNull.Value
 525
 526                         row = table.NewRow();
 527
 528                         try {
 529                                 row.ItemArray = obj;
 530                         }
 531                         catch(Exception e3) {
 532                                 Fail("DR20: Exception Caught: " + e3);
 533                         }
 534
 535                         table.Rows.Add(row);
 536
 537                         // -- normal -----------------
 538                         ValueTest("DR20: normal value test", table, 0, 0, zero);
 539                         ValueTest("DR21: normal value test", table, 0, 1, 8);
 540
 541                         // -- null ----------
 542                         ValueTest("DR22: null value test", table, 1, 0, zero);
 543                         ValueTest("DR23: null value test", table, 1, 1, 15);
 544
 545                         // -- DBNull.Value -------------
 546                         ValueTest("DR24: DBNull.Value value test", table, 2, 0, zero);
 547                         DBNullTest("DR25: DBNull.Value value test", table, 2, 1);
 548
 549                         // -- object array smaller than number of columns -----
 550                         ValueTest("DR26: array smaller value test", table, 3, 0, abc);
 551                         ValueTest("DR27: array smaller value test", table, 3, 1, 15);
 552                 }
 553
 554                 // test AutoIncrement when setting ItemArray
 555                 [Test]
 556                 public void AutoIncrementInItemArray () {
 557                         string zero = "zero";
 558                         string num = "num";
 559
 560                         DataTable table = new DataTable();
 561                         table.Columns.Add(new DataColumn(zero, typeof(string)));
 562
 563                         DataColumn column = new DataColumn("num", typeof(int));
 564                         column.AutoIncrement = true;
 565                         table.Columns.Add(column);
 566
 567                         object[] obj = new object[2];
 568                         // -- normal -----------------
 569                         obj[0] = "zero";
 570                         obj[1] = 8;
 571                         // results:
 572                         //   table.Rows[0].ItemArray.ItemArray[0] = "zero"
 573                         //   table.Rows[0].ItemArray.ItemArray[1] = 8
 574
 575                         DataRow row = table.NewRow();
 576
 577                         try {
 578                                 row.ItemArray = obj;
 579                         }
 580                         catch(Exception e1) {
 581                                 Fail("DR28:  Exception Caught: " + e1);
 582                         }
 583
 584                         table.Rows.Add(row);
 585
 586                         // -- null 1----------
 587                         obj[1] = null;
 588                         // results:
 589                         //   table.Rows[1].ItemArray.ItemArray[0] = "zero"
 590                         //   table.Rows[1].ItemArray.ItemArray[1] = 9
 591
 592                         row = table.NewRow();
 593
 594                         try {
 595                                 row.ItemArray = obj;
 596                         }
 597                         catch(Exception e2) {
 598                                 Fail("DR29:  Exception Caught: " + e2);
 599                         }
 600
 601                         table.Rows.Add(row);
 602
 603                         // -- null 2----------
 604                         obj[1] = null;
 605                         // results:
 606                         //   table.Rows[1].ItemArray.ItemArray[0] = "zero"
 607                         //   table.Rows[1].ItemArray.ItemArray[1] = 10
 608
 609                         row = table.NewRow();
 610
 611                         try {
 612                                 row.ItemArray = obj;
 613                         }
 614                         catch(Exception e2) {
 615                                 Fail("DR30: Exception Caught: " + e2);
 616                         }
 617
 618                         table.Rows.Add(row);
 619
 620                         // -- null 3----------
 621                         obj[1] = null;
 622                         // results:
 623                         //   table.Rows[1].ItemArray.ItemArray[0] = "zero"
 624                         //   table.Rows[1].ItemArray.ItemArray[1] = 11
 625
 626                         row = table.NewRow();
 627
 628                         try {
 629                                 row.ItemArray = obj;
 630                         }
 631                         catch(Exception e2) {
 632                                 Fail("DR31: Exception Caught: " + e2);
 633                         }
 634
 635                         table.Rows.Add(row);
 636
 637                         // -- DBNull.Value -------------
 638                         obj[1] = DBNull.Value;
 639                         // results:
 640                         //   table.Rows[2].ItemArray.ItemArray[0] = "zero"
 641                         //   table.Rows[2].ItemArray.ItemArray[1] = DBNull.Value
 642                         //      even though internally, the AutoIncrement value
 643                         //      is incremented
 644
 645                         row = table.NewRow();
 646
 647                         try {
 648                                 row.ItemArray = obj;
 649                         }
 650                         catch(Exception e3) {
 651                                 Fail("DR32: Exception Caught: " + e3);
 652                         }
 653
 654                         table.Rows.Add(row);
 655
 656                         // -- null 4----------
 657                         obj[1] = null;
 658                         // results:
 659                         //   table.Rows[1].ItemArray.ItemArray[0] = "zero"
 660                         //   table.Rows[1].ItemArray.ItemArray[1] = 13
 661
 662                         row = table.NewRow();
 663
 664                         try {
 665                                 row.ItemArray = obj;
 666                         }
 667                         catch(Exception e2) {
 668                                 Fail("DR48: Exception Caught: " + e2);
 669                         }
 670
 671                         table.Rows.Add(row);
 672
 673                         // -- object array smaller than number of columns -----
 674                         string abc = "abc";
 675                         string def = "def";
 676                         obj = new object[2];
 677                         obj[0] = abc;
 678                         // results:
 679                         //   table.Rows[3].ItemArray.ItemArray[0] = "abc"
 680                         //   table.Rows[3].ItemArray.ItemArray[1] = 14
 681
 682                         row = table.NewRow();
 683
 684                         try {
 685                                 row.ItemArray = obj;
 686                         }
 687                         catch(Exception e3) {
 688                                 Fail("DR33: Exception Caught: " + e3);
 689                         }
 690
 691                         table.Rows.Add(row);
 692
 693                         // -- normal -----------------
 694                         ValueTest("DR34: normal value test", table, 0, 0, zero);
 695                         ValueTest("DR35: normal value test", table, 0, 1, 8);
 696
 697                         // -- null 1----------
 698                         ValueTest("DR36: null value test", table, 1, 0, zero);
 699                         ValueTest("DR37: null value test", table, 1, 1, 9);
 700
 701                         // -- null 2----------
 702                         ValueTest("DR38: null value test", table, 2, 0, zero);
 703                         ValueTest("DR39: null value test", table, 2, 1, 10);
 704
 705                         // -- null 3----------
 706                         ValueTest("DR40: null value test", table, 3, 0, zero);
 707                         ValueTest("DR41: null value test", table, 3, 1, 11);
 708
 709                         // -- DBNull.Value -------------
 710                         ValueTest("DR42: DBNull.Value value test", table, 4, 0, zero);
 711                         ValueTest("DR43: DBNull.Value value test", table, 4, 1, DBNull.Value);
 712
 713                         // -- null 4----------
 714                         ValueTest("DR44: null value test", table, 5, 0, zero);
 715                         ValueTest("DR45: null value test", table, 5, 1, 13);
 716
 717                         // -- object array smaller than number of columns -----
 718                         ValueTest("DR46: array smaller value test", table, 6, 0, abc);
 719                         ValueTest("DR47: array smaller value test", table, 6, 1, 14);
 720                 }
 721         }
 722 }