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

   1 // Authors:
   2 //   Rafael Mizrahi   <rafim@mainsoft.com>
   3 //   Erez Lotan       <erezl@mainsoft.com>
   4 //   Oren Gurfinkel   <oreng@mainsoft.com>
   5 //   Ofer Borstein
   6 //
   7 // Copyright (c) 2004 Mainsoft Co.
   8 //
   9 // Permission is hereby granted, free of charge, to any person obtaining
  10 // a copy of this software and associated documentation files (the
  11 // "Software"), to deal in the Software without restriction, including
  12 // without limitation the rights to use, copy, modify, merge, publish,
  13 // distribute, sublicense, and/or sell copies of the Software, and to
  14 // permit persons to whom the Software is furnished to do so, subject to
  15 // the following conditions:
  16 //
  17 // The above copyright notice and this permission notice shall be
  18 // included in all copies or substantial portions of the Software.
  19 //
  20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  23 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  24 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  25 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27 //
  28
  29 using System;
  30 using System.Collections;
  31 using System.ComponentModel;
  32 using System.Data;
  33 using System.Globalization;
  34 using System.IO;
  35
  36 using MonoTests.System.Data.Utils;
  37
  38 using NUnit.Framework;
  39
  40 namespace MonoTests.System.Data
  41 {
  42         [TestFixture] public class DataRowTest2
  43         {
  44                 bool _rowChanged;
  45                 ArrayList _eventsFired;
  46
  47                 [SetUp]
  48                 public void SetUp ()
  49                 {
  50                         _rowChanged = false;
  51                         _eventsFired = new ArrayList ();
  52                 }
  53
  54                 [Test] public void AcceptChanges()
  55                 {
  56                         DataTable myTable = new DataTable("myTable");
  57                         DataRow myRow;
  58                         myRow = myTable.NewRow();
  59                         myTable.Rows.Add(myRow);
  60
  61                         // DataRow AcceptChanges
  62                         // DataRowState.Added -> DataRowState.Unchanged
  63                         myTable.AcceptChanges();
  64                         Assert.AreEqual(DataRowState.Unchanged , myRow.RowState , "DRW1");
  65                 }
  66
  67                 [Test] public void CancelEdit()
  68                 {
  69                         DataTable myTable = new DataTable("myTable");
  70                         DataColumn dc = new DataColumn("Id",typeof(int));
  71                         dc.Unique=true;
  72                         myTable.Columns.Add(dc);
  73                         myTable.Rows.Add(new object[] {1});
  74                         myTable.Rows.Add(new object[] {2});
  75                         myTable.Rows.Add(new object[] {3});
  76
  77                         DataRow myRow = myTable.Rows[0];
  78                         myRow.BeginEdit();
  79                         myRow[0] = 7;
  80                         myRow.CancelEdit();
  81
  82                         // DataRow CancelEdit
  83                         Assert.AreEqual(true ,  (int)myRow[0] == 1, "DRW2");
  84                 }
  85
  86                 [Test] public void ClearErrors()
  87                 {
  88                         DataTable dt = new DataTable("myTable");
  89                         DataRow dr = dt.NewRow();
  90                         dr.RowError = "err";
  91
  92                         // DataRow ClearErrors
  93                         Assert.AreEqual(true ,  dr.HasErrors , "DRW3");
  94
  95                         // DataRow ClearErrors
  96                         dr.ClearErrors();
  97                         Assert.AreEqual(false ,  dr.HasErrors , "DRW4");
  98                 }
  99
 100                 [Test] public void Delete()
 101                 {
 102                         DataTable myTable = new DataTable("myTable");
 103                         DataColumn dc = new DataColumn("Id",typeof(int));
 104                         dc.Unique=true;
 105                         myTable.Columns.Add(dc);
 106                         myTable.Rows.Add(new object[] {1});
 107                         myTable.Rows.Add(new object[] {2});
 108                         myTable.Rows.Add(new object[] {3});
 109                         myTable.AcceptChanges();
 110
 111                         DataRow myRow = myTable.Rows[0];
 112                         myRow.Delete();
 113
 114                         // Delete1
 115                         Assert.AreEqual(DataRowState.Deleted  ,  myRow.RowState , "DRW5");
 116
 117                         // Delete2
 118                         myTable.AcceptChanges();
 119                         Assert.AreEqual(DataRowState.Detached  ,  myRow.RowState , "DRW6");
 120                 }
 121
 122                 [Test] public void EndEdit()
 123                 {
 124                         DataTable myTable = new DataTable("myTable");
 125                         DataColumn dc = new DataColumn("Id",typeof(int));
 126                         dc.Unique=true;
 127                         myTable.Columns.Add(dc);
 128                         myTable.Rows.Add(new object[] {1});
 129                         myTable.Rows.Add(new object[] {2});
 130                         myTable.Rows.Add(new object[] {3});
 131
 132                         DataRow myRow = myTable.Rows[0];
 133
 134                         int iProposed;
 135                         //After calling the DataRow object's BeginEdit method, if you change the value, the Current and Proposed values become available
 136                         myRow.BeginEdit();
 137                         myRow[0] = 7;
 138                         iProposed = (int)myRow[0,DataRowVersion.Proposed];
 139                         myRow.EndEdit();
 140
 141                         // EndEdit
 142                         Assert.AreEqual(iProposed ,  (int)myRow[0,DataRowVersion.Current] , "DRW7");
 143                 }
 144
 145                 [Test] public void Equals()
 146                 {
 147                         DataTable myTable = new DataTable("myTable");
 148                         DataRow dr1,dr2;
 149                         dr1 = myTable.NewRow();
 150                         dr2 = myTable.NewRow();
 151
 152                         // not equals
 153                         Assert.AreEqual(false  , dr1.Equals(dr2), "DRW8");
 154
 155                 dr1=dr2;
 156                         // equals
 157                         Assert.AreEqual(true , dr1.Equals(dr2), "DRW9");
 158                 }
 159
 160                 [Test] public void GetChildRows_ByDataRealtion()
 161                 {
 162                         DataRow dr;
 163                         DataRow[] drArrExcepted,drArrResult;
 164                         DataTable dtChild,dtParent;
 165                         DataSet ds = new DataSet();
 166
 167                         //Create tables
 168                         dtChild = DataProvider.CreateChildDataTable();
 169                         dtParent= DataProvider.CreateParentDataTable();
 170
 171                         //Add tables to dataset
 172                         ds.Tables.Add(dtChild);
 173                         ds.Tables.Add(dtParent);
 174                         dr = dtParent.Rows[0];
 175
 176                         //Add Relation
 177                         DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"]);
 178                         ds.Relations.Add(dRel);
 179                         //Get Excepted result
 180                         drArrExcepted = dtChild.Select("ParentId=" + dr["ParentId"]);
 181                         //Get Result
 182                         drArrResult = dr.GetChildRows(dRel);
 183
 184                         // GetChildRows_D
 185                         Assert.AreEqual(drArrExcepted,  drArrResult, "DRW10");
 186                 }
 187
 188                 [Test] public void GetChildRows_ByDataRealtionDataRowVersion()
 189                 {
 190                         DataRow drParent;
 191                         DataRow[] drArrExcepted,drArrResult;
 192                         DataTable dtChild,dtParent;
 193                         DataSet ds = new DataSet();
 194                         //Create tables
 195                         dtChild = DataProvider.CreateChildDataTable();
 196                         dtParent= DataProvider.CreateParentDataTable();
 197                         //Add tables to dataset
 198                         ds.Tables.Add(dtChild);
 199                         ds.Tables.Add(dtParent);
 200                         //Add Relation
 201                         DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"]);
 202                         ds.Relations.Add(dRel);
 203
 204                         drParent = dtParent.Rows[0];
 205
 206                         // Teting: DateTime.Now.ToShortTimeString()
 207                         //Get Excepted result
 208                         drArrExcepted = dtChild.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.CurrentRows );
 209                         //Get Result DataRowVersion.Current
 210                         drArrResult = drParent.GetChildRows(dRel,DataRowVersion.Current);
 211                         Assert.AreEqual(drArrExcepted,  drArrResult, "DRW11");
 212
 213                         // Teting: DataRow.GetParentRows_D_D
 214                         //Get Excepted result
 215                         drArrExcepted = dtChild.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.OriginalRows );
 216                         //Get Result DataRowVersion.Current
 217                         drArrResult = drParent.GetChildRows(dRel,DataRowVersion.Original );
 218                         Assert.AreEqual(drArrExcepted,  drArrResult, "DRW12");
 219
 220                         // Teting: DataRow.GetParentRows_D_D
 221                         //Get Excepted result, in this case Current = Default
 222                         drArrExcepted = dtChild.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.CurrentRows);
 223                         //Get Result DataRowVersion.Current
 224                         drArrResult = drParent.GetChildRows(dRel,DataRowVersion.Default  );
 225                         Assert.AreEqual(drArrExcepted,  drArrResult, "DRW13");
 226
 227                         // Teting: DataRow.GetParentRows_D_D
 228                         drParent.BeginEdit();
 229                         drParent["String1"] = "Value";
 230                         //Get Excepted result
 231                         drArrExcepted = dtChild.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.CurrentRows );
 232                         //Get Result DataRowVersion.Current
 233                         drArrResult = drParent.GetChildRows(dRel,DataRowVersion.Proposed  );
 234                         Assert.AreEqual(drArrExcepted,  drArrResult, "DRW14");
 235                 }
 236
 237                 [Test] public void GetChildRows_ByName()
 238                 {
 239                         DataRow dr;
 240                         DataRow[] drArrExcepted,drArrResult;
 241                         DataTable dtChild,dtParent;
 242                         DataSet ds = new DataSet();
 243
 244                         //Create tables
 245                         dtChild = DataProvider.CreateChildDataTable();
 246                         dtParent= DataProvider.CreateParentDataTable();
 247
 248                         //Add tables to dataset
 249                         ds.Tables.Add(dtChild);
 250                         ds.Tables.Add(dtParent);
 251                         dr = dtParent.Rows[0];
 252
 253                         //Add Relation
 254                         DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"]);
 255                         ds.Relations.Add(dRel);
 256                         //Get Excepted result
 257                         drArrExcepted = dtChild.Select("ParentId=" + dr["ParentId"]);
 258                         //Get Result
 259                         drArrResult = dr.GetChildRows("Parent-Child");
 260
 261                         // GetChildRows_S
 262                         Assert.AreEqual(drArrExcepted,  drArrResult, "DRW15");
 263                 }
 264
 265                 [Test] public void GetChildRows_ByNameDataRowVersion()
 266                 {
 267                         DataRow drParent;
 268                         DataRow[] drArrExcepted,drArrResult;
 269                         DataTable dtChild,dtParent;
 270                         DataSet ds = new DataSet();
 271                         //Create tables
 272                         dtChild = DataProvider.CreateChildDataTable();
 273                         dtParent= DataProvider.CreateParentDataTable();
 274                         //Add tables to dataset
 275                         ds.Tables.Add(dtChild);
 276                         ds.Tables.Add(dtParent);
 277                         //Add Relation
 278                         DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"]);
 279                         ds.Relations.Add(dRel);
 280
 281                         drParent = dtParent.Rows[0];
 282
 283                         // GetChildRows_SD 1
 284                         //Get Excepted result
 285                         drArrExcepted = dtChild.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.CurrentRows );
 286                         //Get Result DataRowVersion.Current
 287                         drArrResult = drParent.GetChildRows("Parent-Child",DataRowVersion.Current);
 288                         Assert.AreEqual(drArrExcepted,  drArrResult, "DRW16");
 289
 290                         // GetChildRows_SD 2
 291                         //Get Excepted result
 292                         drArrExcepted = dtChild.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.OriginalRows );
 293                         //Get Result DataRowVersion.Current
 294                         drArrResult = drParent.GetChildRows("Parent-Child",DataRowVersion.Original );
 295                         Assert.AreEqual(drArrExcepted,  drArrResult, "DRW17");
 296
 297                         // GetParentRows_SD 3
 298                         //Get Excepted result, in this case Current = Default
 299                         drArrExcepted = dtChild.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.CurrentRows);
 300                         //Get Result DataRowVersion.Current
 301                         drArrResult = drParent.GetChildRows("Parent-Child",DataRowVersion.Default  );
 302                         Assert.AreEqual(drArrExcepted,  drArrResult, "DRW18");
 303
 304                         // GetParentRows_SD 4
 305                         drParent.BeginEdit();
 306                         drParent["String1"] = "Value";
 307                         //Get Excepted result
 308                         drArrExcepted = dtChild.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.CurrentRows );
 309                         //Get Result DataRowVersion.Current
 310                         drArrResult = drParent.GetChildRows("Parent-Child",DataRowVersion.Proposed  );
 311                         Assert.AreEqual(drArrExcepted,  drArrResult, "DRW19");
 312                 }
 313
 314                 [Test] public void GetColumnError_ByIndex()
 315                 {
 316                         string sColErr = "Error!";
 317                         DataTable dt = new DataTable("myTable");
 318                         DataColumn dc = new DataColumn("Column1");
 319                         dt.Columns.Add(dc);
 320                         DataRow dr = dt.NewRow();
 321
 322                         // GetColumnError 1
 323                         Assert.AreEqual(String.Empty ,  dr.GetColumnError(0) , "DRW20");
 324
 325                         dr.SetColumnError(0,sColErr );
 326
 327                         // GetColumnError 2
 328                         Assert.AreEqual(sColErr ,  dr.GetColumnError(0) , "DRW21");
 329                 }
 330
 331                 [Test] public void GetColumnError_ByName()
 332                 {
 333                         string sColErr = "Error!";
 334                         DataTable dt = new DataTable("myTable");
 335                         DataColumn dc = new DataColumn("Column1");
 336                         dt.Columns.Add(dc);
 337                         DataRow dr = dt.NewRow();
 338
 339                         // GetColumnError 1
 340                         Assert.AreEqual(String.Empty ,  dr.GetColumnError("Column1") , "DRW22");
 341
 342                         dr.SetColumnError("Column1",sColErr );
 343
 344                         // GetColumnError 2
 345                         Assert.AreEqual(sColErr ,  dr.GetColumnError("Column1") , "DRW23");
 346                 }
 347
 348                 [Test] public void GetColumnsInError()
 349                 {
 350                         string sColErr = "Error!";
 351                         DataColumn[] dcArr;
 352                         DataTable dt = new DataTable("myTable");
 353                         //init some columns
 354                         dt.Columns.Add(new DataColumn());
 355                         dt.Columns.Add(new DataColumn());
 356                         dt.Columns.Add(new DataColumn());
 357                         dt.Columns.Add(new DataColumn());
 358                         dt.Columns.Add(new DataColumn());
 359
 360                         //init some rows
 361                         dt.Rows.Add(new object[] {});
 362                         dt.Rows.Add(new object[] {});
 363                         dt.Rows.Add(new object[] {});
 364
 365                         DataRow dr = dt.Rows[1];
 366
 367                         dcArr = dr.GetColumnsInError();
 368
 369                         // GetColumnsInError 1
 370                         Assert.AreEqual(0,  dcArr.Length , "DRW24");
 371
 372                         dr.SetColumnError(0,sColErr);
 373                         dr.SetColumnError(2,sColErr);
 374                         dr.SetColumnError(4,sColErr);
 375
 376                         dcArr = dr.GetColumnsInError();
 377
 378                         // GetColumnsInError 2
 379                         Assert.AreEqual(3, dcArr.Length , "DRW25");
 380
 381                         //check that the right columns taken
 382                         // GetColumnsInError 3
 383                         Assert.AreEqual(dt.Columns[0], dcArr[0], "DRW26");
 384
 385                         // GetColumnsInError 4
 386                         Assert.AreEqual(dt.Columns[2], dcArr[1], "DRW27");
 387
 388                         // GetColumnsInError 5
 389                         Assert.AreEqual(dt.Columns[4], dcArr[2], "DRW28");
 390                 }
 391
 392                 [Test] public new void GetHashCode()
 393                 {
 394                         int iHashCode;
 395                         DataRow dr;
 396                         DataTable dt = new DataTable();
 397                         dr = dt.NewRow();
 398
 399                         iHashCode = dr.GetHashCode();
 400                         for (int i=0; i<10; i++)
 401                         {       //must return the same value each time
 402                                 // GetHashCode #" + i
 403                                 Assert.AreEqual(dr.GetHashCode() ,  iHashCode , "DRW29");
 404                         }
 405                 }
 406
 407                 [Test] public void GetParentRow_ByDataRelation()
 408                 {
 409                         DataRow drExcepted,drResult,drChild;
 410                         DataTable dtChild,dtParent;
 411                         DataSet ds = new DataSet();
 412
 413                         //Create tables
 414                         dtChild = DataProvider.CreateChildDataTable();
 415                         dtParent = DataProvider.CreateParentDataTable();
 416
 417                         //Add tables to dataset
 418                         ds.Tables.Add(dtChild);
 419                         ds.Tables.Add(dtParent);
 420
 421                         //Add Relation
 422                         DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"]);
 423                         ds.Relations.Add(dRel);
 424
 425                         //Excepted result
 426                         drExcepted = dtParent.Rows[0];
 427
 428                         //Get Result
 429                         drChild = dtChild.Select("ParentId=" + drExcepted["ParentId"])[0];
 430                         drResult = drChild.GetParentRow(dRel);
 431
 432                         // GetParentRow_D
 433                         Assert.AreEqual(drExcepted.ItemArray,  drResult.ItemArray , "DRW30");
 434                 }
 435
 436                 [Test] public void GetParentRow_ByDataRelationDataRowVersion()
 437                 {
 438                         DataRow drParent,drChild;
 439                         DataRow drArrExcepted,drArrResult;
 440                         DataTable dtChild,dtParent;
 441                         DataSet ds = new DataSet();
 442                         //Create tables
 443                         dtChild = DataProvider.CreateChildDataTable();
 444                         dtParent= DataProvider.CreateParentDataTable();
 445                         //Add tables to dataset
 446                         ds.Tables.Add(dtChild);
 447                         ds.Tables.Add(dtParent);
 448                         //Add Relation
 449                         DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"]);
 450                         ds.Relations.Add(dRel);
 451
 452                         drParent = dtParent.Rows[0];
 453                         drChild = dtChild.Select("ParentId=" + drParent["ParentId"])[0];
 454
 455                         // GetParentRow_DD 1
 456                         //Get Excepted result
 457                         drArrExcepted = drParent;
 458                         //Get Result DataRowVersion.Current
 459                         drArrResult = drChild.GetParentRow(dRel,DataRowVersion.Current);
 460                         Assert.AreEqual(drArrExcepted.ItemArray,  drArrResult.ItemArray , "DRW31");
 461
 462                         // GetParentRow_DD 2
 463                         //Get Excepted result
 464                         drArrExcepted = drParent;
 465                         //Get Result DataRowVersion.Current
 466                         drArrResult = drChild.GetParentRow(dRel,DataRowVersion.Original );
 467                         Assert.AreEqual(drArrExcepted.ItemArray,  drArrResult.ItemArray , "DRW32");
 468
 469                         // GetParentRow_DD 3
 470                         //Get Excepted result, in this case Current = Default
 471                         drArrExcepted = drParent;
 472                         //Get Result DataRowVersion.Current
 473                         drArrResult = drChild.GetParentRow(dRel,DataRowVersion.Default  );
 474                         Assert.AreEqual(drArrExcepted.ItemArray,  drArrResult.ItemArray , "DRW33");
 475
 476                         // GetParentRow_DD 4
 477                         drChild.BeginEdit();
 478                         drChild["String1"] = "Value";
 479                         //Get Excepted result
 480                         drArrExcepted = drParent;
 481                         //Get Result DataRowVersion.Current
 482                         drArrResult = drChild.GetParentRow(dRel,DataRowVersion.Proposed  );
 483                         Assert.AreEqual(drArrExcepted.ItemArray,  drArrResult.ItemArray , "DRW34");
 484                 }
 485
 486                 [Test] public void GetParentRow_ByName()
 487                 {
 488                         DataRow drExcepted,drResult,drChild;
 489                         DataTable dtChild,dtParent;
 490                         DataSet ds = new DataSet();
 491
 492                         //Create tables
 493                         dtChild = DataProvider.CreateChildDataTable();
 494                         dtParent = DataProvider.CreateParentDataTable();
 495
 496                         //Add tables to dataset
 497                         ds.Tables.Add(dtChild);
 498                         ds.Tables.Add(dtParent);
 499
 500                         //Add Relation
 501                         DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"]);
 502                         ds.Relations.Add(dRel);
 503
 504                         //Excepted result
 505                         drExcepted = dtParent.Rows[0];
 506
 507                         //Get Result
 508                         drChild = dtChild.Select("ParentId=" + drExcepted["ParentId"])[0];
 509                         drResult = drChild.GetParentRow("Parent-Child");
 510
 511                         // GetParentRow_S
 512                         Assert.AreEqual(drExcepted.ItemArray,  drResult.ItemArray , "DRW35");
 513                 }
 514
 515                 [Test] public void GetParentRow_ByNameDataRowVersion()
 516                 {
 517                         DataRow drParent,drChild;
 518                         DataRow drArrExcepted,drArrResult;
 519                         DataTable dtChild,dtParent;
 520                         DataSet ds = new DataSet();
 521                         //Create tables
 522                         dtChild = DataProvider.CreateChildDataTable();
 523                         dtParent= DataProvider.CreateParentDataTable();
 524                         //Add tables to dataset
 525                         ds.Tables.Add(dtChild);
 526                         ds.Tables.Add(dtParent);
 527                         //Add Relation
 528                         DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"]);
 529                         ds.Relations.Add(dRel);
 530
 531                         drParent = dtParent.Rows[0];
 532                         drChild = dtChild.Select("ParentId=" + drParent["ParentId"])[0];
 533
 534                         // GetParentRow_SD 1
 535                         //Get Excepted result
 536                         drArrExcepted = drParent;
 537                         //Get Result DataRowVersion.Current
 538                         drArrResult = drChild.GetParentRow("Parent-Child",DataRowVersion.Current);
 539                         Assert.AreEqual(drArrExcepted.ItemArray,  drArrResult.ItemArray , "DRW36");
 540
 541                         // GetParentRow_SD 2
 542                         //Get Excepted result
 543                         drArrExcepted = drParent;
 544                         //Get Result DataRowVersion.Current
 545                         drArrResult = drChild.GetParentRow("Parent-Child",DataRowVersion.Original );
 546                         Assert.AreEqual(drArrExcepted.ItemArray,  drArrResult.ItemArray , "DRW37");
 547
 548                         // GetParentRow_SD 3
 549                         //Get Excepted result, in this case Current = Default
 550                         drArrExcepted = drParent;
 551                         //Get Result DataRowVersion.Current
 552                         drArrResult = drChild.GetParentRow("Parent-Child",DataRowVersion.Default  );
 553                         Assert.AreEqual(drArrExcepted.ItemArray,  drArrResult.ItemArray , "DRW38");
 554
 555                         // GetParentRow_SD 4
 556                         drChild.BeginEdit();
 557                         drChild["String1"] = "Value";
 558                         //Get Excepted result
 559                         drArrExcepted = drParent;
 560                         //Get Result DataRowVersion.Current
 561                         drArrResult = drChild.GetParentRow("Parent-Child",DataRowVersion.Proposed  );
 562                         Assert.AreEqual(drArrExcepted.ItemArray,  drArrResult.ItemArray , "DRW39");
 563                 }
 564
 565                 [Test] public void GetParentRows_ByDataRelation()
 566                 {
 567                         DataRow dr;
 568                         DataRow[] drArrExcepted,drArrResult;
 569                         DataTable dtChild,dtParent;
 570                         DataSet ds = new DataSet();
 571
 572                         //Create tables
 573                         dtChild = DataProvider.CreateChildDataTable();
 574                         dtParent = DataProvider.CreateParentDataTable();
 575
 576                         //Add tables to dataset
 577                         ds.Tables.Add(dtChild);
 578                         ds.Tables.Add(dtParent);
 579                         dr = dtParent.Rows[0];
 580
 581                         //Duplicate several rows in order to create Many to Many relation
 582                         dtParent.ImportRow(dr);
 583                         dtParent.ImportRow(dr);
 584                         dtParent.ImportRow(dr);
 585
 586                         //Add Relation
 587                         DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"],false);
 588                         ds.Relations.Add(dRel);
 589                         //Get Excepted result
 590                         drArrExcepted = dtParent.Select("ParentId=" + dr["ParentId"]);
 591                         dr = dtChild.Select("ParentId=" + dr["ParentId"])[0];
 592                         //Get Result
 593                         drArrResult = dr.GetParentRows(dRel);
 594
 595                         // GetParentRows_D
 596                         Assert.AreEqual(drArrExcepted,  drArrResult, "DRW40");
 597                 }
 598
 599                 [Test] public void GetParentRows_ByName()
 600                 {
 601                         DataRow dr;
 602                         DataRow[] drArrExcepted,drArrResult;
 603                         DataTable dtChild,dtParent;
 604                         DataSet ds = new DataSet();
 605
 606                         //Create tables
 607                         dtChild = DataProvider.CreateChildDataTable();
 608                         dtParent = DataProvider.CreateParentDataTable();
 609
 610                         //Add tables to dataset
 611                         ds.Tables.Add(dtChild);
 612                         ds.Tables.Add(dtParent);
 613                         dr = dtParent.Rows[0];
 614
 615                         //Duplicate several rows in order to create Many to Many relation
 616                         dtParent.ImportRow(dr);
 617                         dtParent.ImportRow(dr);
 618                         dtParent.ImportRow(dr);
 619
 620                         //Add Relation
 621                         DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"],false);
 622                         ds.Relations.Add(dRel);
 623                         //Get Excepted result
 624                         drArrExcepted = dtParent.Select("ParentId=" + dr["ParentId"]);
 625                         dr = dtChild.Select("ParentId=" + dr["ParentId"])[0];
 626                         //Get Result
 627                         drArrResult = dr.GetParentRows("Parent-Child");
 628
 629                         // GetParentRows_S
 630                         Assert.AreEqual(drArrExcepted,  drArrResult, "DRW41");
 631                 }
 632
 633                 [Test] public void GetParentRows_ByNameDataRowVersion()
 634                 {
 635                         DataRow drParent,drChild;
 636                         DataRow[] drArrExcepted,drArrResult;
 637                         DataTable dtChild,dtParent;
 638                         DataSet ds = new DataSet();
 639                         //Create tables
 640                         dtChild = DataProvider.CreateChildDataTable();
 641                         dtParent= DataProvider.CreateParentDataTable();
 642                         //Add tables to dataset
 643                         ds.Tables.Add(dtChild);
 644                         ds.Tables.Add(dtParent);
 645                         //Add Relation
 646                         DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"],false);
 647                         ds.Relations.Add(dRel);
 648
 649                         //Create several copies of the first row
 650                         drParent = dtParent.Rows[0];    //row[0] has versions: Default,Current,Original
 651                         dtParent.ImportRow(drParent);   //row[1] has versions: Default,Current,Original
 652                         dtParent.ImportRow(drParent);   //row[2] has versions: Default,Current,Original
 653                         dtParent.ImportRow(drParent);   //row[3] has versions: Default,Current,Original
 654                         dtParent.ImportRow(drParent);   //row[4] has versions: Default,Current,Original
 655                         dtParent.ImportRow(drParent);   //row[5] has versions: Default,Current,Original
 656                         dtParent.AcceptChanges();
 657
 658                         //Get the first child row for drParent
 659                         drChild = dtChild.Select("ParentId=" + drParent["ParentId"])[0];
 660
 661                         DataRow[] drTemp = dtParent.Select("ParentId=" + drParent["ParentId"]);
 662                         //                              Console.WriteLine("********");
 663                         //                              foreach (DataRow d in drTemp)
 664                         //                              {
 665                         //                                      CheckRowVersion(d);
 666                         //                              }
 667                         drTemp[0].BeginEdit();
 668                         drTemp[0]["String1"] = "NewValue"; //row now has versions: Proposed,Current,Original,Default
 669                         drTemp[1].BeginEdit();
 670                         drTemp[1]["String1"] = "NewValue"; //row now has versions: Proposed,Current,Original,Default
 671
 672                         //              Console.WriteLine("********");
 673                         //              foreach (DataRow d in drTemp)
 674                         //              {
 675                         //                      CheckRowVersion(d);
 676                         //              }
 677                         //              Console.WriteLine("********");
 678
 679                         // Check DataRowVersion.Current
 680                         //Check DataRowVersion.Current
 681                         drArrExcepted = dtParent.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.CurrentRows );
 682                         drArrResult = drChild.GetParentRows("Parent-Child",DataRowVersion.Current);
 683                         Assert.AreEqual(drArrExcepted,  drArrResult, "DRW42");
 684
 685                         //Check DataRowVersion.Current
 686                         // Teting: DataRow.GetParentRows_D_D ,DataRowVersion.Original
 687                         drArrExcepted = dtParent.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.OriginalRows );
 688                         drArrResult = drChild.GetParentRows("Parent-Child",DataRowVersion.Original );
 689                         Assert.AreEqual(drArrExcepted,  drArrResult, "DRW43");
 690
 691                         //Check DataRowVersion.Default
 692                         // Teting: DataRow.GetParentRows_D_D ,DataRowVersion.Default
 693                         drArrExcepted = dtParent.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.CurrentRows);
 694                         drArrResult = drChild.GetParentRows("Parent-Child",DataRowVersion.Default  );
 695                         Assert.AreEqual(drArrExcepted,  drArrResult, "DRW44");
 696
 697                 /* .Net don't work as expected
 698                         //Check DataRowVersion.Proposed
 699                         // Teting: DataRow.GetParentRows_D_D ,DataRowVersion.Proposed
 700                         drArrExcepted = dtParent.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.ModifiedCurrent);
 701                         //drArrExcepted = dtParent.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.ModifiedOriginal );
 702
 703                         drArrResult = drChild.GetParentRows("Parent-Child",DataRowVersion.Proposed  );
 704                         Assert.AreEqual(drArrExcepted,  drArrResult, "DRW45");
 705                 */
 706                 }
 707
 708                 private void CheckRowVersion(DataRow dr)
 709                 {
 710                         Console.WriteLine("");
 711                         if (dr.HasVersion(DataRowVersion.Current)) Console.WriteLine("Has " + DataRowVersion.Current.ToString());
 712                         if (dr.HasVersion(DataRowVersion.Default)) Console.WriteLine("Has " + DataRowVersion.Default.ToString());
 713                         if (dr.HasVersion(DataRowVersion.Original)) Console.WriteLine("Has " + DataRowVersion.Original.ToString());
 714                         if (dr.HasVersion(DataRowVersion.Proposed)) Console.WriteLine("Has " + DataRowVersion.Proposed.ToString());
 715                 }
 716
 717                 [Test] public new void GetType()
 718                 {
 719                         Type myType;
 720                         DataTable dt = new DataTable();
 721                         DataRow dr = dt.NewRow();
 722                         myType = typeof(DataRow);
 723
 724                         // GetType
 725                         Assert.AreEqual(typeof(DataRow), myType , "DRW46");
 726                 }
 727
 728                 [Test] public void HasErrors()
 729                 {
 730                         DataTable dt = new DataTable("myTable");
 731                         DataRow dr = dt.NewRow();
 732
 733                         // HasErrors (default)
 734                         Assert.AreEqual(false, dr.HasErrors, "DRW47");
 735
 736                         dr.RowError = "Err";
 737
 738                         // HasErrors (set/get)
 739                         Assert.AreEqual(true , dr.HasErrors , "DRW48");
 740                 }
 741
 742                 [Test] public void HasVersion_ByDataRowVersion()
 743                 {
 744                         DataTable t = new DataTable("atable");
 745                         t.Columns.Add("id", typeof(int));
 746                         t.Columns.Add("name", typeof(string));
 747                         t.Columns[0].DefaultValue = 1;
 748                         t.Columns[1].DefaultValue = "something";
 749
 750                         // row r is detached
 751                         DataRow r = t.NewRow();
 752
 753                         // HasVersion Test #10
 754                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Current) , "DRW49");
 755
 756                         // HasVersion Test #11
 757                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Original) , "DRW50");
 758
 759                         // HasVersion Test #12
 760                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Default) , "DRW51");
 761
 762                         // HasVersion Test #13
 763                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Proposed) , "DRW52");
 764
 765                         r[0] = 4;
 766                         r[1] = "four";
 767
 768                         // HasVersion Test #20
 769                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Current) , "DRW53");
 770
 771                         // HasVersion Test #21
 772                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Original) , "DRW54");
 773
 774                         // HasVersion Test #22
 775                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Default) , "DRW55");
 776
 777                         // HasVersion Test #23
 778                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Proposed) , "DRW56");
 779
 780                         t.Rows.Add(r);
 781                         // now it is "added"
 782
 783                         // HasVersion Test #30
 784                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Current) , "DRW57");
 785
 786                         // HasVersion Test #31
 787                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Original) , "DRW58");
 788
 789                         // HasVersion Test #32
 790                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Default) , "DRW59");
 791
 792                         // HasVersion Test #33
 793                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Proposed) , "DRW60");
 794
 795                         t.AcceptChanges();
 796                         // now it is "unchanged"
 797
 798                         // HasVersion Test #40
 799                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Current) , "DRW61");
 800
 801                         // HasVersion Test #41
 802                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Original) , "DRW62");
 803
 804                         // HasVersion Test #42
 805                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Default) , "DRW63");
 806
 807                         // HasVersion Test #43
 808                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Proposed) , "DRW64");
 809
 810                         r.BeginEdit();
 811                         r[1] = "newvalue";
 812
 813                         // HasVersion Test #50
 814                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Current) , "DRW65");
 815
 816                         // HasVersion Test #51
 817                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Original) , "DRW66");
 818
 819                         // HasVersion Test #52
 820                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Default) , "DRW67");
 821
 822                         // HasVersion Test #53
 823                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Proposed) , "DRW68");
 824
 825                         r.EndEdit();
 826                         // now it is "modified"
 827                         // HasVersion Test #60
 828                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Current) , "DRW69");
 829
 830                         // HasVersion Test #61
 831                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Original) , "DRW70");
 832
 833                         // HasVersion Test #62
 834                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Default) , "DRW71");
 835
 836                         // HasVersion Test #63
 837                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Proposed) , "DRW72");
 838
 839                         // this or t.AcceptChanges
 840                         r.AcceptChanges();
 841                         // now it is "unchanged" again
 842                         // HasVersion Test #70
 843                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Current) , "DRW73");
 844
 845                         // HasVersion Test #71
 846                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Original) , "DRW74");
 847
 848                         // HasVersion Test #72
 849                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Default) , "DRW75");
 850
 851                         // HasVersion Test #73
 852                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Proposed) , "DRW76");
 853
 854                         r.Delete();
 855                         // now it is "deleted"
 856
 857                         // HasVersion Test #80
 858                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Current) , "DRW77");
 859
 860                         // HasVersion Test #81
 861                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Original) , "DRW78");
 862
 863                         // HasVersion Test #82
 864                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Default) , "DRW79");
 865
 866                         // HasVersion Test #83
 867                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Proposed) , "DRW80");
 868
 869                         r.AcceptChanges();
 870                         // back to detached
 871                         // HasVersion Test #90
 872                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Current) , "DRW81");
 873
 874                         // HasVersion Test #91
 875                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Original) , "DRW82");
 876
 877                         // HasVersion Test #92
 878                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Default) , "DRW83");
 879
 880                         // HasVersion Test #93
 881                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Proposed) , "DRW84");
 882                 }
 883
 884                 [Test] // Object this [DataColumn]
 885                 public void Indexer1 ()
 886                 {
 887                         EventInfo evt;
 888                         DataColumnChangeEventArgs colChangeArgs;
 889
 890                         DataTable dt = new DataTable ();
 891                         dt.ColumnChanged += new DataColumnChangeEventHandler (ColumnChanged);
 892                         dt.ColumnChanging += new DataColumnChangeEventHandler (ColumnChanging);
 893
 894                         DataColumn dc0 = new DataColumn ("Col0", typeof (Address));
 895                         dt.Columns.Add (dc0);
 896                         DataColumn dc1 = new DataColumn ("Col1", typeof (Person));
 897                         dt.Columns.Add (dc1);
 898
 899                         Person personA = new Person ("Miguel");
 900                         Address addressA = new Address ("X", 5);
 901                         Person personB = new Person ("Chris");
 902                         Address addressB = new Address ("Y", 4);
 903                         Person personC = new Person ("Jackson");
 904                         Address addressC = new Address ("Z", 3);
 905
 906                         dt.Rows.Add (new object [] { addressA, personA });
 907                         dt.Rows.Add (new object [] { addressB, personB });
 908                         DataRow dr;
 909
 910                         dr = dt.Rows [0];
 911                         Assert.AreEqual (addressA, dr [dc0], "#A1");
 912                         Assert.AreSame (personA, dr [dc1], "#A2");
 913
 914                         dr = dt.Rows [1];
 915                         Assert.AreEqual (addressB, dr [dc0], "#B1");
 916                         Assert.AreSame (personB, dr [dc1], "#B2");
 917
 918                         dr = dt.Rows [0];
 919                         Assert.AreEqual (0, _eventsFired.Count, "#C1");
 920                         dr [dc0] = addressC;
 921                         Assert.AreEqual (2, _eventsFired.Count, "#C2");
 922                         Assert.AreEqual (addressC, dr [dc0], "#C3");
 923                         Assert.AreSame (personA, dr [dc1], "#C4");
 924
 925                         dr = dt.Rows [1];
 926                         dr.BeginEdit ();
 927                         Assert.AreEqual (2, _eventsFired.Count, "#D1");
 928                         dr [dc1] = personC;
 929                         Assert.AreEqual (4, _eventsFired.Count, "#D2");
 930                         Assert.AreEqual (addressB, dr [dc0], "#D3");
 931                         Assert.AreSame (personC, dr [dc1], "#D4");
 932                         dr.EndEdit ();
 933                         Assert.AreEqual (4, _eventsFired.Count, "#D5");
 934                         Assert.AreEqual (addressB, dr [dc0], "#D6");
 935                         Assert.AreSame (personC, dr [dc1], "#D7");
 936
 937                         dr = dt.Rows [0];
 938                         dr.BeginEdit ();
 939                         Assert.AreEqual (4, _eventsFired.Count, "#E1");
 940                         dr [dc0] = addressB;
 941                         Assert.AreEqual (6, _eventsFired.Count, "#E2");
 942                         Assert.AreEqual (addressB, dr [dc0], "#E3");
 943                         Assert.AreSame (personA, dr [dc1], "#E4");
 944                         dr.CancelEdit ();
 945                         Assert.AreEqual (6, _eventsFired.Count, "#E5");
 946                         Assert.AreEqual (addressC, dr [dc0], "#E6");
 947                         Assert.AreSame (personA, dr [dc1], "#E7");
 948
 949                         evt = (EventInfo) _eventsFired [0];
 950                         Assert.AreEqual ("ColumnChanging", evt.Name, "#F1");
 951                         colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
 952                         Assert.AreSame (dc0, colChangeArgs.Column, "#F2");
 953                         Assert.AreEqual (addressC, colChangeArgs.ProposedValue, "#F3");
 954                         Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#F4");
 955
 956                         evt = (EventInfo) _eventsFired [1];
 957                         Assert.AreEqual ("ColumnChanged", evt.Name, "#G1");
 958                         colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
 959                         Assert.AreSame (dc0, colChangeArgs.Column, "#G2");
 960                         Assert.AreEqual (addressC, colChangeArgs.ProposedValue, "#G3");
 961                         Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#G4");
 962
 963                         evt = (EventInfo) _eventsFired [2];
 964                         Assert.AreEqual ("ColumnChanging", evt.Name, "#H1");
 965                         colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
 966                         Assert.AreSame (dc1, colChangeArgs.Column, "#H2");
 967                         Assert.AreEqual (personC, colChangeArgs.ProposedValue, "#H3");
 968                         Assert.AreSame (dt.Rows [1], colChangeArgs.Row, "#H4");
 969
 970                         evt = (EventInfo) _eventsFired [3];
 971                         Assert.AreEqual ("ColumnChanged", evt.Name, "#I1");
 972                         colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
 973                         Assert.AreSame (dc1, colChangeArgs.Column, "#I2");
 974                         Assert.AreEqual (personC, colChangeArgs.ProposedValue, "#I3");
 975                         Assert.AreSame (dt.Rows [1], colChangeArgs.Row, "#I4");
 976
 977                         evt = (EventInfo) _eventsFired [4];
 978                         Assert.AreEqual ("ColumnChanging", evt.Name, "#J1");
 979                         colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
 980                         Assert.AreSame (dc0, colChangeArgs.Column, "#J2");
 981                         Assert.AreEqual (addressB, colChangeArgs.ProposedValue, "#J3");
 982                         Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#J4");
 983
 984                         evt = (EventInfo) _eventsFired [5];
 985                         Assert.AreEqual ("ColumnChanged", evt.Name, "#K1");
 986                         colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
 987                         Assert.AreSame (dc0, colChangeArgs.Column, "#K2");
 988                         Assert.AreEqual (addressB, colChangeArgs.ProposedValue, "#K3");
 989                         Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#K4");
 990                 }
 991
 992                 [Test] // Object this [DataColumn]
 993                 public void Indexer1_Column_NotInTable ()
 994                 {
 995                         EventInfo evt;
 996                         DataColumnChangeEventArgs colChangeArgs;
 997
 998                         DataTable dtA = new DataTable ("TableA");
 999                         dtA.ColumnChanged += new DataColumnChangeEventHandler (ColumnChanged);
1000                         dtA.ColumnChanging += new DataColumnChangeEventHandler (ColumnChanging);
1001                         DataColumn dcA1 = new DataColumn ("Col0", typeof (Address));
1002                         dtA.Columns.Add (dcA1);
1003                         DataColumn dcA2 = new DataColumn ("Col1", typeof (Person));
1004                         dtA.Columns.Add (dcA2);
1005
1006                         DataTable dtB = new DataTable ("TableB");
1007                         dtB.ColumnChanged += new DataColumnChangeEventHandler (ColumnChanged);
1008                         dtB.ColumnChanging += new DataColumnChangeEventHandler (ColumnChanging);
1009                         DataColumn dcB1 = new DataColumn ("Col0", typeof (Address));
1010                         dtB.Columns.Add (dcB1);
1011                         DataColumn dcB2 = new DataColumn ("Col1", typeof (Person));
1012                         dtB.Columns.Add (dcB2);
1013
1014                         Person personA = new Person ("Miguel");
1015                         Address addressA = new Address ("X", 5);
1016
1017                         dtA.Rows.Add (new object [] { addressA, personA });
1018                         DataRow dr = dtA.Rows [0];
1019
1020                         try {
1021                                 object value = dr [dcB1];
1022                                 Assert.Fail ("#A1:" + value);
1023                         } catch (ArgumentException ex) {
1024                                 // Column 'Col0' does not belong to table TableA
1025                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
1026                                 Assert.IsNull (ex.InnerException, "#A3");
1027                                 Assert.IsNotNull (ex.Message, "#A4");
1028                                 Assert.IsTrue (ex.Message.IndexOf ("'Col0'") != -1, "#A5");
1029                                 Assert.IsTrue (ex.Message.IndexOf ("TableA") != -1, "#A6");
1030                         }
1031
1032                         try {
1033                                 object value = dr [new DataColumn ("ZZZ")];
1034                                 Assert.Fail ("#B1:" + value);
1035                         } catch (ArgumentException ex) {
1036                                 // Column 'Col0' does not belong to table TableA
1037                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1038                                 Assert.IsNull (ex.InnerException, "#B3");
1039                                 Assert.IsNotNull (ex.Message, "#B4");
1040                                 Assert.IsTrue (ex.Message.IndexOf ("'ZZZ'") != -1, "#B5");
1041                                 Assert.IsTrue (ex.Message.IndexOf ("TableA") != -1, "#B6");
1042                         }
1043
1044                         dtA.Columns.Remove (dcA2);
1045
1046                         try {
1047                                 object value = dr [dcA2];
1048                                 Assert.Fail ("#C1:" + value);
1049                         } catch (ArgumentException ex) {
1050                                 // Column 'Col0' does not belong to table TableA
1051                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
1052                                 Assert.IsNull (ex.InnerException, "#C3");
1053                                 Assert.IsNotNull (ex.Message, "#C4");
1054                                 Assert.IsTrue (ex.Message.IndexOf ("'Col1'") != -1, "#C5");
1055                                 Assert.IsTrue (ex.Message.IndexOf ("TableA") != -1, "#C6");
1056                         }
1057                 }
1058
1059                 [Test] // Object this [DataColumn]
1060                 public void Indexer1_Column_Null ()
1061                 {
1062                         EventInfo evt;
1063                         DataColumnChangeEventArgs colChangeArgs;
1064
1065                         DataTable dt = new DataTable ();
1066                         dt.ColumnChanged += new DataColumnChangeEventHandler (ColumnChanged);
1067                         dt.ColumnChanging += new DataColumnChangeEventHandler (ColumnChanging);
1068                         DataColumn dc0 = new DataColumn ("Col0", typeof (Address));
1069                         dt.Columns.Add (dc0);
1070                         DataColumn dc1 = new DataColumn ("Col1", typeof (Person));
1071                         dt.Columns.Add (dc1);
1072
1073                         Person personA = new Person ("Miguel");
1074                         Address addressA = new Address ("X", 5);
1075                         Person personB = new Person ("Chris");
1076
1077                         dt.Rows.Add (new object [] { addressA, personA });
1078                         DataRow dr = dt.Rows [0];
1079
1080                         try {
1081                                 object value = dr [(DataColumn) null];
1082                                 Assert.Fail ("#A1:" + value);
1083                         } catch (ArgumentNullException ex) {
1084                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
1085                                 Assert.IsNull (ex.InnerException, "#A3");
1086                                 Assert.IsNotNull (ex.Message, "#A4");
1087                                 Assert.AreEqual ("column", ex.ParamName, "#A5");
1088                         }
1089
1090                         try {
1091                                 dr [(DataColumn) null] = personB;
1092                                 Assert.Fail ("#B1");
1093                         } catch (ArgumentNullException ex) {
1094                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
1095                                 Assert.IsNull (ex.InnerException, "#B3");
1096                                 Assert.IsNotNull (ex.Message, "#B4");
1097                                 Assert.AreEqual ("column", ex.ParamName, "#B5");
1098                         }
1099
1100                         Assert.AreEqual (0, _eventsFired.Count, "#C");
1101                 }
1102
1103                 [Test] // Object this [DataColumn]
1104                 public void Indexer1_Value_Null ()
1105                 {
1106                         EventInfo evt;
1107                         DataColumnChangeEventArgs colChangeArgs;
1108
1109                         DataTable dt = new DataTable ();
1110                         dt.ColumnChanged += new DataColumnChangeEventHandler (ColumnChanged);
1111                         dt.ColumnChanging += new DataColumnChangeEventHandler (ColumnChanging);
1112                         DataColumn dc0 = new DataColumn ("Col0", typeof (Address));
1113                         dt.Columns.Add (dc0);
1114                         DataColumn dc1 = new DataColumn ("Col1", typeof (Person));
1115                         dt.Columns.Add (dc1);
1116                         DataColumn dc2 = new DataColumn ("Col2", typeof (string));
1117                         dt.Columns.Add (dc2);
1118
1119                         Person personA = new Person ("Miguel");
1120                         Address addressA = new Address ("X", 5);
1121                         string countryA = "U.S.";
1122                         Person personB = new Person ("Chris");
1123                         Address addressB = new Address ("Y", 4);
1124                         string countryB = "Canada";
1125                         Person personC = new Person ("Jackson");
1126                         Address addressC = new Address ("Z", 3);
1127
1128                         dt.Rows.Add (new object [] { addressA, personA, countryA });
1129                         dt.Rows.Add (new object [] { addressB, personB, countryB });
1130
1131                         DataRow dr = dt.Rows [0];
1132
1133                         try {
1134                                 dr [dc0] = null;
1135                                 Assert.Fail ("#A1");
1136                         } catch (ArgumentException ex) {
1137                                 // Cannot set Column 'Col0' to be null.
1138                                 // Please use DBNull instead
1139                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
1140                                 Assert.IsNull (ex.InnerException, "#A3");
1141                                 Assert.IsNotNull (ex.Message, "#A4");
1142                                 Assert.IsTrue (ex.Message.IndexOf ("'Col0'") != -1, "#A5");
1143                                 Assert.IsTrue (ex.Message.IndexOf ("DBNull") != -1, "#A6");
1144                         }
1145
1146                         Assert.AreEqual (1, _eventsFired.Count, "#B1");
1147                         Assert.AreEqual (addressA, dr [dc0], "#B2");
1148                         Assert.IsFalse (dr.IsNull (dc0), "#B3");
1149                         Assert.AreSame (personA, dr [dc1], "#B4");
1150                         Assert.IsFalse (dr.IsNull (dc1), "#B5");
1151                         Assert.AreEqual (1, _eventsFired.Count, "#B6");
1152
1153 #if NET_2_0
1154                         dr [dc1] = null;
1155 #else
1156                         try {
1157                                 dr [dc1] = null;
1158                                 Assert.Fail ("#B1");
1159                         } catch (ArgumentException ex) {
1160                                 // Cannot set Column 'Col1' to be null.
1161                                 // Please use DBNull instead
1162                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1163                                 Assert.IsNull (ex.InnerException, "#B3");
1164                                 Assert.IsNotNull (ex.Message, "#B4");
1165                                 Assert.IsTrue (ex.Message.IndexOf ("'Col1'") != -1, "#B5");
1166                                 Assert.IsTrue (ex.Message.IndexOf ("DBNull") != -1, "#B6");
1167                                 Assert.AreEqual (2, _eventsFired.Count, "#B7");
1168                         }
1169                         dr [dc1] = DBNull.Value;
1170 #endif
1171
1172 #if NET_2_0
1173                         Assert.AreEqual (3, _eventsFired.Count, "#C1");
1174 #else
1175                         Assert.AreEqual (4, _eventsFired.Count, "#C1");
1176 #endif
1177                         Assert.AreEqual (addressA, dr [dc0], "#C2");
1178                         Assert.IsFalse (dr.IsNull (dc0), "#C3");
1179                         Assert.AreSame (DBNull.Value, dr [dc1], "#C4");
1180                         Assert.IsTrue (dr.IsNull (dc1), "#C5");
1181 #if NET_2_0
1182                         Assert.AreEqual (3, _eventsFired.Count, "#C6");
1183 #else
1184                         Assert.AreEqual (4, _eventsFired.Count, "#C6");
1185 #endif
1186
1187                         dr [dc0] = DBNull.Value;
1188 #if NET_2_0
1189                         Assert.AreEqual (5, _eventsFired.Count, "#D1");
1190 #else
1191                         Assert.AreEqual (6, _eventsFired.Count, "#D1");
1192 #endif
1193                         Assert.AreSame (DBNull.Value, dr [dc0], "#D2");
1194                         Assert.IsTrue (dr.IsNull (dc0), "#D3");
1195                         Assert.AreSame (DBNull.Value, dr [dc1], "#D4");
1196                         Assert.IsTrue (dr.IsNull (dc1), "#D5");
1197 #if NET_2_0
1198                         Assert.AreEqual (5, _eventsFired.Count, "#D6");
1199 #else
1200                         Assert.AreEqual (6, _eventsFired.Count, "#D6");
1201 #endif
1202
1203                         dr.BeginEdit ();
1204                         dr [dc1] = personC;
1205 #if NET_2_0
1206                         Assert.AreEqual (7, _eventsFired.Count, "#E1");
1207 #else
1208                         Assert.AreEqual (8, _eventsFired.Count, "#E1");
1209 #endif
1210                         Assert.AreSame (DBNull.Value, dr [dc0], "#E2");
1211                         Assert.IsTrue (dr.IsNull (dc0), "#E3");
1212                         Assert.AreEqual (personC, dr [dc1], "#E4");
1213                         Assert.IsFalse (dr.IsNull (dc1), "#E5");
1214                         dr.EndEdit ();
1215                         Assert.AreSame (DBNull.Value, dr [dc0], "#E6");
1216                         Assert.IsTrue (dr.IsNull (dc0), "#E7");
1217                         Assert.AreEqual (personC, dr [dc1], "#E8");
1218                         Assert.IsFalse (dr.IsNull (dc1), "#E9");
1219 #if NET_2_0
1220                         Assert.AreEqual (7, _eventsFired.Count, "#E10");
1221 #else
1222                         Assert.AreEqual (8, _eventsFired.Count, "#E10");
1223 #endif
1224
1225                         dr [dc1] = DBNull.Value;
1226 #if NET_2_0
1227                         Assert.AreEqual (9, _eventsFired.Count, "#F1");
1228 #else
1229                         Assert.AreEqual (10, _eventsFired.Count, "#F1");
1230 #endif
1231                         Assert.AreSame (DBNull.Value, dr [dc0], "#F2");
1232                         Assert.IsTrue (dr.IsNull (dc0), "#F3");
1233                         Assert.AreSame (DBNull.Value, dr [dc1], "#F4");
1234                         Assert.IsTrue (dr.IsNull (dc1), "#F5");
1235 #if NET_2_0
1236                         Assert.AreEqual (9, _eventsFired.Count, "#F6");
1237 #else
1238                         Assert.AreEqual (10, _eventsFired.Count, "#F6");
1239 #endif
1240
1241                         dr [dc2] = null;
1242 #if NET_2_0
1243                         Assert.AreEqual (11, _eventsFired.Count, "#G1");
1244 #else
1245                         Assert.AreEqual (12, _eventsFired.Count, "#G1");
1246 #endif
1247                         Assert.AreSame (DBNull.Value, dr [dc0], "#G2");
1248                         Assert.IsTrue (dr.IsNull (dc0), "#G3");
1249                         Assert.AreSame (DBNull.Value, dr [dc1], "#G4");
1250                         Assert.IsTrue (dr.IsNull (dc1), "#G5");
1251                         Assert.AreSame (DBNull.Value, dr [dc2], "#G6");
1252                         Assert.IsTrue (dr.IsNull (dc2), "#G7");
1253 #if NET_2_0
1254                         Assert.AreEqual (11, _eventsFired.Count, "#G8");
1255 #else
1256                         Assert.AreEqual (12, _eventsFired.Count, "#G8");
1257 #endif
1258
1259                         dr [dc2] = DBNull.Value;
1260 #if NET_2_0
1261                         Assert.AreEqual (13, _eventsFired.Count, "#H1");
1262 #else
1263                         Assert.AreEqual (14, _eventsFired.Count, "#H1");
1264 #endif
1265                         Assert.AreSame (DBNull.Value, dr [dc0], "#H2");
1266                         Assert.IsTrue (dr.IsNull (dc0), "#H3");
1267                         Assert.AreSame (DBNull.Value, dr [dc1], "#H4");
1268                         Assert.IsTrue (dr.IsNull (dc1), "#H5");
1269                         Assert.AreSame (DBNull.Value, dr [dc2], "#H6");
1270                         Assert.IsTrue (dr.IsNull (dc2), "#H7");
1271 #if NET_2_0
1272                         Assert.AreEqual (13, _eventsFired.Count, "#H8");
1273 #else
1274                         Assert.AreEqual (14, _eventsFired.Count, "#H8");
1275 #endif
1276
1277                         int index = 0;
1278
1279                         evt = (EventInfo) _eventsFired [index++];
1280                         Assert.AreEqual ("ColumnChanging", evt.Name, "#I1");
1281                         colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
1282                         Assert.AreSame (dc0, colChangeArgs.Column, "#I2");
1283                         Assert.IsNull (colChangeArgs.ProposedValue, "#I3");
1284                         Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#I4");
1285
1286                         evt = (EventInfo) _eventsFired [index++];
1287                         Assert.AreEqual ("ColumnChanging", evt.Name, "#J1");
1288                         colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
1289                         Assert.AreSame (dc1, colChangeArgs.Column, "#J2");
1290                         Assert.IsNull (colChangeArgs.ProposedValue, "#J3");
1291                         Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#J4");
1292
1293 #if ONLY_1_1
1294                         evt = (EventInfo) _eventsFired [index++];
1295                         Assert.AreEqual ("ColumnChanging", evt.Name, "#K1");
1296                         colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
1297                         Assert.AreSame (dc1, colChangeArgs.Column, "#K2");
1298                         Assert.AreSame (DBNull.Value, colChangeArgs.ProposedValue, "#K3");
1299                         Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#K4");
1300 #endif
1301
1302                         evt = (EventInfo) _eventsFired [index++];
1303                         Assert.AreEqual ("ColumnChanged", evt.Name, "#L1");
1304                         colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
1305                         Assert.AreSame (dc1, colChangeArgs.Column, "#L2");
1306 #if NET_2_0
1307                         Assert.IsNull (colChangeArgs.ProposedValue, "#L3");
1308 #else
1309                         Assert.AreSame (DBNull.Value, colChangeArgs.ProposedValue, "#L3");
1310 #endif
1311                         Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#L4");
1312
1313                         evt = (EventInfo) _eventsFired [index++];
1314                         Assert.AreEqual ("ColumnChanging", evt.Name, "#M1");
1315                         colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
1316                         Assert.AreSame (dc0, colChangeArgs.Column, "#M2");
1317                         Assert.AreSame (DBNull.Value, colChangeArgs.ProposedValue, "#M3");
1318                         Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#M4");
1319
1320                         evt = (EventInfo) _eventsFired [index++];
1321                         Assert.AreEqual ("ColumnChanged", evt.Name, "#N1");
1322                         colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
1323                         Assert.AreSame (dc0, colChangeArgs.Column, "#N2");
1324                         Assert.AreSame (DBNull.Value, colChangeArgs.ProposedValue, "#N3");
1325                         Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#N4");
1326
1327                         evt = (EventInfo) _eventsFired [index++];
1328                         Assert.AreEqual ("ColumnChanging", evt.Name, "#O1");
1329                         colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
1330                         Assert.AreSame (dc1, colChangeArgs.Column, "#O2");
1331                         Assert.AreSame (personC, colChangeArgs.ProposedValue, "#O3");
1332                         Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#O4");
1333
1334                         evt = (EventInfo) _eventsFired [index++];
1335                         Assert.AreEqual ("ColumnChanged", evt.Name, "#P1");
1336                         colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
1337                         Assert.AreSame (dc1, colChangeArgs.Column, "#P2");
1338                         Assert.AreSame (personC, colChangeArgs.ProposedValue, "#P3");
1339                         Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#P4");
1340
1341                         evt = (EventInfo) _eventsFired [index++];
1342                         Assert.AreEqual ("ColumnChanging", evt.Name, "#Q1");
1343                         colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
1344                         Assert.AreSame (dc1, colChangeArgs.Column, "#Q2");
1345                         Assert.AreSame (DBNull.Value, colChangeArgs.ProposedValue, "#Q3");
1346                         Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#Q4");
1347
1348                         evt = (EventInfo) _eventsFired [index++];
1349                         Assert.AreEqual ("ColumnChanged", evt.Name, "#R1");
1350                         colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
1351                         Assert.AreSame (dc1, colChangeArgs.Column, "#R2");
1352                         Assert.AreSame (DBNull.Value, colChangeArgs.ProposedValue, "#R3");
1353                         Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#R4");
1354
1355                         evt = (EventInfo) _eventsFired [index++];
1356                         Assert.AreEqual ("ColumnChanging", evt.Name, "#S1");
1357                         colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
1358                         Assert.AreSame (dc2, colChangeArgs.Column, "#S2");
1359                         Assert.IsNull (colChangeArgs.ProposedValue, "#S3");
1360                         Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#S4");
1361
1362                         evt = (EventInfo) _eventsFired [index++];
1363                         Assert.AreEqual ("ColumnChanged", evt.Name, "#T1");
1364                         colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
1365                         Assert.AreSame (dc2, colChangeArgs.Column, "#T2");
1366                         Assert.IsNull (colChangeArgs.ProposedValue, "#T3");
1367                         Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#T4");
1368
1369                         evt = (EventInfo) _eventsFired [index++];
1370                         Assert.AreEqual ("ColumnChanging", evt.Name, "#U1");
1371                         colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
1372                         Assert.AreSame (dc2, colChangeArgs.Column, "#U2");
1373                         Assert.AreSame (DBNull.Value, colChangeArgs.ProposedValue, "#U3");
1374                         Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#U4");
1375
1376                         evt = (EventInfo) _eventsFired [index++];
1377                         Assert.AreEqual ("ColumnChanged", evt.Name, "#V1");
1378                         colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
1379                         Assert.AreSame (dc2, colChangeArgs.Column, "#V2");
1380                         Assert.AreSame (DBNull.Value, colChangeArgs.ProposedValue, "#V3");
1381                         Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#V4");
1382                 }
1383
1384                 [Test] // Object this [Int32]
1385                 public void Indexer2 ()
1386                 {
1387                         DataTable dt = new DataTable ();
1388                         DataColumn dc0 = new DataColumn ("Col0", typeof (Address));
1389                         dt.Columns.Add (dc0);
1390                         DataColumn dc1 = new DataColumn ("Col1", typeof (Person));
1391                         dt.Columns.Add (dc1);
1392
1393                         Person personA = new Person ("Miguel");
1394                         Address addressA = new Address ("X", 5);
1395                         Person personB = new Person ("Chris");
1396                         Address addressB = new Address ("Y", 4);
1397                         Person personC = new Person ("Jackson");
1398                         Address addressC = new Address ("Z", 3);
1399
1400                         dt.Rows.Add (new object [] { addressA, personA });
1401                         dt.Rows.Add (new object [] { addressB, personB });
1402                         DataRow dr;
1403
1404                         dr = dt.Rows [0];
1405                         Assert.AreEqual (addressA, dr [0], "#A1");
1406                         Assert.AreSame (personA, dr [1], "#A2");
1407
1408                         dr = dt.Rows [1];
1409                         Assert.AreEqual (addressB, dr [0], "#B1");
1410                         Assert.AreSame (personB, dr [1], "#B2");
1411
1412                         dr = dt.Rows [0];
1413                         dr [0] = addressC;
1414                         Assert.AreEqual (addressC, dr [0], "#C1");
1415                         Assert.AreSame (personA, dr [1], "#C2");
1416
1417                         dr = dt.Rows [1];
1418                         dr.BeginEdit ();
1419                         dr [1] = personC;
1420                         Assert.AreEqual (addressB, dr [0], "#D1");
1421                         Assert.AreSame (personC, dr [1], "#D2");
1422                         dr.EndEdit ();
1423                         Assert.AreEqual (addressB, dr [0], "#D3");
1424                         Assert.AreSame (personC, dr [1], "#D4");
1425
1426                         dr = dt.Rows [0];
1427                         dr.BeginEdit ();
1428                         dr [0] = addressB;
1429                         Assert.AreEqual (addressB, dr [0], "#E1");
1430                         Assert.AreSame (personA, dr [1], "#E2");
1431                         dr.CancelEdit ();
1432                         Assert.AreEqual (addressC, dr [0], "#E3");
1433                         Assert.AreSame (personA, dr [1], "#E4");
1434                 }
1435
1436                 [Test] // Object this [Int32]
1437                 public void Indexer2_Value_Null ()
1438                 {
1439                         DataTable dt = new DataTable ();
1440                         DataColumn dc0 = new DataColumn ("Col0", typeof (Address));
1441                         dt.Columns.Add (dc0);
1442                         DataColumn dc1 = new DataColumn ("Col1", typeof (Person));
1443                         dt.Columns.Add (dc1);
1444
1445                         Person personA = new Person ("Miguel");
1446                         Address addressA = new Address ("X", 5);
1447                         Person personB = new Person ("Chris");
1448                         Address addressB = new Address ("Y", 4);
1449                         Person personC = new Person ("Jackson");
1450                         Address addressC = new Address ("Z", 3);
1451
1452                         dt.Rows.Add (new object [] { addressA, personA });
1453                         dt.Rows.Add (new object [] { addressB, personB });
1454
1455                         DataRow dr = dt.Rows [0];
1456
1457                         try {
1458                                 dr [0] = null;
1459                                 Assert.Fail ("#A1");
1460                         } catch (ArgumentException ex) {
1461                                 // Cannot set Column 'Col0' to be null.
1462                                 // Please use DBNull instead
1463                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
1464                                 Assert.IsNull (ex.InnerException, "#A3");
1465                                 Assert.IsNotNull (ex.Message, "#A4");
1466                                 Assert.IsTrue (ex.Message.IndexOf ("'Col0'") != -1, "#A5");
1467                                 Assert.IsTrue (ex.Message.IndexOf ("DBNull") != -1, "#A6");
1468                         }
1469
1470                         Assert.AreEqual (addressA, dr [0], "#B1");
1471                         Assert.IsFalse (dr.IsNull (0), "#B2");
1472                         Assert.AreSame (personA, dr [1], "#B3");
1473                         Assert.IsFalse (dr.IsNull (1), "#B4");
1474
1475 #if NET_2_0
1476                         dr [1] = null;
1477 #else
1478                         try {
1479                                 dr [1] = null;
1480                                 Assert.Fail ("#B1");
1481                         } catch (ArgumentException ex) {
1482                                 // Cannot set Column 'Col1' to be null.
1483                                 // Please use DBNull instead
1484                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1485                                 Assert.IsNull (ex.InnerException, "#B3");
1486                                 Assert.IsNotNull (ex.Message, "#B4");
1487                                 Assert.IsTrue (ex.Message.IndexOf ("'Col1'") != -1, "#B5");
1488                                 Assert.IsTrue (ex.Message.IndexOf ("DBNull") != -1, "#B6");
1489                         }
1490                         dr [1] = DBNull.Value;
1491 #endif
1492
1493                         Assert.AreEqual (addressA, dr [0], "#C1");
1494                         Assert.IsFalse (dr.IsNull (0), "#C2");
1495                         Assert.AreSame (DBNull.Value, dr [1], "#C3");
1496                         Assert.IsTrue (dr.IsNull (1), "#C4");
1497
1498                         dr [0] = DBNull.Value;
1499
1500                         Assert.AreSame (DBNull.Value, dr [0], "#D1");
1501                         Assert.IsTrue (dr.IsNull (0), "#D2");
1502                         Assert.AreSame (DBNull.Value, dr [1], "#D3");
1503                         Assert.IsTrue (dr.IsNull (1), "#D4");
1504
1505                         dr.BeginEdit ();
1506                         dr [1] = personC;
1507                         Assert.AreSame (DBNull.Value, dr [0], "#E1");
1508                         Assert.IsTrue (dr.IsNull (0), "#E2");
1509                         Assert.AreEqual (personC, dr [1], "#E3");
1510                         Assert.IsFalse (dr.IsNull (1), "#E4");
1511                         dr.EndEdit ();
1512                         Assert.AreSame (DBNull.Value, dr [0], "#E5");
1513                         Assert.IsTrue (dr.IsNull (0), "#E6");
1514                         Assert.AreEqual (personC, dr [1], "#E7");
1515                         Assert.IsFalse (dr.IsNull (1), "#E8");
1516
1517                         dr [1] = DBNull.Value;
1518
1519                         Assert.AreSame (DBNull.Value, dr [0], "#F1");
1520                         Assert.IsTrue (dr.IsNull (0), "#F2");
1521                         Assert.AreSame (DBNull.Value, dr [1], "#F3");
1522                         Assert.IsTrue (dr.IsNull (1), "#F4");
1523                 }
1524
1525                 [Test] // Object this [String]
1526                 public void Indexer3 ()
1527                 {
1528                         DataTable dt = new DataTable ();
1529                         DataColumn dc0 = new DataColumn ("Col0", typeof (Address));
1530                         dt.Columns.Add (dc0);
1531                         DataColumn dc1 = new DataColumn ("Col1", typeof (Person));
1532                         dt.Columns.Add (dc1);
1533
1534                         Person personA = new Person ("Miguel");
1535                         Address addressA = new Address ("X", 5);
1536                         Person personB = new Person ("Chris");
1537                         Address addressB = new Address ("Y", 4);
1538                         Person personC = new Person ("Jackson");
1539                         Address addressC = new Address ("Z", 3);
1540
1541                         dt.Rows.Add (new object [] { addressA, personA });
1542                         dt.Rows.Add (new object [] { addressB, personB });
1543                         DataRow dr;
1544
1545                         dr = dt.Rows [0];
1546                         Assert.AreEqual (addressA, dr ["Col0"], "#A1");
1547                         Assert.AreSame (personA, dr ["Col1"], "#A2");
1548
1549                         dr = dt.Rows [1];
1550                         Assert.AreEqual (addressB, dr ["Col0"], "#B1");
1551                         Assert.AreSame (personB, dr ["Col1"], "#B2");
1552
1553                         dr = dt.Rows [0];
1554                         dr ["Col0"] = addressC;
1555                         Assert.AreEqual (addressC, dr ["Col0"], "#C1");
1556                         Assert.AreSame (personA, dr ["Col1"], "#C2");
1557
1558                         dr = dt.Rows [1];
1559                         dr.BeginEdit ();
1560                         dr ["Col1"] = personC;
1561                         Assert.AreEqual (addressB, dr ["Col0"], "#D1");
1562                         Assert.AreSame (personC, dr ["Col1"], "#D2");
1563                         dr.EndEdit ();
1564                         Assert.AreEqual (addressB, dr ["Col0"], "#D3");
1565                         Assert.AreSame (personC, dr ["Col1"], "#D4");
1566
1567                         dr = dt.Rows [0];
1568                         dr.BeginEdit ();
1569                         dr ["Col0"] = addressB;
1570                         Assert.AreEqual (addressB, dr ["Col0"], "#E1");
1571                         Assert.AreSame (personA, dr ["Col1"], "#E2");
1572                         dr.CancelEdit ();
1573                         Assert.AreEqual (addressC, dr ["Col0"], "#E3");
1574                         Assert.AreSame (personA, dr ["Col1"], "#E4");
1575                 }
1576
1577                 [Test] // Object this [String]
1578                 public void Indexer3_ColumnName_Empty ()
1579                 {
1580                         DataTable dt = new DataTable ("Persons");
1581                         DataColumn dc0 = new DataColumn ("Col0", typeof (Address));
1582                         dt.Columns.Add (dc0);
1583                         DataColumn dc1 = new DataColumn (string.Empty, typeof (Person));
1584                         dt.Columns.Add (dc1);
1585
1586                         Person personA = new Person ("Miguel");
1587                         Address addressA = new Address ("X", 5);
1588                         Person personB = new Person ("Chris");
1589
1590                         dt.Rows.Add (new object [] { addressA, personA });
1591
1592                         DataRow dr = dt.Rows [0];
1593
1594                         try {
1595                                 object value = dr [string.Empty];
1596                                 Assert.Fail ("#A1:" + value);
1597                         } catch (ArgumentException ex) {
1598                                 //  Column '' does not belong to table Persons
1599                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
1600                                 Assert.IsNull (ex.InnerException, "#A3");
1601                                 Assert.IsNotNull (ex.Message, "#A4");
1602                                 Assert.IsTrue (ex.Message.IndexOf ("''") != -1, "#A5");
1603                                 Assert.IsTrue (ex.Message.IndexOf ("Persons") != -1, "#A6");
1604                                 Assert.IsNull (ex.ParamName, "#A7");
1605                         }
1606
1607                         try {
1608                                 dr [string.Empty] = personB;
1609                                 Assert.Fail ("#B1");
1610                         } catch (ArgumentException ex) {
1611                                 // Column '' does not belong to table Persons
1612                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1613                                 Assert.IsNull (ex.InnerException, "#B3");
1614                                 Assert.IsNotNull (ex.Message, "#B4");
1615                                 Assert.IsTrue (ex.Message.IndexOf ("''") != -1, "#B5");
1616                                 Assert.IsTrue (ex.Message.IndexOf ("Persons") != -1, "#B6");
1617                                 Assert.IsNull (ex.ParamName, "#B7");
1618                         }
1619                 }
1620
1621                 [Test] // Object this [String]
1622                 public void Indexer3_ColumnName_Null ()
1623                 {
1624                         DataTable dt = new DataTable ();
1625                         DataColumn dc0 = new DataColumn ("Col0", typeof (Address));
1626                         dt.Columns.Add (dc0);
1627                         DataColumn dc1 = new DataColumn ("Col1", typeof (Person));
1628                         dt.Columns.Add (dc1);
1629
1630                         Person personA = new Person ("Miguel");
1631                         Address addressA = new Address ("X", 5);
1632                         Person personB = new Person ("Chris");
1633
1634                         dt.Rows.Add (new object [] { addressA, personA });
1635
1636                         DataRow dr = dt.Rows [0];
1637
1638                         try {
1639                                 object value = dr [(string) null];
1640                                 Assert.Fail ("#A1:" + value);
1641                         } catch (ArgumentNullException ex) {
1642                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
1643                                 Assert.IsNull (ex.InnerException, "#A3");
1644                                 Assert.IsNotNull (ex.Message, "#A4");
1645 #if NET_2_0
1646                                 Assert.AreEqual ("name", ex.ParamName, "#A5");
1647 #else
1648                                 Assert.AreEqual ("key", ex.ParamName, "#A5");
1649 #endif
1650                         }
1651
1652                         try {
1653                                 dr [(string) null] = personB;
1654                                 Assert.Fail ("#B1");
1655                         } catch (ArgumentNullException ex) {
1656                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
1657                                 Assert.IsNull (ex.InnerException, "#B3");
1658                                 Assert.IsNotNull (ex.Message, "#B4");
1659 #if NET_2_0
1660                                 Assert.AreEqual ("name", ex.ParamName, "#B5");
1661 #else
1662                                 Assert.AreEqual ("key", ex.ParamName, "#B5");
1663 #endif
1664                         }
1665                 }
1666
1667                 [Test] // Object this [String]
1668                 public void Indexer3_Value_Null ()
1669                 {
1670                         DataTable dt = new DataTable ();
1671                         DataColumn dc0 = new DataColumn ("Col0", typeof (Address));
1672                         dt.Columns.Add (dc0);
1673                         DataColumn dc1 = new DataColumn ("Col1", typeof (Person));
1674                         dt.Columns.Add (dc1);
1675
1676                         Person personA = new Person ("Miguel");
1677                         Address addressA = new Address ("X", 5);
1678                         Person personB = new Person ("Chris");
1679                         Address addressB = new Address ("Y", 4);
1680                         Person personC = new Person ("Jackson");
1681                         Address addressC = new Address ("Z", 3);
1682
1683                         dt.Rows.Add (new object [] { addressA, personA });
1684                         dt.Rows.Add (new object [] { addressB, personB });
1685
1686                         DataRow dr = dt.Rows [0];
1687
1688                         try {
1689                                 dr ["Col0"] = null;
1690                                 Assert.Fail ("#A1");
1691                         } catch (ArgumentException ex) {
1692                                 // Cannot set Column 'Col0' to be null.
1693                                 // Please use DBNull instead
1694                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
1695                                 Assert.IsNull (ex.InnerException, "#A3");
1696                                 Assert.IsNotNull (ex.Message, "#A4");
1697                                 Assert.IsTrue (ex.Message.IndexOf ("'Col0'") != -1, "#A5");
1698                                 Assert.IsTrue (ex.Message.IndexOf ("DBNull") != -1, "#A6");
1699                         }
1700
1701                         Assert.AreEqual (addressA, dr ["Col0"], "#B1");
1702                         Assert.IsFalse (dr.IsNull ("Col0"), "#B2");
1703                         Assert.AreSame (personA, dr ["Col1"], "#B3");
1704                         Assert.IsFalse (dr.IsNull ("Col1"), "#B4");
1705
1706 #if NET_2_0
1707                         dr ["Col1"] = null;
1708 #else
1709                         try {
1710                                 dr ["Col1"] = null;
1711                                 Assert.Fail ("#B1");
1712                         } catch (ArgumentException ex) {
1713                                 // Cannot set Column 'Col1' to be null.
1714                                 // Please use DBNull instead
1715                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1716                                 Assert.IsNull (ex.InnerException, "#B3");
1717                                 Assert.IsNotNull (ex.Message, "#B4");
1718                                 Assert.IsTrue (ex.Message.IndexOf ("'Col1'") != -1, "#B5");
1719                                 Assert.IsTrue (ex.Message.IndexOf ("DBNull") != -1, "#B6");
1720                         }
1721                         dr ["Col1"] = DBNull.Value;
1722 #endif
1723
1724                         Assert.AreEqual (addressA, dr ["Col0"], "#C1");
1725                         Assert.IsFalse (dr.IsNull ("Col0"), "#C2");
1726                         Assert.AreSame (DBNull.Value, dr ["Col1"], "#C3");
1727                         Assert.IsTrue (dr.IsNull ("Col1"), "#C4");
1728
1729                         dr ["Col0"] = DBNull.Value;
1730
1731                         Assert.AreSame (DBNull.Value, dr ["Col0"], "#D1");
1732                         Assert.IsTrue (dr.IsNull ("Col0"), "#D2");
1733                         Assert.AreSame (DBNull.Value, dr ["Col1"], "#D3");
1734                         Assert.IsTrue (dr.IsNull ("Col1"), "#D4");
1735
1736                         dr ["Col1"] = personC;
1737                         dr.BeginEdit ();
1738                         Assert.AreSame (DBNull.Value, dr ["Col0"], "#E1");
1739                         Assert.IsTrue (dr.IsNull ("Col0"), "#E2");
1740                         Assert.AreEqual (personC, dr ["Col1"], "#E3");
1741                         Assert.IsFalse (dr.IsNull ("Col1"), "#E4");
1742                         dr.EndEdit ();
1743
1744                         dr ["Col1"] = DBNull.Value;
1745
1746                         Assert.AreSame (DBNull.Value, dr ["Col0"], "#F1");
1747                         Assert.IsTrue (dr.IsNull ("Col0"), "#F2");
1748                         Assert.AreSame (DBNull.Value, dr ["Col1"], "#F3");
1749                         Assert.IsTrue (dr.IsNull ("Col1"), "#F4");
1750                 }
1751
1752                 [Test] // Object this [DataColumn, DataRowVersion]
1753                 public void Indexer4 ()
1754                 {
1755                         DataTable dt = new DataTable ();
1756                         DataColumn dc0 = new DataColumn ("Col0", typeof (Address));
1757                         dt.Columns.Add (dc0);
1758                         DataColumn dc1 = new DataColumn ("Col1", typeof (Person));
1759                         dt.Columns.Add (dc1);
1760
1761                         Person personA = new Person ("Miguel");
1762                         Address addressA = new Address ("X", 5);
1763                         Person personB = new Person ("Chris");
1764                         Address addressB = new Address ("Y", 4);
1765                         Person personC = new Person ("Jackson");
1766                         Address addressC = new Address ("Z", 3);
1767
1768                         dt.Rows.Add (new object [] { addressA, personA });
1769                         dt.Rows.Add (new object [] { addressB, personB });
1770                         DataRow dr;
1771
1772                         dr = dt.Rows [0];
1773                         Assert.AreEqual (addressA, dr [dc0, DataRowVersion.Current], "#A1");
1774                         Assert.AreEqual (addressA, dr [dc0, DataRowVersion.Default], "#A2");
1775                         Assert.IsTrue (AssertNotFound (dr, dc0, DataRowVersion.Original), "#A3");
1776                         Assert.IsTrue (AssertNotFound (dr, dc0, DataRowVersion.Proposed), "#A4");
1777                         Assert.AreSame (personA, dr [dc1, DataRowVersion.Current], "#A5");
1778                         Assert.AreSame (personA, dr [dc1, DataRowVersion.Default], "#A6");
1779                         Assert.IsTrue (AssertNotFound (dr, dc1, DataRowVersion.Original), "#A7");
1780                         Assert.IsTrue (AssertNotFound (dr, dc1, DataRowVersion.Proposed), "#A8");
1781
1782                         dr = dt.Rows [1];
1783                         Assert.AreEqual (addressB, dr [dc0, DataRowVersion.Current], "#B1");
1784                         Assert.AreEqual (addressB, dr [dc0, DataRowVersion.Default], "#B2");
1785                         Assert.IsTrue (AssertNotFound (dr, dc0, DataRowVersion.Original), "#B3");
1786                         Assert.IsTrue (AssertNotFound (dr, dc0, DataRowVersion.Proposed), "#B4");
1787                         Assert.AreSame (personB, dr [dc1, DataRowVersion.Current], "#B5");
1788                         Assert.AreSame (personB, dr [dc1, DataRowVersion.Default], "#B6");
1789                         Assert.IsTrue (AssertNotFound (dr, dc1, DataRowVersion.Original), "#B7");
1790                         Assert.IsTrue (AssertNotFound (dr, dc1, DataRowVersion.Proposed), "#B8");
1791
1792                         dr = dt.Rows [0];
1793                         dr [dc0] = addressC;
1794                         Assert.AreEqual (addressC, dr [dc0, DataRowVersion.Current], "#C1");
1795                         Assert.AreEqual (addressC, dr [dc0, DataRowVersion.Default], "#C2");
1796                         Assert.IsTrue (AssertNotFound (dr, dc0, DataRowVersion.Original), "#C3");
1797                         Assert.IsTrue (AssertNotFound (dr, dc0, DataRowVersion.Proposed), "#C4");
1798                         Assert.AreSame (personA, dr [dc1, DataRowVersion.Current], "#C5");
1799                         Assert.AreSame (personA, dr [dc1, DataRowVersion.Default], "#C6");
1800                         Assert.IsTrue (AssertNotFound (dr, dc1, DataRowVersion.Original), "#C7");
1801                         Assert.IsTrue (AssertNotFound (dr, dc1, DataRowVersion.Proposed), "#C8");
1802
1803                         dr = dt.Rows [1];
1804                         dr.BeginEdit ();
1805                         dr [dc1] = personC;
1806                         Assert.AreEqual (addressB, dr [dc0, DataRowVersion.Current], "#D1");
1807                         Assert.AreEqual (addressB, dr [dc0, DataRowVersion.Default], "#D2");
1808                         Assert.IsTrue (AssertNotFound (dr, dc0, DataRowVersion.Original), "#D3");
1809                         Assert.AreEqual (addressB, dr [dc0, DataRowVersion.Proposed], "#D4");
1810                         Assert.AreSame (personB, dr [dc1, DataRowVersion.Current], "#D5");
1811                         Assert.AreSame (personC, dr [dc1, DataRowVersion.Default], "#D6");
1812                         Assert.IsTrue (AssertNotFound (dr, dc1, DataRowVersion.Original), "#D7");
1813                         Assert.AreSame (personC, dr [dc1, DataRowVersion.Proposed], "#D8");
1814                         dr.EndEdit ();
1815                         Assert.AreEqual (addressB, dr [dc0, DataRowVersion.Current], "#D9");
1816                         Assert.AreEqual (addressB, dr [dc0, DataRowVersion.Default], "#D10");
1817                         Assert.IsTrue (AssertNotFound (dr, dc0, DataRowVersion.Original), "#D11");
1818                         Assert.IsTrue (AssertNotFound (dr, dc0, DataRowVersion.Proposed), "#D12");
1819                         Assert.AreSame (personC, dr [dc1, DataRowVersion.Current], "#D13");
1820                         Assert.AreSame (personC, dr [dc1, DataRowVersion.Default], "#D14");
1821                         Assert.IsTrue (AssertNotFound (dr, dc1, DataRowVersion.Original), "#D15");
1822                         Assert.IsTrue (AssertNotFound (dr, dc1, DataRowVersion.Proposed), "#D16");
1823                         dr.AcceptChanges ();
1824                         Assert.AreEqual (addressB, dr [dc0, DataRowVersion.Current], "#D17");
1825                         Assert.AreEqual (addressB, dr [dc0, DataRowVersion.Default], "#D18");
1826                         Assert.AreEqual (addressB, dr [dc0, DataRowVersion.Original], "#D19");
1827                         Assert.IsTrue (AssertNotFound (dr, dc0, DataRowVersion.Proposed), "#D20");
1828                         Assert.AreSame (personC, dr [dc1, DataRowVersion.Current], "#D21");
1829                         Assert.AreSame (personC, dr [dc1, DataRowVersion.Default], "#D22");
1830                         Assert.AreEqual (personC, dr [dc1, DataRowVersion.Original], "#D23");
1831                         Assert.IsTrue (AssertNotFound (dr, dc1, DataRowVersion.Proposed), "#D24");
1832
1833                         dr = dt.Rows [0];
1834                         dr.BeginEdit ();
1835                         dr [dc0] = addressA;
1836                         Assert.AreEqual (addressC, dr [dc0, DataRowVersion.Current], "#E1");
1837                         Assert.AreEqual (addressA, dr [dc0, DataRowVersion.Default], "#E2");
1838                         Assert.IsTrue (AssertNotFound (dr, dc0, DataRowVersion.Original), "#E3");
1839                         Assert.AreEqual (addressA, dr [dc0, DataRowVersion.Proposed], "#E4");
1840                         Assert.AreSame (personA, dr [dc1, DataRowVersion.Current], "#E5");
1841                         Assert.AreSame (personA, dr [dc1, DataRowVersion.Default], "#E6");
1842                         Assert.IsTrue (AssertNotFound (dr, dc1, DataRowVersion.Original), "#E7");
1843                         Assert.AreSame (personA, dr [dc1, DataRowVersion.Proposed], "#E8");
1844                         dr.CancelEdit ();
1845                         Assert.AreEqual (addressC, dr [dc0, DataRowVersion.Current], "#E9");
1846                         Assert.AreEqual (addressC, dr [dc0, DataRowVersion.Default], "#E10");
1847                         Assert.IsTrue (AssertNotFound (dr, dc0, DataRowVersion.Original), "#E11");
1848                         Assert.IsTrue (AssertNotFound (dr, dc0, DataRowVersion.Proposed), "#E12");
1849                         Assert.AreSame (personA, dr [dc1, DataRowVersion.Current], "#E13");
1850                         Assert.AreSame (personA, dr [dc1, DataRowVersion.Default], "#E14");
1851                         Assert.IsTrue (AssertNotFound (dr, dc1, DataRowVersion.Original), "#E15");
1852                         Assert.IsTrue (AssertNotFound (dr, dc1, DataRowVersion.Proposed), "#E16");
1853                 }
1854
1855                 [Test]
1856                 public void Indexer4_Column_NotInTable ()
1857                 {
1858                         DataTable dtA = new DataTable ("TableA");
1859                         DataColumn dcA1 = new DataColumn ("Col0", typeof (Address));
1860                         dtA.Columns.Add (dcA1);
1861                         DataColumn dcA2 = new DataColumn ("Col1", typeof (Person));
1862                         dtA.Columns.Add (dcA2);
1863
1864                         DataTable dtB = new DataTable ("TableB");
1865                         DataColumn dcB1 = new DataColumn ("Col0", typeof (Address));
1866                         dtB.Columns.Add (dcB1);
1867                         DataColumn dcB2 = new DataColumn ("Col1", typeof (Person));
1868                         dtB.Columns.Add (dcB2);
1869
1870                         Person personA = new Person ("Miguel");
1871                         Address addressA = new Address ("X", 5);
1872
1873                         dtA.Rows.Add (new object [] { addressA, personA });
1874                         DataRow dr = dtA.Rows [0];
1875
1876                         try {
1877                                 object value = dr [dcB1, DataRowVersion.Default];
1878                                 Assert.Fail ("#A1:" + value);
1879                         } catch (ArgumentException ex) {
1880                                 // Column 'Col0' does not belong to table TableA
1881                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
1882                                 Assert.IsNull (ex.InnerException, "#A3");
1883                                 Assert.IsNotNull (ex.Message, "#A4");
1884                                 Assert.IsTrue (ex.Message.IndexOf ("'Col0'") != -1, "#A5");
1885                                 Assert.IsTrue (ex.Message.IndexOf ("TableA") != -1, "#A6");
1886                         }
1887
1888                         try {
1889                                 object value = dr [new DataColumn ("ZZZ"), DataRowVersion.Default];
1890                                 Assert.Fail ("#B1:" + value);
1891                         } catch (ArgumentException ex) {
1892                                 // Column 'Col0' does not belong to table TableA
1893                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1894                                 Assert.IsNull (ex.InnerException, "#B3");
1895                                 Assert.IsNotNull (ex.Message, "#B4");
1896                                 Assert.IsTrue (ex.Message.IndexOf ("'ZZZ'") != -1, "#B5");
1897                                 Assert.IsTrue (ex.Message.IndexOf ("TableA") != -1, "#B6");
1898                         }
1899
1900                         dtA.Columns.Remove (dcA2);
1901
1902                         try {
1903                                 object value = dr [dcA2, DataRowVersion.Default];
1904                                 Assert.Fail ("#C1:" + value);
1905                         } catch (ArgumentException ex) {
1906                                 // Column 'Col0' does not belong to table TableA
1907                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
1908                                 Assert.IsNull (ex.InnerException, "#C3");
1909                                 Assert.IsNotNull (ex.Message, "#C4");
1910                                 Assert.IsTrue (ex.Message.IndexOf ("'Col1'") != -1, "#C5");
1911                                 Assert.IsTrue (ex.Message.IndexOf ("TableA") != -1, "#C6");
1912                         }
1913                 }
1914
1915                 [Test] // Object this [DataColumn, DataRowVersion]
1916                 public void Indexer4_Column_Null ()
1917                 {
1918                         DataTable dt = new DataTable ();
1919                         DataColumn dc0 = new DataColumn ("Col0", typeof (Address));
1920                         dt.Columns.Add (dc0);
1921                         DataColumn dc1 = new DataColumn ("Col1", typeof (Person));
1922                         dt.Columns.Add (dc1);
1923
1924                         Person personA = new Person ("Miguel");
1925                         Address addressA = new Address ("X", 5);
1926                         Person personB = new Person ("Chris");
1927
1928                         dt.Rows.Add (new object [] { addressA, personA });
1929                         DataRow dr = dt.Rows [0];
1930
1931                         try {
1932                                 object value = dr [(DataColumn) null, DataRowVersion.Default];
1933                                 Assert.Fail ("#1:" + value);
1934                         } catch (ArgumentNullException ex) {
1935                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1936                                 Assert.IsNull (ex.InnerException, "#3");
1937                                 Assert.IsNotNull (ex.Message, "#4");
1938                                 Assert.AreEqual ("column", ex.ParamName, "#5");
1939                         }
1940                 }
1941
1942                 [Test] // Object this [DataColumn, DataRowVersion]
1943                 public void Indexer4_Version_Invalid ()
1944                 {
1945                         DataTable dt = new DataTable ();
1946                         DataColumn dc0 = new DataColumn ("Col0", typeof (Address));
1947                         dt.Columns.Add (dc0);
1948                         DataColumn dc1 = new DataColumn ("Col1", typeof (Person));
1949                         dt.Columns.Add (dc1);
1950
1951                         Person personA = new Person ("Miguel");
1952                         Address addressA = new Address ("X", 5);
1953                         Person personB = new Person ("Chris");
1954
1955                         dt.Rows.Add (new object [] { addressA, personA });
1956                         DataRow dr = dt.Rows [0];
1957
1958                         try {
1959                                 object value = dr [dc0, (DataRowVersion) 666];
1960                                 Assert.Fail ("#1:" + value);
1961                         } catch (DataException ex) {
1962                                 // Version must be Original, Current, or Proposed
1963                                 Assert.AreEqual (typeof (DataException), ex.GetType (), "#2");
1964                                 Assert.IsNull (ex.InnerException, "#3");
1965                                 Assert.IsNotNull (ex.Message, "#4");
1966                                 Assert.IsTrue (ex.Message.IndexOf ("Original") != -1, "#5");
1967                                 Assert.IsTrue (ex.Message.IndexOf ("Current") != -1, "#6");
1968                                 Assert.IsTrue (ex.Message.IndexOf ("Proposed") != -1, "#7");
1969                                 Assert.IsFalse (ex.Message.IndexOf ("Default") != -1, "#8");
1970                         }
1971                 }
1972
1973                 [Test] // Object this [DataColumn, DataRowVersion]
1974                 public void Indexer4_Version_NotFound ()
1975                 {
1976                         DataTable dt = new DataTable ();
1977                         DataColumn dc0 = new DataColumn ("Col0", typeof (Address));
1978                         dt.Columns.Add (dc0);
1979                         DataColumn dc1 = new DataColumn ("Col1", typeof (Person));
1980                         dt.Columns.Add (dc1);
1981
1982                         Person personA = new Person ("Miguel");
1983                         Address addressA = new Address ("X", 5);
1984                         Person personB = new Person ("Chris");
1985
1986                         dt.Rows.Add (new object [] { addressA, personA });
1987                         DataRow dr = dt.Rows [0];
1988
1989                         try {
1990                                 object value = dr [dc0, DataRowVersion.Original];
1991                                 Assert.Fail ("#A1:" + value);
1992                         } catch (VersionNotFoundException ex) {
1993                                 // There is no Original data to access
1994                                 Assert.AreEqual (typeof (VersionNotFoundException), ex.GetType (), "#A2");
1995                                 Assert.IsNull (ex.InnerException, "#A3");
1996                                 Assert.IsNotNull (ex.Message, "#A4");
1997                                 Assert.IsTrue (ex.Message.IndexOf ("Original") != -1, "#A5");
1998                         }
1999
2000                         try {
2001                                 object value = dr [dc0, DataRowVersion.Proposed];
2002                                 Assert.Fail ("#B1:" + value);
2003                         } catch (VersionNotFoundException ex) {
2004                                 // There is no Proposed data to access
2005                                 Assert.AreEqual (typeof (VersionNotFoundException), ex.GetType (), "#B2");
2006                                 Assert.IsNull (ex.InnerException, "#B3");
2007                                 Assert.IsNotNull (ex.Message, "#B4");
2008                                 Assert.IsTrue (ex.Message.IndexOf ("Proposed") != -1, "#B5");
2009                         }
2010                 }
2011
2012                 [Test] public void IsNull_ByDataColumn()
2013                 {
2014                         DataTable dt = new DataTable();
2015                         DataColumn dc0 = new DataColumn("Col0",typeof(int));
2016                         DataColumn dc1 = new DataColumn("Col1",typeof(int));
2017                         dt.Columns.Add(dc0);
2018                         dt.Columns.Add(dc1);
2019                         dt.Rows.Add(new object[] {1234});
2020                         DataRow dr = dt.Rows[0];
2021
2022                         // IsNull_I 2
2023                         Assert.AreEqual(false , dr.IsNull(dc0) , "DRW85");
2024
2025                         // IsNull_I 2
2026                         Assert.AreEqual(true , dr.IsNull(dc1) , "DRW86");
2027                 }
2028
2029                 [Test] public void IsNull_ByDataColumnDataRowVersion()
2030                 {
2031                         DataTable dt = new DataTable();
2032                         DataColumn dc0 = new DataColumn("Col0",typeof(int));
2033                         DataColumn dc1 = new DataColumn("Col1",typeof(int));
2034                         dt.Columns.Add(dc0);
2035                         dt.Columns.Add(dc1);
2036                         dt.Rows.Add(new object[] {1234});
2037                         DataRow dr = dt.Rows[0];
2038
2039                         // IsNull - col0 Current
2040                         Assert.AreEqual(false, dr.IsNull(dc0,DataRowVersion.Current) , "DRW87");
2041
2042                         // IsNull - col1 Current
2043                         Assert.AreEqual(true, dr.IsNull(dc1,DataRowVersion.Current) , "DRW88");
2044
2045                         // IsNull - col0 Default
2046                         Assert.AreEqual(false, dr.IsNull(dc0,DataRowVersion.Default) , "DRW89");
2047                         // IsNull - col1 Default
2048                         Assert.AreEqual(true, dr.IsNull(dc1,DataRowVersion.Default) , "DRW90");
2049
2050                         dr.BeginEdit();
2051                         dr[0] = 9; //Change value, Create RowVersion Proposed
2052
2053                         // IsNull - col0 Proposed
2054                         Assert.AreEqual(false, dr.IsNull(dc0,DataRowVersion.Proposed) , "DRW91");
2055                         // IsNull - col1 Proposed
2056                         Assert.AreEqual(true, dr.IsNull(dc1,DataRowVersion.Proposed) , "DRW92");
2057
2058                         dr.AcceptChanges();
2059                         dr.Delete();
2060
2061                         // IsNull - col0 Original
2062                         Assert.AreEqual(false, dr.IsNull(dc0,DataRowVersion.Original) , "DRW93");
2063                 }
2064
2065                 [Test] public void IsNull_ByIndex()
2066                 {
2067                         DataTable dt = new DataTable();
2068                         DataColumn dc0 = new DataColumn("Col0",typeof(int));
2069                         DataColumn dc1 = new DataColumn("Col1",typeof(int));
2070                         dt.Columns.Add(dc0);
2071                         dt.Columns.Add(dc1);
2072                         dt.Rows.Add(new object[] {1234});
2073                         DataRow dr = dt.Rows[0];
2074
2075                         // IsNull_I 2
2076                         Assert.AreEqual(false , dr.IsNull(0) , "DRW94");
2077
2078                         // IsNull_I 2
2079                         Assert.AreEqual(true , dr.IsNull(1) , "DRW95");
2080                 }
2081
2082                 [Test] public void IsNull_ByName()
2083                 {
2084                         DataTable dt = new DataTable();
2085                         DataColumn dc0 = new DataColumn("Col0",typeof(int));
2086                         DataColumn dc1 = new DataColumn("Col1",typeof(int));
2087                         dt.Columns.Add(dc0);
2088                         dt.Columns.Add(dc1);
2089                         dt.Rows.Add(new object[] {1234});
2090                         DataRow dr = dt.Rows[0];
2091
2092 #region --- assignment  ----
2093                         // IsNull_S 1
2094                         Assert.AreEqual(false, dr.IsNull("Col0"), "DRW96");
2095
2096                         // IsNull_S 2
2097                         Assert.AreEqual(true, dr.IsNull("Col1"), "DRW97");
2098 #endregion
2099
2100 #region --- bug 3124 ---
2101
2102                         // IsNull_S 1
2103                         MemoryStream st = new MemoryStream();
2104                         StreamWriter sw = new StreamWriter(st);
2105                         sw.Write("<?xml version=\"1.0\" standalone=\"yes\"?><NewDataSet>");
2106                         sw.Write("<Table><EmployeeNo>9</EmployeeNo></Table>");
2107                         sw.Write("</NewDataSet>");
2108                         sw.Flush();
2109                         st.Position=0;
2110                         DataSet ds = new DataSet();
2111                         ds.ReadXml(st);
2112                         //  Here we add the expression column
2113                         ds.Tables[0].Columns.Add("ValueListValueMember", typeof(object), "EmployeeNo");
2114
2115                         foreach( DataRow row in ds.Tables[0].Rows )
2116                         {
2117                                 // Console.WriteLine(row["ValueListValueMember"].ToString() + " " );
2118                                 if( row.IsNull("ValueListValueMember") == true )
2119                                         Assert.AreEqual("Failed", "SubTest", "DRW98");
2120                                 else
2121                                         Assert.AreEqual("Passed", "Passed", "DRW99");
2122                         }
2123
2124 #endregion
2125                 }
2126
2127                 [Test] public void Item()
2128                 {
2129                         // init table with columns
2130                         DataTable myTable = new DataTable("myTable");
2131
2132                         myTable.Columns.Add(new DataColumn("Id",typeof(int)));
2133                         myTable.Columns.Add(new DataColumn("Name",typeof(string)));
2134                         DataColumn dc = myTable.Columns[0];
2135
2136                         myTable.Rows.Add(new object[] {1,"Ofer"});
2137                         myTable.Rows.Add(new object[] {2,"Ofer"});
2138
2139                         myTable.AcceptChanges();
2140
2141                         DataRow myRow = myTable.Rows[0];
2142
2143                         //Start checking
2144
2145                         // Item - index
2146                         Assert.AreEqual(1 , (int)myRow[0] , "DRW100");
2147
2148                         // Item - string
2149                         Assert.AreEqual(1 ,  (int)myRow["Id"] , "DRW101");
2150
2151                         // Item - Column
2152                         Assert.AreEqual(1 ,  (int)myRow[dc] , "DRW102");
2153
2154                         // Item - index,Current
2155                         Assert.AreEqual(1 ,  (int)myRow[0,DataRowVersion.Current ] , "DRW103");
2156
2157                         // Item - string,Current
2158                         Assert.AreEqual(1 ,  (int)myRow["Id",DataRowVersion.Current] , "DRW104");
2159
2160                         // Item - columnn,Current
2161                         Assert.AreEqual(1 ,  (int)myRow[dc,DataRowVersion.Current] , "DRW105");
2162
2163                         //      testMore();
2164                 }
2165
2166                 /*public void testMore()
2167                 {
2168                         DataTable dt = DataProvider.CreateParentDataTable();
2169                         dt.Rows[0].BeginEdit();
2170                         dt.Rows[0][0] = 10;
2171                         dt.Rows[0].EndEdit();
2172                         dt.AcceptChanges();
2173                 }*/
2174
2175                 [Test] public void RejectChanges()
2176                 {
2177                         DataTable dt = new DataTable();
2178                         DataColumn dc0 = new DataColumn("Col0",typeof(int));
2179                         DataColumn dc1 = new DataColumn("Col1",typeof(int));
2180                         dt.Columns.Add(dc0);
2181                         dt.Columns.Add(dc1);
2182                         dt.Rows.Add(new object[] {1234});
2183                         dt.AcceptChanges();
2184                         DataRow dr = dt.Rows[0];
2185
2186                         dr[0] = 567;
2187                         dr[1] = 789;
2188                         dr.RejectChanges();
2189
2190                         // RejectChanges - row 0
2191                         Assert.AreEqual(1234  ,  (int)dr[0], "DRW106");
2192
2193                         // RejectChanges - row 1
2194                         Assert.AreEqual(DBNull.Value  ,  dr[1] , "DRW107");
2195
2196                         dr.Delete();
2197                         dr.RejectChanges();
2198
2199                         // RejectChanges - count
2200                         Assert.AreEqual(1 ,  dt.Rows.Count , "DRW108");
2201                 }
2202
2203                 [Test] public void RowState()
2204                 {
2205                         DataTable myTable = new DataTable("myTable");
2206                         DataColumn dc = new DataColumn("Name",typeof(string));
2207                         myTable.Columns.Add(dc);
2208                         DataRow myRow;
2209
2210                         // Create a new DataRow.
2211                         myRow = myTable.NewRow();
2212
2213                         // Detached row.
2214
2215                         // Detached
2216                         Assert.AreEqual(DataRowState.Detached ,  myRow.RowState , "DRW109");
2217
2218                         myTable.Rows.Add(myRow);
2219                         // New row.
2220
2221                         // Added
2222                         Assert.AreEqual(DataRowState.Added ,  myRow.RowState , "DRW110");
2223
2224                         myTable.AcceptChanges();
2225                         // Unchanged row.
2226
2227                         // Unchanged
2228                         Assert.AreEqual(DataRowState.Unchanged ,  myRow.RowState , "DRW111");
2229
2230                         myRow["Name"] = "Scott";
2231                         // Modified row.
2232
2233                         // Modified
2234                         Assert.AreEqual(DataRowState.Modified ,  myRow.RowState , "DRW112");
2235
2236                         myRow.Delete();
2237                         // Deleted row.
2238
2239                         // Deleted
2240                         Assert.AreEqual(DataRowState.Deleted ,  myRow.RowState , "DRW113");
2241                 }
2242
2243                 [Test] public void SetColumnError_ByDataColumnError()
2244                 {
2245                         string sColErr = "Error!";
2246                         DataTable dt = new DataTable("myTable");
2247                         DataColumn dc = new DataColumn("Column1");
2248                         dt.Columns.Add(dc);
2249                         DataRow dr = dt.NewRow();
2250
2251                         // empty string
2252                         Assert.AreEqual(String.Empty,  dr.GetColumnError(dc) , "DRW114");
2253
2254                         dr.SetColumnError(dc,sColErr );
2255
2256                         // error string
2257                         Assert.AreEqual(sColErr, dr.GetColumnError(dc) , "DRW115");
2258                 }
2259
2260                 [Test] public void SetColumnError_ByIndexError()
2261                 {
2262                         string sColErr = "Error!";
2263                         DataTable dt = new DataTable("myTable");
2264                         DataColumn dc = new DataColumn("Column1");
2265                         dt.Columns.Add(dc);
2266                         DataRow dr = dt.NewRow();
2267
2268                         // empty string
2269                         Assert.AreEqual(String.Empty ,  dr.GetColumnError(0) , "DRW116");
2270
2271                         dr.SetColumnError(0,sColErr );
2272
2273                         // error string
2274                         Assert.AreEqual(sColErr  ,  dr.GetColumnError(0) , "DRW117");
2275                         dr.SetColumnError (0, "");
2276                         Assert.AreEqual("",  dr.GetColumnError (0) , "DRW118");
2277                 }
2278
2279                 [Test] public void SetColumnError_ByColumnNameError()
2280                 {
2281                         string sColErr = "Error!";
2282                         DataTable dt = new DataTable("myTable");
2283                         DataColumn dc = new DataColumn("Column1");
2284                         dt.Columns.Add(dc);
2285                         DataRow dr = dt.NewRow();
2286
2287                         // empty string
2288                         Assert.AreEqual(String.Empty,  dr.GetColumnError("Column1") , "DRW118");
2289
2290                         dr.SetColumnError("Column1",sColErr );
2291
2292                         // error string
2293                         Assert.AreEqual(sColErr,  dr.GetColumnError("Column1") , "DRW119");
2294                 }
2295
2296                 [Test] public void SetParentRow_ByDataRow()
2297                 {
2298                         DataRow drParent,drChild;
2299                         DataRow drArrExcepted,drArrResult;
2300                         DataTable dtChild,dtParent;
2301                         DataSet ds = new DataSet();
2302                         //Create tables
2303                         dtChild = DataProvider.CreateChildDataTable();
2304                         dtParent= DataProvider.CreateParentDataTable();
2305                         //Add tables to dataset
2306                         ds.Tables.Add(dtChild);
2307                         ds.Tables.Add(dtParent);
2308                         //Add Relation
2309                         DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"]);
2310                         ds.Relations.Add(dRel);
2311
2312                         drParent = dtParent.Rows[0];
2313                         drChild = dtChild.Select("ParentId=" + drParent["ParentId"])[0];
2314
2315                         drChild.SetParentRow(drParent);
2316
2317                         //Get Excepted result
2318                         drArrExcepted = drParent;
2319                         //Get Result DataRowVersion.Current
2320                         drArrResult = drChild.GetParentRow("Parent-Child",DataRowVersion.Current);
2321
2322                         // SetParentRow
2323                         Assert.AreEqual(drArrExcepted ,  drArrResult, "DRW120");
2324                 }
2325
2326                 [Test]
2327                 public void testMore()
2328                 {
2329                         DataSet ds = DataProvider.CreateForigenConstraint();
2330                         DataRow drParent = ds.Tables[0].Rows[0];
2331                         //DataRow[] drArray =  ds.Tables[1].Rows[0].GetParentRows(ds.Tables[1].ParentRelations[0]);
2332                         ds.Tables[1].Rows[0].SetParentRow(drParent);
2333                 }
2334
2335                 [Test]
2336                 public void test()
2337                 {
2338                         // test SetParentRow
2339                         DataTable parent = DataProvider.CreateParentDataTable();
2340                         DataTable child = DataProvider.CreateChildDataTable();
2341                         DataRow dr = parent.Rows[0];
2342                         dr.Delete();
2343                         parent.AcceptChanges();
2344
2345                         child.Rows[0].SetParentRow(dr);
2346                 }
2347
2348                 public void checkForLoops()
2349                 {
2350                         DataSet ds = new DataSet();
2351                         //Create tables
2352                         DataTable  dtChild = DataProvider.CreateChildDataTable();
2353                         DataTable dtParent= DataProvider.CreateParentDataTable();
2354                         //Add tables to dataset
2355                         ds.Tables.Add(dtChild);
2356                         ds.Tables.Add(dtParent);
2357
2358                         dtChild.Rows.Clear();
2359                         dtParent.Rows.Clear();
2360
2361                         dtParent.ChildRelations.Add(dtParent.Columns[0],dtChild.Columns[0]);
2362                         dtChild.ChildRelations.Add(dtChild.Columns[0],dtParent.Columns[0]);
2363
2364                         dtChild.Rows[0].SetParentRow(dtParent.Rows[0]);
2365                         dtParent.Rows[0].SetParentRow(dtChild.Rows[0]);
2366                 }
2367
2368                 public void checkForLoopsAdvenced()
2369                 {
2370                         //Create tables
2371                         DataTable  dtChild = new DataTable();
2372                         dtChild.Columns.Add("Col1",typeof(int));
2373                         dtChild.Columns.Add("Col2",typeof(int));
2374
2375                         DataRelation drl = new DataRelation("drl1",dtChild.Columns[0],dtChild.Columns[1]);
2376                         dtChild.ChildRelations.Add(drl);
2377                         dtChild.Rows[0].SetParentRow(dtChild.Rows[1]);
2378                         dtChild.Rows[1].SetParentRow(dtChild.Rows[0]);
2379                 }
2380
2381                 [Test] public void SetParentRow_ByDataRowDataRelation()
2382                 {
2383                         DataRow drParent,drChild;
2384                         DataRow drArrExcepted,drArrResult;
2385                         DataTable dtChild,dtParent;
2386                         DataSet ds = new DataSet();
2387                         //Create tables
2388                         dtChild = DataProvider.CreateChildDataTable();
2389                         dtParent= DataProvider.CreateParentDataTable();
2390                         //Add tables to dataset
2391                         ds.Tables.Add(dtChild);
2392                         ds.Tables.Add(dtParent);
2393                         //Add Relation
2394                         DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"]);
2395                         ds.Relations.Add(dRel);
2396
2397                         drParent = dtParent.Rows[0];
2398                         drChild = dtChild.Select("ParentId=" + drParent["ParentId"])[0];
2399
2400                         drChild.SetParentRow(drParent ,dRel);
2401
2402                         //Get Excepted result
2403                         drArrExcepted = drParent;
2404                         //Get Result DataRowVersion.Current
2405                         drArrResult = drChild.GetParentRow("Parent-Child",DataRowVersion.Current);
2406
2407                         // SetParentRow
2408                         Assert.AreEqual(drArrExcepted ,  drArrResult, "DRW121");
2409                 }
2410
2411                 [Test] public void Table()
2412                 {
2413                         DataTable dt1,dt2;
2414                         dt2 = new DataTable("myTable");
2415                         DataRow dr = dt2.NewRow();
2416                         dt1 = dr.Table;
2417
2418                         // ctor
2419                         Assert.AreEqual(dt2, dt1 , "DRW122");
2420                 }
2421
2422                 [Test] public new  void ToString()
2423                 {
2424                         DataRow dr;
2425                         DataTable dtParent;
2426                         dtParent= DataProvider.CreateParentDataTable();
2427                         dr = dtParent.Rows[0];
2428
2429                         // ToString
2430                         Assert.AreEqual(true, dr.ToString().ToLower().StartsWith("system.data.datarow") , "DRW123");
2431                 }
2432
2433                 [Test] public void DataRow_RowError()
2434                 {
2435                         DataTable dt = new DataTable ("myTable");
2436                         DataRow dr = dt.NewRow ();
2437
2438                         Assert.AreEqual ( dr.RowError, string.Empty );
2439
2440                         dr.RowError = "Err";
2441                         Assert.AreEqual ( dr.RowError , "Err" );
2442                 }
2443
2444                 [Test]
2445                 [ExpectedException (typeof (ConstraintException))]
2446                 public void DataRow_RowError2()
2447                 {
2448                         DataTable dt1 = DataProvider.CreateUniqueConstraint();
2449
2450                         dt1.BeginLoadData();
2451
2452                         DataRow  dr = dt1.NewRow();
2453                         dr[0] = 3;
2454                         dt1.Rows.Add(dr);
2455                         dt1.EndLoadData();
2456                 }
2457
2458                 [Test]
2459                 [ExpectedException (typeof (ConstraintException))]
2460                 public void DataRow_RowError3()
2461                 {
2462                         DataSet ds= DataProvider.CreateForigenConstraint();
2463                         ds.Tables[0].BeginLoadData();
2464                         ds.Tables[0].Rows[0][0] = 10;
2465                         ds.Tables[0].EndLoadData(); //Foreign constraint violation
2466                 }
2467
2468
2469                 [Test]
2470                 public void TestRowErrors ()
2471                 {
2472                         DataTable table = new DataTable ();
2473                         DataColumn col1 = table.Columns.Add ("col1", typeof (int));
2474                         DataColumn col2 = table.Columns.Add ("col2", typeof (int));
2475                         DataColumn col3 = table.Columns.Add ("col3", typeof (int));
2476
2477                         col1.AllowDBNull = false;
2478                         table.Constraints.Add ("uc", new DataColumn[] {col2,col3}, false);
2479                         table.BeginLoadData ();
2480                         table.Rows.Add (new object[] {null,1,1});
2481                         table.Rows.Add (new object[] {1,1,1});
2482                         try {
2483                                 table.EndLoadData ();
2484                                 Assert.Fail ("#0");
2485                         } catch (ConstraintException) {}
2486                         Assert.IsTrue (table.HasErrors, "#1");
2487                         DataRow[] rows = table.GetErrors ();
2488
2489                         Assert.AreEqual (2, rows.Length, "#2");
2490                         Assert.AreEqual ("Column 'col1' does not allow DBNull.Value.", table.Rows [0].RowError, "#3");
2491                         Assert.AreEqual ("Column 'col2, col3' is constrained to be unique.  Value '1, 1' is already present."
2492                                         , table.Rows [1].RowError, "#4");
2493
2494                         Assert.AreEqual (table.Rows [0].RowError, table.Rows [0].GetColumnError (0), "#5");
2495                         Assert.AreEqual (table.Rows [1].RowError, table.Rows [0].GetColumnError (1), "#6");
2496                         Assert.AreEqual (table.Rows [1].RowError, table.Rows [0].GetColumnError (2), "#7");
2497
2498                         Assert.AreEqual ("", table.Rows [1].GetColumnError (0), "#8");
2499                         Assert.AreEqual (table.Rows [1].RowError, table.Rows [1].GetColumnError (1), "#9");
2500                         Assert.AreEqual (table.Rows [1].RowError, table.Rows [1].GetColumnError (2), "#10");
2501                 }
2502
2503                 [Test]
2504                 public void BeginEdit()
2505                 {
2506                         DataTable myTable = new DataTable("myTable");
2507                         DataColumn dc = new DataColumn("Id",typeof(int));
2508                         dc.Unique=true;
2509                         myTable.Columns.Add(dc);
2510                         myTable.Rows.Add(new object[] {1});
2511                         myTable.Rows.Add(new object[] {2});
2512                         myTable.Rows.Add(new object[] {3});
2513
2514                         DataRow myRow = myTable.Rows[0];
2515
2516                         try
2517                         {
2518                                 myRow[0] = 2; //row[0] now conflict with row[1]
2519                                 Assert.Fail("DRW121: failed to throw ConstraintException");
2520                         }
2521                         catch (ConstraintException) {}
2522                         catch (AssertionException exc) {throw  exc;}
2523                         catch (Exception exc)
2524                         {
2525                                 Assert.Fail("DRW122: Add. Wrong exception type. Got:" + exc);
2526                         }
2527
2528                         //Will NOT! throw exception
2529                         myRow.BeginEdit();
2530                         myRow[0] = 2; //row[0] now conflict with row[1]
2531
2532                         DataTable dt = DataProvider.CreateParentDataTable();
2533                         DataRow dr = dt.Rows[0];
2534                         dr.Delete();
2535                         try
2536                         {
2537                                 dr.BeginEdit();
2538                                 Assert.Fail("DRW123: failed to throw DeletedRowInaccessibleException");
2539                         }
2540                         catch (DeletedRowInaccessibleException) {}
2541                         catch (AssertionException exc) {throw  exc;}
2542                         catch (Exception exc)
2543                         {
2544                                 Assert.Fail("DRW124: Add. Wrong exception type. Got:" + exc);
2545                         }
2546                 }
2547
2548                 [Test]
2549                 public void GetChildRows_DataRelation()
2550                 {
2551                         DataRow dr;
2552                         DataRow[] drArrExcepted,drArrResult;
2553                         DataTable dtChild,dtParent;
2554                         DataSet ds = new DataSet();
2555
2556                         //Create tables
2557                         dtChild = DataProvider.CreateChildDataTable();
2558                         dtParent= DataProvider.CreateParentDataTable();
2559
2560                         //Add tables to dataset
2561                         ds.Tables.Add(dtChild);
2562                         ds.Tables.Add(dtParent);
2563                         dr = dtParent.Rows[0];
2564
2565                         //Add Relation
2566                         DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"]);
2567                         ds.Relations.Add(dRel);
2568                         //Get Excepted result
2569                         drArrExcepted = dtChild.Select("ParentId=" + dr["ParentId"]);
2570                         //Get Result
2571                         drArrResult = dr.GetChildRows(dRel);
2572
2573                         Assert.AreEqual(drArrExcepted, drArrResult, "DRW125");
2574                 }
2575
2576                 [Test]
2577                 public void GetParentRows_DataRelation_DataRowVersion()
2578                 {
2579                         DataRow drParent,drChild;
2580                         DataRow[] drArrExcepted,drArrResult;
2581                         DataTable dtChild,dtParent;
2582                         DataSet ds = new DataSet();
2583                         //Create tables
2584                         dtChild = DataProvider.CreateChildDataTable();
2585                         dtParent= DataProvider.CreateParentDataTable();
2586                         //Add tables to dataset
2587                         ds.Tables.Add(dtChild);
2588                         ds.Tables.Add(dtParent);
2589
2590                         drParent = dtParent.Rows[0];
2591                         drChild = dtChild.Select("ParentId=" + drParent["ParentId"])[0];
2592
2593                         //Duplicate several rows in order to create Many to Many relation
2594                         dtParent.ImportRow(drParent);
2595                         dtParent.ImportRow(drParent);
2596                         dtParent.ImportRow(drParent);
2597
2598                         //Add Relation
2599                         DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"],false);
2600                         ds.Relations.Add(dRel);
2601
2602                         //Get Excepted result
2603                         drArrExcepted = dtParent.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.CurrentRows );
2604                         //Get Result DataRowVersion.Current
2605                         drArrResult = drChild.GetParentRows(dRel,DataRowVersion.Current);
2606                         Assert.AreEqual(drArrExcepted, drArrResult, "DRW126");
2607
2608                         //Get Excepted result
2609                         drArrExcepted = dtParent.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.OriginalRows );
2610                         //Get Result DataRowVersion.Current
2611                         drArrResult = drChild.GetParentRows(dRel,DataRowVersion.Original );
2612                         Assert.AreEqual(drArrExcepted, drArrResult, "DRW127");
2613
2614                         //Get Excepted result, in this case Current = Default
2615                         drArrExcepted = dtParent.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.CurrentRows);
2616                         //Get Result DataRowVersion.Current
2617                         drArrResult = drChild.GetParentRows(dRel,DataRowVersion.Default  );
2618                         Assert.AreEqual(drArrExcepted, drArrResult, "DRW128");
2619
2620                         try
2621                         {
2622                                 DataTable dtOtherParent = DataProvider.CreateParentDataTable();
2623                                 DataTable dtOtherChild = DataProvider.CreateChildDataTable();
2624
2625                                 DataRelation drl = new DataRelation("newRelation",dtOtherParent.Columns[0],dtOtherChild.Columns[0]);
2626                                 drChild.GetParentRows(drl,DataRowVersion.Current);
2627                                 Assert.Fail("DRW129: failed to throw ArgumentException");
2628                         }
2629                         catch (ArgumentException) {}
2630                         catch (AssertionException exc) {throw  exc;}
2631                         catch (Exception exc)
2632                         {
2633                                 Assert.Fail("DRW130: Add. Wrong exception type. Got:" + exc);
2634                         }
2635                 }
2636
2637                 [Test]
2638                 public void ItemArray()
2639                 {
2640                         DataTable dt = GetDataTable();
2641                         DataRow dr = dt.Rows[0];
2642
2643                         Assert.AreEqual(1, (int)dr.ItemArray[0] , "DRW131" );
2644
2645                         Assert.AreEqual("Ofer", (string)dr.ItemArray[1] , "DRW132" );
2646
2647                         dt = GetDataTable();
2648
2649                         dr = dt.Rows[0];
2650
2651                         //Changing row via itemArray
2652
2653                         dt.Rows[0].ItemArray = new object[] {2,"Oren"};
2654
2655                         Assert.AreEqual(2, (Int32)dr.ItemArray[0] , "DRW133" );
2656                         Assert.AreEqual("Oren", (string)dr.ItemArray[1] , "DRW134" );
2657
2658                         try
2659                         {
2660                                 dt.Rows[0].ItemArray = new object[] {2,"Oren","some1else"};
2661                                 Assert.Fail("DRW135: failed to throw ArgumentException");
2662                         }
2663                         catch (ArgumentException) {}
2664                         catch (AssertionException exc) {throw  exc;}
2665                         catch (Exception exc)
2666                         {
2667                                 Assert.Fail("DRW136: Add. Wrong exception type. Got:" + exc);
2668                         }
2669                 }
2670
2671                 [Test]
2672                 public void ItemArray_NewTable ()
2673                 {
2674                         DataTable dt = new DataTable("Customers");
2675
2676                         dt.Columns.Add("name", typeof (string));
2677                         dt.Columns.Add("address", typeof (string));
2678                         dt.Columns.Add("phone", typeof (string));
2679
2680                         DataRow dr = dt.NewRow();
2681                         dr["name"] = "myName";
2682                         dr["address"] = "myAddress";
2683                         dr["phone"] = "myPhone";
2684
2685                         // Should not throw RowNotInTableException
2686                         object[] obj = dr.ItemArray;
2687                 }
2688
2689                 private DataTable GetDataTable()
2690                 {
2691                         DataTable dt = new DataTable("myTable");
2692                         dt.Columns.Add("Id",typeof(int));
2693                         dt.Columns.Add("Name",typeof(string));
2694
2695                         DataRow dr = dt.NewRow();
2696                         dr.ItemArray = new object[] {1,"Ofer"};
2697
2698                         dt.Rows.Add(dr);
2699
2700                         return dt;
2701                 }
2702
2703                 [Test]
2704                 public void RowError()
2705                 {
2706                         DataTable dt = new DataTable("myTable");
2707                         DataRow dr = dt.NewRow();
2708
2709                         Assert.AreEqual(string.Empty , dr.RowError, "DRW137");
2710
2711                         dr.RowError = "Err";
2712
2713                         Assert.AreEqual("Err", dr.RowError , "DRW138" );
2714
2715                         DataTable dt1 = DataProvider.CreateUniqueConstraint();
2716
2717                         try
2718                         {
2719                                 dt1.BeginLoadData();
2720
2721                                 dr = dt1.NewRow();
2722                                 dr[0] = 3;
2723                                 dt1.Rows.Add(dr);
2724                                 dt1.EndLoadData();
2725                                 Assert.Fail("DRW139: failed to throw ConstraintException");
2726                         }
2727                         catch (ConstraintException)
2728                         {
2729                                 Assert.AreEqual(2,dt1.GetErrors().Length,"DRW141");
2730                                 Assert.AreEqual(true,dt1.GetErrors()[0].RowError.Length > 10,"DRW142");
2731                                 Assert.AreEqual(true,dt1.GetErrors()[1].RowError.Length > 10,"DRW143");
2732                         }
2733                         catch (AssertionException exc) {throw  exc;}
2734                         catch (Exception exc)
2735                         {
2736                                 Assert.Fail("DRW144: Wrong exception type. Got:" + exc);
2737                         }
2738
2739
2740                         DataSet ds=null;
2741                         try
2742                         {
2743                                 ds= DataProvider.CreateForigenConstraint();
2744                                 ds.Tables[0].BeginLoadData();
2745                                 ds.Tables[0].Rows[0][0] = 10; //Forigen constraint violation
2746                                 //ds.Tables[0].AcceptChanges();
2747                                 ds.Tables[0].EndLoadData();
2748                                 Assert.Fail("DRW139: failed to throw ConstraintException");
2749                         }
2750                         catch (ConstraintException)
2751                         {
2752                                 Assert.AreEqual(3,ds.Tables[1].GetErrors().Length,"DRW145");
2753                                 for(int index=0;index<3;index++)
2754                                 {
2755                                         Assert.AreEqual(true,ds.Tables[1].GetErrors()[index].RowError.Length > 10,"RDW146");
2756                                 }
2757                         }
2758                         catch (AssertionException exc) {throw  exc;}
2759                         catch (Exception exc)
2760                         {
2761                                 Assert.Fail("DRW147: Wrong exception type. Got:" + exc);
2762                         }
2763                 }
2764
2765                 [Test]
2766                 public void bug78885 ()
2767                 {
2768                         DataSet ds = new DataSet ();
2769                         DataTable t = ds.Tables.Add ("table");
2770                         DataColumn id;
2771
2772                         id = t.Columns.Add ("userID", Type.GetType ("System.Int32"));
2773                         id.AutoIncrement = true;
2774                         t.Columns.Add ("name", Type.GetType ("System.String"));
2775                         t.Columns.Add ("address", Type.GetType ("System.String"));
2776                         t.Columns.Add ("zipcode", Type.GetType ("System.Int32"));
2777                         t.PrimaryKey = new DataColumn [] { id };
2778
2779                         DataRow tempRow;
2780                         tempRow = t.NewRow ();
2781                         tempRow ["name"] = "Joan";
2782                         tempRow ["address"] = "Balmes 152";
2783                         tempRow ["zipcode"] = "1";
2784                         t.Rows.Add (tempRow);
2785
2786                         t.RowChanged += new DataRowChangeEventHandler (RowChangedHandler);
2787
2788                         /* neither of the calls to EndEdit below generate a RowChangedHandler on MS.  the first one does on mono */
2789                         t.DefaultView [0].BeginEdit ();
2790                         t.DefaultView [0].EndEdit (); /* this generates a call to the row changed handler */
2791                         t.DefaultView [0].EndEdit (); /* this doesn't */
2792
2793                         Assert.IsFalse (_rowChanged);
2794                 }
2795
2796                 private void RowChangedHandler (object sender, DataRowChangeEventArgs e)
2797                 {
2798                         _rowChanged = true;
2799                 }
2800
2801 #if NET_2_0
2802                 string SetAddedModified_ErrMsg = "SetAdded and SetModified can only be called on DataRows with Unchanged DataRowState.";
2803                 [Test]
2804                 public void SetAdded_test()
2805                 {
2806                         DataTable table = new DataTable();
2807
2808                         DataRow row = table.NewRow();
2809                         try {
2810                                 row.SetAdded();
2811                                 Assert.Fail ("#1");
2812                         } catch (InvalidOperationException e) {
2813                                 // Never premise English.
2814                                 //Assert.AreEqual (SetAddedModified_ErrMsg, e.Message, "#2");
2815                         }
2816
2817                         table.Columns.Add("col1", typeof(int));
2818                         table.Columns.Add("col2", typeof(int));
2819                         table.Columns.Add("col3", typeof(int));
2820
2821                         row = table.Rows.Add(new object[] { 1, 2, 3 });
2822                         Assert.AreEqual(DataRowState.Added, row.RowState, "#1");
2823                         try {
2824                                 row.SetAdded();
2825                                 Assert.Fail ("#2");
2826                         } catch (InvalidOperationException e) {
2827                                 // Never premise English.
2828                                 //Assert.AreEqual (SetAddedModified_ErrMsg, e.Message, "#2");
2829                         }
2830                         Assert.AreEqual(DataRowState.Added, row.RowState, "#2");
2831
2832                         row.AcceptChanges();
2833                         row[0] = 10;
2834                         Assert.AreEqual(DataRowState.Modified, row.RowState, "#5");
2835                         try {
2836                                 row.SetAdded();
2837                                 Assert.Fail ("#3");
2838                         } catch (InvalidOperationException e) {
2839                                 // Never premise English.
2840                                 //Assert.AreEqual (SetAddedModified_ErrMsg, e.Message, "#2");
2841                         }
2842
2843                         row.AcceptChanges();
2844                         Assert.AreEqual(DataRowState.Unchanged, row.RowState, "#3");
2845                         row.SetAdded();
2846                         Assert.AreEqual(DataRowState.Added, row.RowState, "#4");
2847                 }
2848
2849                 [Test]
2850                 public void setAdded_testRollback ()
2851                 {
2852                         DataTable table = new DataTable ();
2853                         table.Columns.Add ("col1", typeof (int));
2854                         table.Columns.Add ("col2", typeof (int));
2855
2856                         table.Rows.Add (new object[] {1,1});
2857                         table.AcceptChanges ();
2858
2859                         table.Rows [0].SetAdded ();
2860                         table.RejectChanges ();
2861                         Assert.AreEqual (0, table.Rows.Count, "#1");
2862                 }
2863
2864                 [Test]
2865                 public void SetModified_test()
2866                 {
2867                         DataTable table = new DataTable();
2868
2869                         DataRow row = table.NewRow();
2870                         try {
2871                                 row.SetModified ();
2872                         } catch (InvalidOperationException) {}
2873
2874                         table.Columns.Add("col1", typeof(int));
2875                         table.Columns.Add("col2", typeof(int));
2876                         table.Columns.Add("col3", typeof(int));
2877
2878                         row = table.Rows.Add(new object[] { 1, 2, 3 });
2879                         Assert.AreEqual(DataRowState.Added, row.RowState, "#1");
2880                         try {
2881                                 row.SetModified();
2882                                 Assert.Fail ("#1");
2883                         } catch (InvalidOperationException e) {
2884                                 // Never premise English.
2885                                 //Assert.AreEqual (SetAddedModified_ErrMsg, e.Message, "#2");
2886                         }
2887
2888                         row.AcceptChanges();
2889                         row[0] = 10;
2890                         Assert.AreEqual(DataRowState.Modified, row.RowState, "#5");
2891                         try {
2892                                 row.SetModified ();
2893                                 Assert.Fail ("#2");
2894                         } catch (InvalidOperationException e) {
2895                                 // Never premise English.
2896                                 //Assert.AreEqual (SetAddedModified_ErrMsg, e.Message, "#2");
2897                         }
2898
2899                         row.AcceptChanges();
2900                         Assert.AreEqual(DataRowState.Unchanged, row.RowState, "#3");
2901                         row.SetModified ();
2902                         Assert.AreEqual(DataRowState.Modified, row.RowState, "#4");
2903                 }
2904
2905                 [Test]
2906                 public void setModified_testRollback()
2907                 {
2908                         DataTable table = new DataTable();
2909                         table.Columns.Add("col1", typeof(int));
2910                         table.Columns.Add("col2", typeof(int));
2911
2912                         DataRow row = table.Rows.Add(new object[] { 1, 1 });
2913                         table.AcceptChanges();
2914
2915                         row.SetModified ();
2916                         Assert.AreEqual(row.RowState, DataRowState.Modified, "#0");
2917                         Assert.AreEqual(1, row [0, DataRowVersion.Current], "#1");
2918                         Assert.AreEqual(1, row [0, DataRowVersion.Original], "#2");
2919                         table.RejectChanges ();
2920                         Assert.AreEqual(row.RowState, DataRowState.Unchanged, "#3");
2921                 }
2922 #endif
2923                 [Test]
2924                 public void DataRowExpressionDefaultValueTest ()
2925                 {
2926                         DataSet ds = new DataSet ();
2927                         DataTable custTable = ds.Tables.Add ("CustTable");
2928
2929                         DataColumn column = new DataColumn ("units", typeof (int));
2930                         column.AllowDBNull = false;
2931                         column.Caption = "Units";
2932                         column.DefaultValue = 1;
2933                         custTable.Columns.Add (column);
2934
2935                         column = new DataColumn ("price", typeof (decimal));
2936                         column.AllowDBNull = false;
2937                         column.Caption = "Price";
2938                         column.DefaultValue = 25;
2939                         custTable.Columns.Add (column);
2940
2941                         column = new DataColumn ("total", typeof (string));
2942                         column.Caption = "Total";
2943                         column.Expression = "price*units";
2944                         custTable.Columns.Add (column);
2945
2946                         DataRow row = custTable.NewRow ();
2947
2948                         Assert.AreEqual (DBNull.Value, row["Total"] , "#1 Should be System.DBNull");
2949                         custTable.Rows.Add (row);
2950
2951                         Assert.AreEqual ("25", row["Total"] , "#2 Should not be emptry string");
2952                 }
2953
2954                 void ColumnChanged (object sender, DataColumnChangeEventArgs e)
2955                 {
2956                         _eventsFired.Add (new EventInfo ("ColumnChanged", e));
2957                 }
2958
2959                 void ColumnChanging (object sender, DataColumnChangeEventArgs e)
2960                 {
2961                         _eventsFired.Add (new EventInfo ("ColumnChanging", e));
2962                 }
2963
2964                 class EventInfo
2965                 {
2966                         public EventInfo (string name, EventArgs args)
2967                         {
2968                                 this.name = name;
2969                                 this.args = args;
2970                         }
2971
2972                         public string Name {
2973                                 get { return name; }
2974                         }
2975
2976                         public EventArgs Args {
2977                                 get { return args; }
2978                         }
2979
2980                         private readonly string name;
2981                         private readonly EventArgs args;
2982                 }
2983
2984                 static bool AssertNotFound (DataRow rc, DataColumn dc, DataRowVersion version)
2985                 {
2986                         try {
2987                                 object value = rc [dc, version];
2988                                 return false;
2989                         } catch (VersionNotFoundException) {
2990                                 return true;
2991                         }
2992                 }
2993
2994                 class Person
2995                 {
2996                         public Person (string name)
2997                         {
2998                                 this.Name = name;
2999                         }
3000
3001                         public string Name;
3002                         public Address HomeAddress;
3003                 }
3004
3005                 struct Address
3006                 {
3007                         public Address (string street, int houseNumber)
3008                         {
3009                                 Street = street;
3010                                 HouseNumber = houseNumber;
3011                         }
3012
3013                         public override bool Equals (object o)
3014                         {
3015                                 if (!(o is Address))
3016                                         return false;
3017
3018                                 Address address = (Address) o;
3019                                 if (address.HouseNumber != HouseNumber)
3020                                         return false;
3021                                 if (address.Street != Street)
3022                                         return false;
3023                                 return true;
3024                         }
3025
3026                         public override int GetHashCode ()
3027                         {
3028                                 if (Street == null)
3029                                         return HouseNumber.GetHashCode ();
3030                                 return (Street.GetHashCode () ^ HouseNumber.GetHashCode ());
3031                         }
3032
3033                         public override string ToString ()
3034                         {
3035                                 if (Street == null)
3036                                         return HouseNumber.ToString (CultureInfo.InvariantCulture);
3037
3038                                 return string.Concat (Street, HouseNumber.ToString (CultureInfo.InvariantCulture));
3039                         }
3040
3041                         public string Street;
3042                         public int HouseNumber;
3043                 }
3044         }
3045 }