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 HasErrorsWithNullError()
 743                 {
 744                         DataTable dt = new DataTable("myTable");
 745                         DataRow dr = dt.NewRow();
 746
 747                         // HasErrors (default)
 748                         Assert.AreEqual(false, dr.HasErrors, "DRW47.2");
 749
 750                         dr.RowError = null;
 751
 752                         // HasErrors (set/get)
 753                         Assert.AreEqual(string.Empty , dr.RowError , "DRW48.2");
 754                         Assert.AreEqual(false , dr.HasErrors , "DRW49.2");
 755                 }
 756
 757                 [Test] public void HasVersion_ByDataRowVersion()
 758                 {
 759                         DataTable t = new DataTable("atable");
 760                         t.Columns.Add("id", typeof(int));
 761                         t.Columns.Add("name", typeof(string));
 762                         t.Columns[0].DefaultValue = 1;
 763                         t.Columns[1].DefaultValue = "something";
 764
 765                         // row r is detached
 766                         DataRow r = t.NewRow();
 767
 768                         // HasVersion Test #10
 769                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Current) , "DRW49");
 770
 771                         // HasVersion Test #11
 772                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Original) , "DRW50");
 773
 774                         // HasVersion Test #12
 775                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Default) , "DRW51");
 776
 777                         // HasVersion Test #13
 778                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Proposed) , "DRW52");
 779
 780                         r[0] = 4;
 781                         r[1] = "four";
 782
 783                         // HasVersion Test #20
 784                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Current) , "DRW53");
 785
 786                         // HasVersion Test #21
 787                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Original) , "DRW54");
 788
 789                         // HasVersion Test #22
 790                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Default) , "DRW55");
 791
 792                         // HasVersion Test #23
 793                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Proposed) , "DRW56");
 794
 795                         t.Rows.Add(r);
 796                         // now it is "added"
 797
 798                         // HasVersion Test #30
 799                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Current) , "DRW57");
 800
 801                         // HasVersion Test #31
 802                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Original) , "DRW58");
 803
 804                         // HasVersion Test #32
 805                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Default) , "DRW59");
 806
 807                         // HasVersion Test #33
 808                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Proposed) , "DRW60");
 809
 810                         t.AcceptChanges();
 811                         // now it is "unchanged"
 812
 813                         // HasVersion Test #40
 814                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Current) , "DRW61");
 815
 816                         // HasVersion Test #41
 817                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Original) , "DRW62");
 818
 819                         // HasVersion Test #42
 820                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Default) , "DRW63");
 821
 822                         // HasVersion Test #43
 823                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Proposed) , "DRW64");
 824
 825                         r.BeginEdit();
 826                         r[1] = "newvalue";
 827
 828                         // HasVersion Test #50
 829                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Current) , "DRW65");
 830
 831                         // HasVersion Test #51
 832                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Original) , "DRW66");
 833
 834                         // HasVersion Test #52
 835                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Default) , "DRW67");
 836
 837                         // HasVersion Test #53
 838                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Proposed) , "DRW68");
 839
 840                         r.EndEdit();
 841                         // now it is "modified"
 842                         // HasVersion Test #60
 843                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Current) , "DRW69");
 844
 845                         // HasVersion Test #61
 846                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Original) , "DRW70");
 847
 848                         // HasVersion Test #62
 849                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Default) , "DRW71");
 850
 851                         // HasVersion Test #63
 852                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Proposed) , "DRW72");
 853
 854                         // this or t.AcceptChanges
 855                         r.AcceptChanges();
 856                         // now it is "unchanged" again
 857                         // HasVersion Test #70
 858                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Current) , "DRW73");
 859
 860                         // HasVersion Test #71
 861                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Original) , "DRW74");
 862
 863                         // HasVersion Test #72
 864                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Default) , "DRW75");
 865
 866                         // HasVersion Test #73
 867                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Proposed) , "DRW76");
 868
 869                         r.Delete();
 870                         // now it is "deleted"
 871
 872                         // HasVersion Test #80
 873                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Current) , "DRW77");
 874
 875                         // HasVersion Test #81
 876                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Original) , "DRW78");
 877
 878                         // HasVersion Test #82
 879                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Default) , "DRW79");
 880
 881                         // HasVersion Test #83
 882                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Proposed) , "DRW80");
 883
 884                         r.AcceptChanges();
 885                         // back to detached
 886                         // HasVersion Test #90
 887                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Current) , "DRW81");
 888
 889                         // HasVersion Test #91
 890                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Original) , "DRW82");
 891
 892                         // HasVersion Test #92
 893                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Default) , "DRW83");
 894
 895                         // HasVersion Test #93
 896                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Proposed) , "DRW84");
 897                 }
 898
 899                 [Test] // Object this [DataColumn]
 900                 public void Indexer1 ()
 901                 {
 902                         EventInfo evt;
 903                         DataColumnChangeEventArgs colChangeArgs;
 904
 905                         DataTable dt = new DataTable ();
 906                         dt.ColumnChanged += new DataColumnChangeEventHandler (ColumnChanged);
 907                         dt.ColumnChanging += new DataColumnChangeEventHandler (ColumnChanging);
 908
 909                         DataColumn dc0 = new DataColumn ("Col0", typeof (Address));
 910                         dt.Columns.Add (dc0);
 911                         DataColumn dc1 = new DataColumn ("Col1", typeof (Person));
 912                         dt.Columns.Add (dc1);
 913
 914                         Person personA = new Person ("Miguel");
 915                         Address addressA = new Address ("X", 5);
 916                         Person personB = new Person ("Chris");
 917                         Address addressB = new Address ("Y", 4);
 918                         Person personC = new Person ("Jackson");
 919                         Address addressC = new Address ("Z", 3);
 920
 921                         dt.Rows.Add (new object [] { addressA, personA });
 922                         dt.Rows.Add (new object [] { addressB, personB });
 923                         DataRow dr;
 924
 925                         dr = dt.Rows [0];
 926                         Assert.AreEqual (addressA, dr [dc0], "#A1");
 927                         Assert.AreSame (personA, dr [dc1], "#A2");
 928
 929                         dr = dt.Rows [1];
 930                         Assert.AreEqual (addressB, dr [dc0], "#B1");
 931                         Assert.AreSame (personB, dr [dc1], "#B2");
 932
 933                         dr = dt.Rows [0];
 934                         Assert.AreEqual (0, _eventsFired.Count, "#C1");
 935                         dr [dc0] = addressC;
 936                         Assert.AreEqual (2, _eventsFired.Count, "#C2");
 937                         Assert.AreEqual (addressC, dr [dc0], "#C3");
 938                         Assert.AreSame (personA, dr [dc1], "#C4");
 939
 940                         dr = dt.Rows [1];
 941                         dr.BeginEdit ();
 942                         Assert.AreEqual (2, _eventsFired.Count, "#D1");
 943                         dr [dc1] = personC;
 944                         Assert.AreEqual (4, _eventsFired.Count, "#D2");
 945                         Assert.AreEqual (addressB, dr [dc0], "#D3");
 946                         Assert.AreSame (personC, dr [dc1], "#D4");
 947                         dr.EndEdit ();
 948                         Assert.AreEqual (4, _eventsFired.Count, "#D5");
 949                         Assert.AreEqual (addressB, dr [dc0], "#D6");
 950                         Assert.AreSame (personC, dr [dc1], "#D7");
 951
 952                         dr = dt.Rows [0];
 953                         dr.BeginEdit ();
 954                         Assert.AreEqual (4, _eventsFired.Count, "#E1");
 955                         dr [dc0] = addressB;
 956                         Assert.AreEqual (6, _eventsFired.Count, "#E2");
 957                         Assert.AreEqual (addressB, dr [dc0], "#E3");
 958                         Assert.AreSame (personA, dr [dc1], "#E4");
 959                         dr.CancelEdit ();
 960                         Assert.AreEqual (6, _eventsFired.Count, "#E5");
 961                         Assert.AreEqual (addressC, dr [dc0], "#E6");
 962                         Assert.AreSame (personA, dr [dc1], "#E7");
 963
 964                         evt = (EventInfo) _eventsFired [0];
 965                         Assert.AreEqual ("ColumnChanging", evt.Name, "#F1");
 966                         colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
 967                         Assert.AreSame (dc0, colChangeArgs.Column, "#F2");
 968                         Assert.AreEqual (addressC, colChangeArgs.ProposedValue, "#F3");
 969                         Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#F4");
 970
 971                         evt = (EventInfo) _eventsFired [1];
 972                         Assert.AreEqual ("ColumnChanged", evt.Name, "#G1");
 973                         colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
 974                         Assert.AreSame (dc0, colChangeArgs.Column, "#G2");
 975                         Assert.AreEqual (addressC, colChangeArgs.ProposedValue, "#G3");
 976                         Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#G4");
 977
 978                         evt = (EventInfo) _eventsFired [2];
 979                         Assert.AreEqual ("ColumnChanging", evt.Name, "#H1");
 980                         colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
 981                         Assert.AreSame (dc1, colChangeArgs.Column, "#H2");
 982                         Assert.AreEqual (personC, colChangeArgs.ProposedValue, "#H3");
 983                         Assert.AreSame (dt.Rows [1], colChangeArgs.Row, "#H4");
 984
 985                         evt = (EventInfo) _eventsFired [3];
 986                         Assert.AreEqual ("ColumnChanged", evt.Name, "#I1");
 987                         colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
 988                         Assert.AreSame (dc1, colChangeArgs.Column, "#I2");
 989                         Assert.AreEqual (personC, colChangeArgs.ProposedValue, "#I3");
 990                         Assert.AreSame (dt.Rows [1], colChangeArgs.Row, "#I4");
 991
 992                         evt = (EventInfo) _eventsFired [4];
 993                         Assert.AreEqual ("ColumnChanging", evt.Name, "#J1");
 994                         colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
 995                         Assert.AreSame (dc0, colChangeArgs.Column, "#J2");
 996                         Assert.AreEqual (addressB, colChangeArgs.ProposedValue, "#J3");
 997                         Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#J4");
 998
 999                         evt = (EventInfo) _eventsFired [5];
1000                         Assert.AreEqual ("ColumnChanged", evt.Name, "#K1");
1001                         colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
1002                         Assert.AreSame (dc0, colChangeArgs.Column, "#K2");
1003                         Assert.AreEqual (addressB, colChangeArgs.ProposedValue, "#K3");
1004                         Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#K4");
1005                 }
1006
1007                 [Test] // Object this [DataColumn]
1008                 public void Indexer1_Column_NotInTable ()
1009                 {
1010                         EventInfo evt;
1011                         DataColumnChangeEventArgs colChangeArgs;
1012
1013                         DataTable dtA = new DataTable ("TableA");
1014                         dtA.ColumnChanged += new DataColumnChangeEventHandler (ColumnChanged);
1015                         dtA.ColumnChanging += new DataColumnChangeEventHandler (ColumnChanging);
1016                         DataColumn dcA1 = new DataColumn ("Col0", typeof (Address));
1017                         dtA.Columns.Add (dcA1);
1018                         DataColumn dcA2 = new DataColumn ("Col1", typeof (Person));
1019                         dtA.Columns.Add (dcA2);
1020
1021                         DataTable dtB = new DataTable ("TableB");
1022                         dtB.ColumnChanged += new DataColumnChangeEventHandler (ColumnChanged);
1023                         dtB.ColumnChanging += new DataColumnChangeEventHandler (ColumnChanging);
1024                         DataColumn dcB1 = new DataColumn ("Col0", typeof (Address));
1025                         dtB.Columns.Add (dcB1);
1026                         DataColumn dcB2 = new DataColumn ("Col1", typeof (Person));
1027                         dtB.Columns.Add (dcB2);
1028
1029                         Person personA = new Person ("Miguel");
1030                         Address addressA = new Address ("X", 5);
1031
1032                         dtA.Rows.Add (new object [] { addressA, personA });
1033                         DataRow dr = dtA.Rows [0];
1034
1035                         try {
1036                                 object value = dr [dcB1];
1037                                 Assert.Fail ("#A1:" + value);
1038                         } catch (ArgumentException ex) {
1039                                 // Column 'Col0' does not belong to table TableA
1040                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
1041                                 Assert.IsNull (ex.InnerException, "#A3");
1042                                 Assert.IsNotNull (ex.Message, "#A4");
1043                                 Assert.IsTrue (ex.Message.IndexOf ("'Col0'") != -1, "#A5");
1044                                 Assert.IsTrue (ex.Message.IndexOf ("TableA") != -1, "#A6");
1045                         }
1046
1047                         try {
1048                                 object value = dr [new DataColumn ("ZZZ")];
1049                                 Assert.Fail ("#B1:" + value);
1050                         } catch (ArgumentException ex) {
1051                                 // Column 'Col0' does not belong to table TableA
1052                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1053                                 Assert.IsNull (ex.InnerException, "#B3");
1054                                 Assert.IsNotNull (ex.Message, "#B4");
1055                                 Assert.IsTrue (ex.Message.IndexOf ("'ZZZ'") != -1, "#B5");
1056                                 Assert.IsTrue (ex.Message.IndexOf ("TableA") != -1, "#B6");
1057                         }
1058
1059                         dtA.Columns.Remove (dcA2);
1060
1061                         try {
1062                                 object value = dr [dcA2];
1063                                 Assert.Fail ("#C1:" + value);
1064                         } catch (ArgumentException ex) {
1065                                 // Column 'Col0' does not belong to table TableA
1066                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
1067                                 Assert.IsNull (ex.InnerException, "#C3");
1068                                 Assert.IsNotNull (ex.Message, "#C4");
1069                                 Assert.IsTrue (ex.Message.IndexOf ("'Col1'") != -1, "#C5");
1070                                 Assert.IsTrue (ex.Message.IndexOf ("TableA") != -1, "#C6");
1071                         }
1072                 }
1073
1074                 [Test] // Object this [DataColumn]
1075                 public void Indexer1_Column_Null ()
1076                 {
1077                         EventInfo evt;
1078                         DataColumnChangeEventArgs colChangeArgs;
1079
1080                         DataTable dt = new DataTable ();
1081                         dt.ColumnChanged += new DataColumnChangeEventHandler (ColumnChanged);
1082                         dt.ColumnChanging += new DataColumnChangeEventHandler (ColumnChanging);
1083                         DataColumn dc0 = new DataColumn ("Col0", typeof (Address));
1084                         dt.Columns.Add (dc0);
1085                         DataColumn dc1 = new DataColumn ("Col1", typeof (Person));
1086                         dt.Columns.Add (dc1);
1087
1088                         Person personA = new Person ("Miguel");
1089                         Address addressA = new Address ("X", 5);
1090                         Person personB = new Person ("Chris");
1091
1092                         dt.Rows.Add (new object [] { addressA, personA });
1093                         DataRow dr = dt.Rows [0];
1094
1095                         try {
1096                                 object value = dr [(DataColumn) null];
1097                                 Assert.Fail ("#A1:" + value);
1098                         } catch (ArgumentNullException ex) {
1099                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
1100                                 Assert.IsNull (ex.InnerException, "#A3");
1101                                 Assert.IsNotNull (ex.Message, "#A4");
1102                                 Assert.AreEqual ("column", ex.ParamName, "#A5");
1103                         }
1104
1105                         try {
1106                                 dr [(DataColumn) null] = personB;
1107                                 Assert.Fail ("#B1");
1108                         } catch (ArgumentNullException ex) {
1109                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
1110                                 Assert.IsNull (ex.InnerException, "#B3");
1111                                 Assert.IsNotNull (ex.Message, "#B4");
1112                                 Assert.AreEqual ("column", ex.ParamName, "#B5");
1113                         }
1114
1115                         Assert.AreEqual (0, _eventsFired.Count, "#C");
1116                 }
1117
1118                 [Test] // Object this [DataColumn]
1119                 public void Indexer1_Value_Null ()
1120                 {
1121                         EventInfo evt;
1122                         DataColumnChangeEventArgs colChangeArgs;
1123
1124                         DataTable dt = new DataTable ();
1125                         dt.ColumnChanged += new DataColumnChangeEventHandler (ColumnChanged);
1126                         dt.ColumnChanging += new DataColumnChangeEventHandler (ColumnChanging);
1127                         DataColumn dc0 = new DataColumn ("Col0", typeof (Address));
1128                         dt.Columns.Add (dc0);
1129                         DataColumn dc1 = new DataColumn ("Col1", typeof (Person));
1130                         dt.Columns.Add (dc1);
1131                         DataColumn dc2 = new DataColumn ("Col2", typeof (string));
1132                         dt.Columns.Add (dc2);
1133
1134                         Person personA = new Person ("Miguel");
1135                         Address addressA = new Address ("X", 5);
1136                         string countryA = "U.S.";
1137                         Person personB = new Person ("Chris");
1138                         Address addressB = new Address ("Y", 4);
1139                         string countryB = "Canada";
1140                         Person personC = new Person ("Jackson");
1141                         Address addressC = new Address ("Z", 3);
1142
1143                         dt.Rows.Add (new object [] { addressA, personA, countryA });
1144                         dt.Rows.Add (new object [] { addressB, personB, countryB });
1145
1146                         DataRow dr = dt.Rows [0];
1147
1148                         try {
1149                                 dr [dc0] = null;
1150                                 Assert.Fail ("#A1");
1151                         } catch (ArgumentException ex) {
1152                                 // Cannot set Column 'Col0' to be null.
1153                                 // Please use DBNull instead
1154                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
1155                                 Assert.IsNull (ex.InnerException, "#A3");
1156                                 Assert.IsNotNull (ex.Message, "#A4");
1157                                 Assert.IsTrue (ex.Message.IndexOf ("'Col0'") != -1, "#A5");
1158                                 Assert.IsTrue (ex.Message.IndexOf ("DBNull") != -1, "#A6");
1159                         }
1160
1161                         Assert.AreEqual (1, _eventsFired.Count, "#B1");
1162                         Assert.AreEqual (addressA, dr [dc0], "#B2");
1163                         Assert.IsFalse (dr.IsNull (dc0), "#B3");
1164                         Assert.AreSame (personA, dr [dc1], "#B4");
1165                         Assert.IsFalse (dr.IsNull (dc1), "#B5");
1166                         Assert.AreEqual (1, _eventsFired.Count, "#B6");
1167
1168 #if NET_2_0
1169                         dr [dc1] = null;
1170 #else
1171                         try {
1172                                 dr [dc1] = null;
1173                                 Assert.Fail ("#B1");
1174                         } catch (ArgumentException ex) {
1175                                 // Cannot set Column 'Col1' to be null.
1176                                 // Please use DBNull instead
1177                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1178                                 Assert.IsNull (ex.InnerException, "#B3");
1179                                 Assert.IsNotNull (ex.Message, "#B4");
1180                                 Assert.IsTrue (ex.Message.IndexOf ("'Col1'") != -1, "#B5");
1181                                 Assert.IsTrue (ex.Message.IndexOf ("DBNull") != -1, "#B6");
1182                                 Assert.AreEqual (2, _eventsFired.Count, "#B7");
1183                         }
1184                         dr [dc1] = DBNull.Value;
1185 #endif
1186
1187 #if NET_2_0
1188                         Assert.AreEqual (3, _eventsFired.Count, "#C1");
1189 #else
1190                         Assert.AreEqual (4, _eventsFired.Count, "#C1");
1191 #endif
1192                         Assert.AreEqual (addressA, dr [dc0], "#C2");
1193                         Assert.IsFalse (dr.IsNull (dc0), "#C3");
1194                         Assert.AreSame (DBNull.Value, dr [dc1], "#C4");
1195                         Assert.IsTrue (dr.IsNull (dc1), "#C5");
1196 #if NET_2_0
1197                         Assert.AreEqual (3, _eventsFired.Count, "#C6");
1198 #else
1199                         Assert.AreEqual (4, _eventsFired.Count, "#C6");
1200 #endif
1201
1202                         dr [dc0] = DBNull.Value;
1203 #if NET_2_0
1204                         Assert.AreEqual (5, _eventsFired.Count, "#D1");
1205 #else
1206                         Assert.AreEqual (6, _eventsFired.Count, "#D1");
1207 #endif
1208                         Assert.AreSame (DBNull.Value, dr [dc0], "#D2");
1209                         Assert.IsTrue (dr.IsNull (dc0), "#D3");
1210                         Assert.AreSame (DBNull.Value, dr [dc1], "#D4");
1211                         Assert.IsTrue (dr.IsNull (dc1), "#D5");
1212 #if NET_2_0
1213                         Assert.AreEqual (5, _eventsFired.Count, "#D6");
1214 #else
1215                         Assert.AreEqual (6, _eventsFired.Count, "#D6");
1216 #endif
1217
1218                         dr.BeginEdit ();
1219                         dr [dc1] = personC;
1220 #if NET_2_0
1221                         Assert.AreEqual (7, _eventsFired.Count, "#E1");
1222 #else
1223                         Assert.AreEqual (8, _eventsFired.Count, "#E1");
1224 #endif
1225                         Assert.AreSame (DBNull.Value, dr [dc0], "#E2");
1226                         Assert.IsTrue (dr.IsNull (dc0), "#E3");
1227                         Assert.AreEqual (personC, dr [dc1], "#E4");
1228                         Assert.IsFalse (dr.IsNull (dc1), "#E5");
1229                         dr.EndEdit ();
1230                         Assert.AreSame (DBNull.Value, dr [dc0], "#E6");
1231                         Assert.IsTrue (dr.IsNull (dc0), "#E7");
1232                         Assert.AreEqual (personC, dr [dc1], "#E8");
1233                         Assert.IsFalse (dr.IsNull (dc1), "#E9");
1234 #if NET_2_0
1235                         Assert.AreEqual (7, _eventsFired.Count, "#E10");
1236 #else
1237                         Assert.AreEqual (8, _eventsFired.Count, "#E10");
1238 #endif
1239
1240                         dr [dc1] = DBNull.Value;
1241 #if NET_2_0
1242                         Assert.AreEqual (9, _eventsFired.Count, "#F1");
1243 #else
1244                         Assert.AreEqual (10, _eventsFired.Count, "#F1");
1245 #endif
1246                         Assert.AreSame (DBNull.Value, dr [dc0], "#F2");
1247                         Assert.IsTrue (dr.IsNull (dc0), "#F3");
1248                         Assert.AreSame (DBNull.Value, dr [dc1], "#F4");
1249                         Assert.IsTrue (dr.IsNull (dc1), "#F5");
1250 #if NET_2_0
1251                         Assert.AreEqual (9, _eventsFired.Count, "#F6");
1252 #else
1253                         Assert.AreEqual (10, _eventsFired.Count, "#F6");
1254 #endif
1255
1256                         dr [dc2] = null;
1257 #if NET_2_0
1258                         Assert.AreEqual (11, _eventsFired.Count, "#G1");
1259 #else
1260                         Assert.AreEqual (12, _eventsFired.Count, "#G1");
1261 #endif
1262                         Assert.AreSame (DBNull.Value, dr [dc0], "#G2");
1263                         Assert.IsTrue (dr.IsNull (dc0), "#G3");
1264                         Assert.AreSame (DBNull.Value, dr [dc1], "#G4");
1265                         Assert.IsTrue (dr.IsNull (dc1), "#G5");
1266                         Assert.AreSame (DBNull.Value, dr [dc2], "#G6");
1267                         Assert.IsTrue (dr.IsNull (dc2), "#G7");
1268 #if NET_2_0
1269                         Assert.AreEqual (11, _eventsFired.Count, "#G8");
1270 #else
1271                         Assert.AreEqual (12, _eventsFired.Count, "#G8");
1272 #endif
1273
1274                         dr [dc2] = DBNull.Value;
1275 #if NET_2_0
1276                         Assert.AreEqual (13, _eventsFired.Count, "#H1");
1277 #else
1278                         Assert.AreEqual (14, _eventsFired.Count, "#H1");
1279 #endif
1280                         Assert.AreSame (DBNull.Value, dr [dc0], "#H2");
1281                         Assert.IsTrue (dr.IsNull (dc0), "#H3");
1282                         Assert.AreSame (DBNull.Value, dr [dc1], "#H4");
1283                         Assert.IsTrue (dr.IsNull (dc1), "#H5");
1284                         Assert.AreSame (DBNull.Value, dr [dc2], "#H6");
1285                         Assert.IsTrue (dr.IsNull (dc2), "#H7");
1286 #if NET_2_0
1287                         Assert.AreEqual (13, _eventsFired.Count, "#H8");
1288 #else
1289                         Assert.AreEqual (14, _eventsFired.Count, "#H8");
1290 #endif
1291
1292                         int index = 0;
1293
1294                         evt = (EventInfo) _eventsFired [index++];
1295                         Assert.AreEqual ("ColumnChanging", evt.Name, "#I1");
1296                         colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
1297                         Assert.AreSame (dc0, colChangeArgs.Column, "#I2");
1298                         Assert.IsNull (colChangeArgs.ProposedValue, "#I3");
1299                         Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#I4");
1300
1301                         evt = (EventInfo) _eventsFired [index++];
1302                         Assert.AreEqual ("ColumnChanging", evt.Name, "#J1");
1303                         colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
1304                         Assert.AreSame (dc1, colChangeArgs.Column, "#J2");
1305                         Assert.IsNull (colChangeArgs.ProposedValue, "#J3");
1306                         Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#J4");
1307
1308 #if ONLY_1_1
1309                         evt = (EventInfo) _eventsFired [index++];
1310                         Assert.AreEqual ("ColumnChanging", evt.Name, "#K1");
1311                         colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
1312                         Assert.AreSame (dc1, colChangeArgs.Column, "#K2");
1313                         Assert.AreSame (DBNull.Value, colChangeArgs.ProposedValue, "#K3");
1314                         Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#K4");
1315 #endif
1316
1317                         evt = (EventInfo) _eventsFired [index++];
1318                         Assert.AreEqual ("ColumnChanged", evt.Name, "#L1");
1319                         colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
1320                         Assert.AreSame (dc1, colChangeArgs.Column, "#L2");
1321 #if NET_2_0
1322                         Assert.IsNull (colChangeArgs.ProposedValue, "#L3");
1323 #else
1324                         Assert.AreSame (DBNull.Value, colChangeArgs.ProposedValue, "#L3");
1325 #endif
1326                         Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#L4");
1327
1328                         evt = (EventInfo) _eventsFired [index++];
1329                         Assert.AreEqual ("ColumnChanging", evt.Name, "#M1");
1330                         colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
1331                         Assert.AreSame (dc0, colChangeArgs.Column, "#M2");
1332                         Assert.AreSame (DBNull.Value, colChangeArgs.ProposedValue, "#M3");
1333                         Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#M4");
1334
1335                         evt = (EventInfo) _eventsFired [index++];
1336                         Assert.AreEqual ("ColumnChanged", evt.Name, "#N1");
1337                         colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
1338                         Assert.AreSame (dc0, colChangeArgs.Column, "#N2");
1339                         Assert.AreSame (DBNull.Value, colChangeArgs.ProposedValue, "#N3");
1340                         Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#N4");
1341
1342                         evt = (EventInfo) _eventsFired [index++];
1343                         Assert.AreEqual ("ColumnChanging", evt.Name, "#O1");
1344                         colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
1345                         Assert.AreSame (dc1, colChangeArgs.Column, "#O2");
1346                         Assert.AreSame (personC, colChangeArgs.ProposedValue, "#O3");
1347                         Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#O4");
1348
1349                         evt = (EventInfo) _eventsFired [index++];
1350                         Assert.AreEqual ("ColumnChanged", evt.Name, "#P1");
1351                         colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
1352                         Assert.AreSame (dc1, colChangeArgs.Column, "#P2");
1353                         Assert.AreSame (personC, colChangeArgs.ProposedValue, "#P3");
1354                         Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#P4");
1355
1356                         evt = (EventInfo) _eventsFired [index++];
1357                         Assert.AreEqual ("ColumnChanging", evt.Name, "#Q1");
1358                         colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
1359                         Assert.AreSame (dc1, colChangeArgs.Column, "#Q2");
1360                         Assert.AreSame (DBNull.Value, colChangeArgs.ProposedValue, "#Q3");
1361                         Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#Q4");
1362
1363                         evt = (EventInfo) _eventsFired [index++];
1364                         Assert.AreEqual ("ColumnChanged", evt.Name, "#R1");
1365                         colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
1366                         Assert.AreSame (dc1, colChangeArgs.Column, "#R2");
1367                         Assert.AreSame (DBNull.Value, colChangeArgs.ProposedValue, "#R3");
1368                         Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#R4");
1369
1370                         evt = (EventInfo) _eventsFired [index++];
1371                         Assert.AreEqual ("ColumnChanging", evt.Name, "#S1");
1372                         colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
1373                         Assert.AreSame (dc2, colChangeArgs.Column, "#S2");
1374                         Assert.IsNull (colChangeArgs.ProposedValue, "#S3");
1375                         Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#S4");
1376
1377                         evt = (EventInfo) _eventsFired [index++];
1378                         Assert.AreEqual ("ColumnChanged", evt.Name, "#T1");
1379                         colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
1380                         Assert.AreSame (dc2, colChangeArgs.Column, "#T2");
1381                         Assert.IsNull (colChangeArgs.ProposedValue, "#T3");
1382                         Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#T4");
1383
1384                         evt = (EventInfo) _eventsFired [index++];
1385                         Assert.AreEqual ("ColumnChanging", evt.Name, "#U1");
1386                         colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
1387                         Assert.AreSame (dc2, colChangeArgs.Column, "#U2");
1388                         Assert.AreSame (DBNull.Value, colChangeArgs.ProposedValue, "#U3");
1389                         Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#U4");
1390
1391                         evt = (EventInfo) _eventsFired [index++];
1392                         Assert.AreEqual ("ColumnChanged", evt.Name, "#V1");
1393                         colChangeArgs = (DataColumnChangeEventArgs) evt.Args;
1394                         Assert.AreSame (dc2, colChangeArgs.Column, "#V2");
1395                         Assert.AreSame (DBNull.Value, colChangeArgs.ProposedValue, "#V3");
1396                         Assert.AreSame (dt.Rows [0], colChangeArgs.Row, "#V4");
1397                 }
1398
1399                 [Test] // Object this [Int32]
1400                 public void Indexer2 ()
1401                 {
1402                         DataTable dt = new DataTable ();
1403                         DataColumn dc0 = new DataColumn ("Col0", typeof (Address));
1404                         dt.Columns.Add (dc0);
1405                         DataColumn dc1 = new DataColumn ("Col1", typeof (Person));
1406                         dt.Columns.Add (dc1);
1407
1408                         Person personA = new Person ("Miguel");
1409                         Address addressA = new Address ("X", 5);
1410                         Person personB = new Person ("Chris");
1411                         Address addressB = new Address ("Y", 4);
1412                         Person personC = new Person ("Jackson");
1413                         Address addressC = new Address ("Z", 3);
1414
1415                         dt.Rows.Add (new object [] { addressA, personA });
1416                         dt.Rows.Add (new object [] { addressB, personB });
1417                         DataRow dr;
1418
1419                         dr = dt.Rows [0];
1420                         Assert.AreEqual (addressA, dr [0], "#A1");
1421                         Assert.AreSame (personA, dr [1], "#A2");
1422
1423                         dr = dt.Rows [1];
1424                         Assert.AreEqual (addressB, dr [0], "#B1");
1425                         Assert.AreSame (personB, dr [1], "#B2");
1426
1427                         dr = dt.Rows [0];
1428                         dr [0] = addressC;
1429                         Assert.AreEqual (addressC, dr [0], "#C1");
1430                         Assert.AreSame (personA, dr [1], "#C2");
1431
1432                         dr = dt.Rows [1];
1433                         dr.BeginEdit ();
1434                         dr [1] = personC;
1435                         Assert.AreEqual (addressB, dr [0], "#D1");
1436                         Assert.AreSame (personC, dr [1], "#D2");
1437                         dr.EndEdit ();
1438                         Assert.AreEqual (addressB, dr [0], "#D3");
1439                         Assert.AreSame (personC, dr [1], "#D4");
1440
1441                         dr = dt.Rows [0];
1442                         dr.BeginEdit ();
1443                         dr [0] = addressB;
1444                         Assert.AreEqual (addressB, dr [0], "#E1");
1445                         Assert.AreSame (personA, dr [1], "#E2");
1446                         dr.CancelEdit ();
1447                         Assert.AreEqual (addressC, dr [0], "#E3");
1448                         Assert.AreSame (personA, dr [1], "#E4");
1449                 }
1450
1451                 [Test] // Object this [Int32]
1452                 public void Indexer2_Value_Null ()
1453                 {
1454                         DataTable dt = new DataTable ();
1455                         DataColumn dc0 = new DataColumn ("Col0", typeof (Address));
1456                         dt.Columns.Add (dc0);
1457                         DataColumn dc1 = new DataColumn ("Col1", typeof (Person));
1458                         dt.Columns.Add (dc1);
1459
1460                         Person personA = new Person ("Miguel");
1461                         Address addressA = new Address ("X", 5);
1462                         Person personB = new Person ("Chris");
1463                         Address addressB = new Address ("Y", 4);
1464                         Person personC = new Person ("Jackson");
1465                         Address addressC = new Address ("Z", 3);
1466
1467                         dt.Rows.Add (new object [] { addressA, personA });
1468                         dt.Rows.Add (new object [] { addressB, personB });
1469
1470                         DataRow dr = dt.Rows [0];
1471
1472                         try {
1473                                 dr [0] = null;
1474                                 Assert.Fail ("#A1");
1475                         } catch (ArgumentException ex) {
1476                                 // Cannot set Column 'Col0' to be null.
1477                                 // Please use DBNull instead
1478                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
1479                                 Assert.IsNull (ex.InnerException, "#A3");
1480                                 Assert.IsNotNull (ex.Message, "#A4");
1481                                 Assert.IsTrue (ex.Message.IndexOf ("'Col0'") != -1, "#A5");
1482                                 Assert.IsTrue (ex.Message.IndexOf ("DBNull") != -1, "#A6");
1483                         }
1484
1485                         Assert.AreEqual (addressA, dr [0], "#B1");
1486                         Assert.IsFalse (dr.IsNull (0), "#B2");
1487                         Assert.AreSame (personA, dr [1], "#B3");
1488                         Assert.IsFalse (dr.IsNull (1), "#B4");
1489
1490 #if NET_2_0
1491                         dr [1] = null;
1492 #else
1493                         try {
1494                                 dr [1] = null;
1495                                 Assert.Fail ("#B1");
1496                         } catch (ArgumentException ex) {
1497                                 // Cannot set Column 'Col1' to be null.
1498                                 // Please use DBNull instead
1499                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1500                                 Assert.IsNull (ex.InnerException, "#B3");
1501                                 Assert.IsNotNull (ex.Message, "#B4");
1502                                 Assert.IsTrue (ex.Message.IndexOf ("'Col1'") != -1, "#B5");
1503                                 Assert.IsTrue (ex.Message.IndexOf ("DBNull") != -1, "#B6");
1504                         }
1505                         dr [1] = DBNull.Value;
1506 #endif
1507
1508                         Assert.AreEqual (addressA, dr [0], "#C1");
1509                         Assert.IsFalse (dr.IsNull (0), "#C2");
1510                         Assert.AreSame (DBNull.Value, dr [1], "#C3");
1511                         Assert.IsTrue (dr.IsNull (1), "#C4");
1512
1513                         dr [0] = DBNull.Value;
1514
1515                         Assert.AreSame (DBNull.Value, dr [0], "#D1");
1516                         Assert.IsTrue (dr.IsNull (0), "#D2");
1517                         Assert.AreSame (DBNull.Value, dr [1], "#D3");
1518                         Assert.IsTrue (dr.IsNull (1), "#D4");
1519
1520                         dr.BeginEdit ();
1521                         dr [1] = personC;
1522                         Assert.AreSame (DBNull.Value, dr [0], "#E1");
1523                         Assert.IsTrue (dr.IsNull (0), "#E2");
1524                         Assert.AreEqual (personC, dr [1], "#E3");
1525                         Assert.IsFalse (dr.IsNull (1), "#E4");
1526                         dr.EndEdit ();
1527                         Assert.AreSame (DBNull.Value, dr [0], "#E5");
1528                         Assert.IsTrue (dr.IsNull (0), "#E6");
1529                         Assert.AreEqual (personC, dr [1], "#E7");
1530                         Assert.IsFalse (dr.IsNull (1), "#E8");
1531
1532                         dr [1] = DBNull.Value;
1533
1534                         Assert.AreSame (DBNull.Value, dr [0], "#F1");
1535                         Assert.IsTrue (dr.IsNull (0), "#F2");
1536                         Assert.AreSame (DBNull.Value, dr [1], "#F3");
1537                         Assert.IsTrue (dr.IsNull (1), "#F4");
1538                 }
1539
1540                 [Test] // Object this [String]
1541                 public void Indexer3 ()
1542                 {
1543                         DataTable dt = new DataTable ();
1544                         DataColumn dc0 = new DataColumn ("Col0", typeof (Address));
1545                         dt.Columns.Add (dc0);
1546                         DataColumn dc1 = new DataColumn ("Col1", typeof (Person));
1547                         dt.Columns.Add (dc1);
1548
1549                         Person personA = new Person ("Miguel");
1550                         Address addressA = new Address ("X", 5);
1551                         Person personB = new Person ("Chris");
1552                         Address addressB = new Address ("Y", 4);
1553                         Person personC = new Person ("Jackson");
1554                         Address addressC = new Address ("Z", 3);
1555
1556                         dt.Rows.Add (new object [] { addressA, personA });
1557                         dt.Rows.Add (new object [] { addressB, personB });
1558                         DataRow dr;
1559
1560                         dr = dt.Rows [0];
1561                         Assert.AreEqual (addressA, dr ["Col0"], "#A1");
1562                         Assert.AreSame (personA, dr ["Col1"], "#A2");
1563
1564                         dr = dt.Rows [1];
1565                         Assert.AreEqual (addressB, dr ["Col0"], "#B1");
1566                         Assert.AreSame (personB, dr ["Col1"], "#B2");
1567
1568                         dr = dt.Rows [0];
1569                         dr ["Col0"] = addressC;
1570                         Assert.AreEqual (addressC, dr ["Col0"], "#C1");
1571                         Assert.AreSame (personA, dr ["Col1"], "#C2");
1572
1573                         dr = dt.Rows [1];
1574                         dr.BeginEdit ();
1575                         dr ["Col1"] = personC;
1576                         Assert.AreEqual (addressB, dr ["Col0"], "#D1");
1577                         Assert.AreSame (personC, dr ["Col1"], "#D2");
1578                         dr.EndEdit ();
1579                         Assert.AreEqual (addressB, dr ["Col0"], "#D3");
1580                         Assert.AreSame (personC, dr ["Col1"], "#D4");
1581
1582                         dr = dt.Rows [0];
1583                         dr.BeginEdit ();
1584                         dr ["Col0"] = addressB;
1585                         Assert.AreEqual (addressB, dr ["Col0"], "#E1");
1586                         Assert.AreSame (personA, dr ["Col1"], "#E2");
1587                         dr.CancelEdit ();
1588                         Assert.AreEqual (addressC, dr ["Col0"], "#E3");
1589                         Assert.AreSame (personA, dr ["Col1"], "#E4");
1590                 }
1591
1592                 [Test] // Object this [String]
1593                 public void Indexer3_ColumnName_Empty ()
1594                 {
1595                         DataTable dt = new DataTable ("Persons");
1596                         DataColumn dc0 = new DataColumn ("Col0", typeof (Address));
1597                         dt.Columns.Add (dc0);
1598                         DataColumn dc1 = new DataColumn (string.Empty, typeof (Person));
1599                         dt.Columns.Add (dc1);
1600
1601                         Person personA = new Person ("Miguel");
1602                         Address addressA = new Address ("X", 5);
1603                         Person personB = new Person ("Chris");
1604
1605                         dt.Rows.Add (new object [] { addressA, personA });
1606
1607                         DataRow dr = dt.Rows [0];
1608
1609                         try {
1610                                 object value = dr [string.Empty];
1611                                 Assert.Fail ("#A1:" + value);
1612                         } catch (ArgumentException ex) {
1613                                 //  Column '' does not belong to table Persons
1614                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
1615                                 Assert.IsNull (ex.InnerException, "#A3");
1616                                 Assert.IsNotNull (ex.Message, "#A4");
1617                                 Assert.IsTrue (ex.Message.IndexOf ("''") != -1, "#A5");
1618                                 Assert.IsTrue (ex.Message.IndexOf ("Persons") != -1, "#A6");
1619                                 Assert.IsNull (ex.ParamName, "#A7");
1620                         }
1621
1622                         try {
1623                                 dr [string.Empty] = personB;
1624                                 Assert.Fail ("#B1");
1625                         } catch (ArgumentException ex) {
1626                                 // Column '' does not belong to table Persons
1627                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1628                                 Assert.IsNull (ex.InnerException, "#B3");
1629                                 Assert.IsNotNull (ex.Message, "#B4");
1630                                 Assert.IsTrue (ex.Message.IndexOf ("''") != -1, "#B5");
1631                                 Assert.IsTrue (ex.Message.IndexOf ("Persons") != -1, "#B6");
1632                                 Assert.IsNull (ex.ParamName, "#B7");
1633                         }
1634                 }
1635
1636                 [Test] // Object this [String]
1637                 public void Indexer3_ColumnName_Null ()
1638                 {
1639                         DataTable dt = new DataTable ();
1640                         DataColumn dc0 = new DataColumn ("Col0", typeof (Address));
1641                         dt.Columns.Add (dc0);
1642                         DataColumn dc1 = new DataColumn ("Col1", typeof (Person));
1643                         dt.Columns.Add (dc1);
1644
1645                         Person personA = new Person ("Miguel");
1646                         Address addressA = new Address ("X", 5);
1647                         Person personB = new Person ("Chris");
1648
1649                         dt.Rows.Add (new object [] { addressA, personA });
1650
1651                         DataRow dr = dt.Rows [0];
1652
1653                         try {
1654                                 object value = dr [(string) null];
1655                                 Assert.Fail ("#A1:" + value);
1656                         } catch (ArgumentNullException ex) {
1657                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
1658                                 Assert.IsNull (ex.InnerException, "#A3");
1659                                 Assert.IsNotNull (ex.Message, "#A4");
1660 #if NET_2_0
1661                                 Assert.AreEqual ("name", ex.ParamName, "#A5");
1662 #else
1663                                 Assert.AreEqual ("key", ex.ParamName, "#A5");
1664 #endif
1665                         }
1666
1667                         try {
1668                                 dr [(string) null] = personB;
1669                                 Assert.Fail ("#B1");
1670                         } catch (ArgumentNullException ex) {
1671                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
1672                                 Assert.IsNull (ex.InnerException, "#B3");
1673                                 Assert.IsNotNull (ex.Message, "#B4");
1674 #if NET_2_0
1675                                 Assert.AreEqual ("name", ex.ParamName, "#B5");
1676 #else
1677                                 Assert.AreEqual ("key", ex.ParamName, "#B5");
1678 #endif
1679                         }
1680                 }
1681
1682                 [Test] // Object this [String]
1683                 public void Indexer3_Value_Null ()
1684                 {
1685                         DataTable dt = new DataTable ();
1686                         DataColumn dc0 = new DataColumn ("Col0", typeof (Address));
1687                         dt.Columns.Add (dc0);
1688                         DataColumn dc1 = new DataColumn ("Col1", typeof (Person));
1689                         dt.Columns.Add (dc1);
1690
1691                         Person personA = new Person ("Miguel");
1692                         Address addressA = new Address ("X", 5);
1693                         Person personB = new Person ("Chris");
1694                         Address addressB = new Address ("Y", 4);
1695                         Person personC = new Person ("Jackson");
1696                         Address addressC = new Address ("Z", 3);
1697
1698                         dt.Rows.Add (new object [] { addressA, personA });
1699                         dt.Rows.Add (new object [] { addressB, personB });
1700
1701                         DataRow dr = dt.Rows [0];
1702
1703                         try {
1704                                 dr ["Col0"] = null;
1705                                 Assert.Fail ("#A1");
1706                         } catch (ArgumentException ex) {
1707                                 // Cannot set Column 'Col0' to be null.
1708                                 // Please use DBNull instead
1709                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
1710                                 Assert.IsNull (ex.InnerException, "#A3");
1711                                 Assert.IsNotNull (ex.Message, "#A4");
1712                                 Assert.IsTrue (ex.Message.IndexOf ("'Col0'") != -1, "#A5");
1713                                 Assert.IsTrue (ex.Message.IndexOf ("DBNull") != -1, "#A6");
1714                         }
1715
1716                         Assert.AreEqual (addressA, dr ["Col0"], "#B1");
1717                         Assert.IsFalse (dr.IsNull ("Col0"), "#B2");
1718                         Assert.AreSame (personA, dr ["Col1"], "#B3");
1719                         Assert.IsFalse (dr.IsNull ("Col1"), "#B4");
1720
1721 #if NET_2_0
1722                         dr ["Col1"] = null;
1723 #else
1724                         try {
1725                                 dr ["Col1"] = null;
1726                                 Assert.Fail ("#B1");
1727                         } catch (ArgumentException ex) {
1728                                 // Cannot set Column 'Col1' to be null.
1729                                 // Please use DBNull instead
1730                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1731                                 Assert.IsNull (ex.InnerException, "#B3");
1732                                 Assert.IsNotNull (ex.Message, "#B4");
1733                                 Assert.IsTrue (ex.Message.IndexOf ("'Col1'") != -1, "#B5");
1734                                 Assert.IsTrue (ex.Message.IndexOf ("DBNull") != -1, "#B6");
1735                         }
1736                         dr ["Col1"] = DBNull.Value;
1737 #endif
1738
1739                         Assert.AreEqual (addressA, dr ["Col0"], "#C1");
1740                         Assert.IsFalse (dr.IsNull ("Col0"), "#C2");
1741                         Assert.AreSame (DBNull.Value, dr ["Col1"], "#C3");
1742                         Assert.IsTrue (dr.IsNull ("Col1"), "#C4");
1743
1744                         dr ["Col0"] = DBNull.Value;
1745
1746                         Assert.AreSame (DBNull.Value, dr ["Col0"], "#D1");
1747                         Assert.IsTrue (dr.IsNull ("Col0"), "#D2");
1748                         Assert.AreSame (DBNull.Value, dr ["Col1"], "#D3");
1749                         Assert.IsTrue (dr.IsNull ("Col1"), "#D4");
1750
1751                         dr ["Col1"] = personC;
1752                         dr.BeginEdit ();
1753                         Assert.AreSame (DBNull.Value, dr ["Col0"], "#E1");
1754                         Assert.IsTrue (dr.IsNull ("Col0"), "#E2");
1755                         Assert.AreEqual (personC, dr ["Col1"], "#E3");
1756                         Assert.IsFalse (dr.IsNull ("Col1"), "#E4");
1757                         dr.EndEdit ();
1758
1759                         dr ["Col1"] = DBNull.Value;
1760
1761                         Assert.AreSame (DBNull.Value, dr ["Col0"], "#F1");
1762                         Assert.IsTrue (dr.IsNull ("Col0"), "#F2");
1763                         Assert.AreSame (DBNull.Value, dr ["Col1"], "#F3");
1764                         Assert.IsTrue (dr.IsNull ("Col1"), "#F4");
1765                 }
1766
1767                 [Test] // Object this [DataColumn, DataRowVersion]
1768                 public void Indexer4 ()
1769                 {
1770                         DataTable dt = new DataTable ();
1771                         DataColumn dc0 = new DataColumn ("Col0", typeof (Address));
1772                         dt.Columns.Add (dc0);
1773                         DataColumn dc1 = new DataColumn ("Col1", typeof (Person));
1774                         dt.Columns.Add (dc1);
1775
1776                         Person personA = new Person ("Miguel");
1777                         Address addressA = new Address ("X", 5);
1778                         Person personB = new Person ("Chris");
1779                         Address addressB = new Address ("Y", 4);
1780                         Person personC = new Person ("Jackson");
1781                         Address addressC = new Address ("Z", 3);
1782
1783                         dt.Rows.Add (new object [] { addressA, personA });
1784                         dt.Rows.Add (new object [] { addressB, personB });
1785                         DataRow dr;
1786
1787                         dr = dt.Rows [0];
1788                         Assert.AreEqual (addressA, dr [dc0, DataRowVersion.Current], "#A1");
1789                         Assert.AreEqual (addressA, dr [dc0, DataRowVersion.Default], "#A2");
1790                         Assert.IsTrue (AssertNotFound (dr, dc0, DataRowVersion.Original), "#A3");
1791                         Assert.IsTrue (AssertNotFound (dr, dc0, DataRowVersion.Proposed), "#A4");
1792                         Assert.AreSame (personA, dr [dc1, DataRowVersion.Current], "#A5");
1793                         Assert.AreSame (personA, dr [dc1, DataRowVersion.Default], "#A6");
1794                         Assert.IsTrue (AssertNotFound (dr, dc1, DataRowVersion.Original), "#A7");
1795                         Assert.IsTrue (AssertNotFound (dr, dc1, DataRowVersion.Proposed), "#A8");
1796
1797                         dr = dt.Rows [1];
1798                         Assert.AreEqual (addressB, dr [dc0, DataRowVersion.Current], "#B1");
1799                         Assert.AreEqual (addressB, dr [dc0, DataRowVersion.Default], "#B2");
1800                         Assert.IsTrue (AssertNotFound (dr, dc0, DataRowVersion.Original), "#B3");
1801                         Assert.IsTrue (AssertNotFound (dr, dc0, DataRowVersion.Proposed), "#B4");
1802                         Assert.AreSame (personB, dr [dc1, DataRowVersion.Current], "#B5");
1803                         Assert.AreSame (personB, dr [dc1, DataRowVersion.Default], "#B6");
1804                         Assert.IsTrue (AssertNotFound (dr, dc1, DataRowVersion.Original), "#B7");
1805                         Assert.IsTrue (AssertNotFound (dr, dc1, DataRowVersion.Proposed), "#B8");
1806
1807                         dr = dt.Rows [0];
1808                         dr [dc0] = addressC;
1809                         Assert.AreEqual (addressC, dr [dc0, DataRowVersion.Current], "#C1");
1810                         Assert.AreEqual (addressC, dr [dc0, DataRowVersion.Default], "#C2");
1811                         Assert.IsTrue (AssertNotFound (dr, dc0, DataRowVersion.Original), "#C3");
1812                         Assert.IsTrue (AssertNotFound (dr, dc0, DataRowVersion.Proposed), "#C4");
1813                         Assert.AreSame (personA, dr [dc1, DataRowVersion.Current], "#C5");
1814                         Assert.AreSame (personA, dr [dc1, DataRowVersion.Default], "#C6");
1815                         Assert.IsTrue (AssertNotFound (dr, dc1, DataRowVersion.Original), "#C7");
1816                         Assert.IsTrue (AssertNotFound (dr, dc1, DataRowVersion.Proposed), "#C8");
1817
1818                         dr = dt.Rows [1];
1819                         dr.BeginEdit ();
1820                         dr [dc1] = personC;
1821                         Assert.AreEqual (addressB, dr [dc0, DataRowVersion.Current], "#D1");
1822                         Assert.AreEqual (addressB, dr [dc0, DataRowVersion.Default], "#D2");
1823                         Assert.IsTrue (AssertNotFound (dr, dc0, DataRowVersion.Original), "#D3");
1824                         Assert.AreEqual (addressB, dr [dc0, DataRowVersion.Proposed], "#D4");
1825                         Assert.AreSame (personB, dr [dc1, DataRowVersion.Current], "#D5");
1826                         Assert.AreSame (personC, dr [dc1, DataRowVersion.Default], "#D6");
1827                         Assert.IsTrue (AssertNotFound (dr, dc1, DataRowVersion.Original), "#D7");
1828                         Assert.AreSame (personC, dr [dc1, DataRowVersion.Proposed], "#D8");
1829                         dr.EndEdit ();
1830                         Assert.AreEqual (addressB, dr [dc0, DataRowVersion.Current], "#D9");
1831                         Assert.AreEqual (addressB, dr [dc0, DataRowVersion.Default], "#D10");
1832                         Assert.IsTrue (AssertNotFound (dr, dc0, DataRowVersion.Original), "#D11");
1833                         Assert.IsTrue (AssertNotFound (dr, dc0, DataRowVersion.Proposed), "#D12");
1834                         Assert.AreSame (personC, dr [dc1, DataRowVersion.Current], "#D13");
1835                         Assert.AreSame (personC, dr [dc1, DataRowVersion.Default], "#D14");
1836                         Assert.IsTrue (AssertNotFound (dr, dc1, DataRowVersion.Original), "#D15");
1837                         Assert.IsTrue (AssertNotFound (dr, dc1, DataRowVersion.Proposed), "#D16");
1838                         dr.AcceptChanges ();
1839                         Assert.AreEqual (addressB, dr [dc0, DataRowVersion.Current], "#D17");
1840                         Assert.AreEqual (addressB, dr [dc0, DataRowVersion.Default], "#D18");
1841                         Assert.AreEqual (addressB, dr [dc0, DataRowVersion.Original], "#D19");
1842                         Assert.IsTrue (AssertNotFound (dr, dc0, DataRowVersion.Proposed), "#D20");
1843                         Assert.AreSame (personC, dr [dc1, DataRowVersion.Current], "#D21");
1844                         Assert.AreSame (personC, dr [dc1, DataRowVersion.Default], "#D22");
1845                         Assert.AreEqual (personC, dr [dc1, DataRowVersion.Original], "#D23");
1846                         Assert.IsTrue (AssertNotFound (dr, dc1, DataRowVersion.Proposed), "#D24");
1847
1848                         dr = dt.Rows [0];
1849                         dr.BeginEdit ();
1850                         dr [dc0] = addressA;
1851                         Assert.AreEqual (addressC, dr [dc0, DataRowVersion.Current], "#E1");
1852                         Assert.AreEqual (addressA, dr [dc0, DataRowVersion.Default], "#E2");
1853                         Assert.IsTrue (AssertNotFound (dr, dc0, DataRowVersion.Original), "#E3");
1854                         Assert.AreEqual (addressA, dr [dc0, DataRowVersion.Proposed], "#E4");
1855                         Assert.AreSame (personA, dr [dc1, DataRowVersion.Current], "#E5");
1856                         Assert.AreSame (personA, dr [dc1, DataRowVersion.Default], "#E6");
1857                         Assert.IsTrue (AssertNotFound (dr, dc1, DataRowVersion.Original), "#E7");
1858                         Assert.AreSame (personA, dr [dc1, DataRowVersion.Proposed], "#E8");
1859                         dr.CancelEdit ();
1860                         Assert.AreEqual (addressC, dr [dc0, DataRowVersion.Current], "#E9");
1861                         Assert.AreEqual (addressC, dr [dc0, DataRowVersion.Default], "#E10");
1862                         Assert.IsTrue (AssertNotFound (dr, dc0, DataRowVersion.Original), "#E11");
1863                         Assert.IsTrue (AssertNotFound (dr, dc0, DataRowVersion.Proposed), "#E12");
1864                         Assert.AreSame (personA, dr [dc1, DataRowVersion.Current], "#E13");
1865                         Assert.AreSame (personA, dr [dc1, DataRowVersion.Default], "#E14");
1866                         Assert.IsTrue (AssertNotFound (dr, dc1, DataRowVersion.Original), "#E15");
1867                         Assert.IsTrue (AssertNotFound (dr, dc1, DataRowVersion.Proposed), "#E16");
1868                 }
1869
1870                 [Test]
1871                 public void Indexer4_Column_NotInTable ()
1872                 {
1873                         DataTable dtA = new DataTable ("TableA");
1874                         DataColumn dcA1 = new DataColumn ("Col0", typeof (Address));
1875                         dtA.Columns.Add (dcA1);
1876                         DataColumn dcA2 = new DataColumn ("Col1", typeof (Person));
1877                         dtA.Columns.Add (dcA2);
1878
1879                         DataTable dtB = new DataTable ("TableB");
1880                         DataColumn dcB1 = new DataColumn ("Col0", typeof (Address));
1881                         dtB.Columns.Add (dcB1);
1882                         DataColumn dcB2 = new DataColumn ("Col1", typeof (Person));
1883                         dtB.Columns.Add (dcB2);
1884
1885                         Person personA = new Person ("Miguel");
1886                         Address addressA = new Address ("X", 5);
1887
1888                         dtA.Rows.Add (new object [] { addressA, personA });
1889                         DataRow dr = dtA.Rows [0];
1890
1891                         try {
1892                                 object value = dr [dcB1, DataRowVersion.Default];
1893                                 Assert.Fail ("#A1:" + value);
1894                         } catch (ArgumentException ex) {
1895                                 // Column 'Col0' does not belong to table TableA
1896                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
1897                                 Assert.IsNull (ex.InnerException, "#A3");
1898                                 Assert.IsNotNull (ex.Message, "#A4");
1899                                 Assert.IsTrue (ex.Message.IndexOf ("'Col0'") != -1, "#A5");
1900                                 Assert.IsTrue (ex.Message.IndexOf ("TableA") != -1, "#A6");
1901                         }
1902
1903                         try {
1904                                 object value = dr [new DataColumn ("ZZZ"), DataRowVersion.Default];
1905                                 Assert.Fail ("#B1:" + value);
1906                         } catch (ArgumentException ex) {
1907                                 // Column 'Col0' does not belong to table TableA
1908                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
1909                                 Assert.IsNull (ex.InnerException, "#B3");
1910                                 Assert.IsNotNull (ex.Message, "#B4");
1911                                 Assert.IsTrue (ex.Message.IndexOf ("'ZZZ'") != -1, "#B5");
1912                                 Assert.IsTrue (ex.Message.IndexOf ("TableA") != -1, "#B6");
1913                         }
1914
1915                         dtA.Columns.Remove (dcA2);
1916
1917                         try {
1918                                 object value = dr [dcA2, DataRowVersion.Default];
1919                                 Assert.Fail ("#C1:" + value);
1920                         } catch (ArgumentException ex) {
1921                                 // Column 'Col0' does not belong to table TableA
1922                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
1923                                 Assert.IsNull (ex.InnerException, "#C3");
1924                                 Assert.IsNotNull (ex.Message, "#C4");
1925                                 Assert.IsTrue (ex.Message.IndexOf ("'Col1'") != -1, "#C5");
1926                                 Assert.IsTrue (ex.Message.IndexOf ("TableA") != -1, "#C6");
1927                         }
1928                 }
1929
1930                 [Test] // Object this [DataColumn, DataRowVersion]
1931                 public void Indexer4_Column_Null ()
1932                 {
1933                         DataTable dt = new DataTable ();
1934                         DataColumn dc0 = new DataColumn ("Col0", typeof (Address));
1935                         dt.Columns.Add (dc0);
1936                         DataColumn dc1 = new DataColumn ("Col1", typeof (Person));
1937                         dt.Columns.Add (dc1);
1938
1939                         Person personA = new Person ("Miguel");
1940                         Address addressA = new Address ("X", 5);
1941                         Person personB = new Person ("Chris");
1942
1943                         dt.Rows.Add (new object [] { addressA, personA });
1944                         DataRow dr = dt.Rows [0];
1945
1946                         try {
1947                                 object value = dr [(DataColumn) null, DataRowVersion.Default];
1948                                 Assert.Fail ("#1:" + value);
1949                         } catch (ArgumentNullException ex) {
1950                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1951                                 Assert.IsNull (ex.InnerException, "#3");
1952                                 Assert.IsNotNull (ex.Message, "#4");
1953                                 Assert.AreEqual ("column", ex.ParamName, "#5");
1954                         }
1955                 }
1956
1957                 [Test] // Object this [DataColumn, DataRowVersion]
1958                 public void Indexer4_Version_Invalid ()
1959                 {
1960                         DataTable dt = new DataTable ();
1961                         DataColumn dc0 = new DataColumn ("Col0", typeof (Address));
1962                         dt.Columns.Add (dc0);
1963                         DataColumn dc1 = new DataColumn ("Col1", typeof (Person));
1964                         dt.Columns.Add (dc1);
1965
1966                         Person personA = new Person ("Miguel");
1967                         Address addressA = new Address ("X", 5);
1968                         Person personB = new Person ("Chris");
1969
1970                         dt.Rows.Add (new object [] { addressA, personA });
1971                         DataRow dr = dt.Rows [0];
1972
1973                         try {
1974                                 object value = dr [dc0, (DataRowVersion) 666];
1975                                 Assert.Fail ("#1:" + value);
1976                         } catch (DataException ex) {
1977                                 // Version must be Original, Current, or Proposed
1978                                 Assert.AreEqual (typeof (DataException), ex.GetType (), "#2");
1979                                 Assert.IsNull (ex.InnerException, "#3");
1980                                 Assert.IsNotNull (ex.Message, "#4");
1981                                 Assert.IsTrue (ex.Message.IndexOf ("Original") != -1, "#5");
1982                                 Assert.IsTrue (ex.Message.IndexOf ("Current") != -1, "#6");
1983                                 Assert.IsTrue (ex.Message.IndexOf ("Proposed") != -1, "#7");
1984                                 Assert.IsFalse (ex.Message.IndexOf ("Default") != -1, "#8");
1985                         }
1986                 }
1987
1988                 [Test] // Object this [DataColumn, DataRowVersion]
1989                 public void Indexer4_Version_NotFound ()
1990                 {
1991                         DataTable dt = new DataTable ();
1992                         DataColumn dc0 = new DataColumn ("Col0", typeof (Address));
1993                         dt.Columns.Add (dc0);
1994                         DataColumn dc1 = new DataColumn ("Col1", typeof (Person));
1995                         dt.Columns.Add (dc1);
1996
1997                         Person personA = new Person ("Miguel");
1998                         Address addressA = new Address ("X", 5);
1999                         Person personB = new Person ("Chris");
2000
2001                         dt.Rows.Add (new object [] { addressA, personA });
2002                         DataRow dr = dt.Rows [0];
2003
2004                         try {
2005                                 object value = dr [dc0, DataRowVersion.Original];
2006                                 Assert.Fail ("#A1:" + value);
2007                         } catch (VersionNotFoundException ex) {
2008                                 // There is no Original data to access
2009                                 Assert.AreEqual (typeof (VersionNotFoundException), ex.GetType (), "#A2");
2010                                 Assert.IsNull (ex.InnerException, "#A3");
2011                                 Assert.IsNotNull (ex.Message, "#A4");
2012                                 Assert.IsTrue (ex.Message.IndexOf ("Original") != -1, "#A5");
2013                         }
2014
2015                         try {
2016                                 object value = dr [dc0, DataRowVersion.Proposed];
2017                                 Assert.Fail ("#B1:" + value);
2018                         } catch (VersionNotFoundException ex) {
2019                                 // There is no Proposed data to access
2020                                 Assert.AreEqual (typeof (VersionNotFoundException), ex.GetType (), "#B2");
2021                                 Assert.IsNull (ex.InnerException, "#B3");
2022                                 Assert.IsNotNull (ex.Message, "#B4");
2023                                 Assert.IsTrue (ex.Message.IndexOf ("Proposed") != -1, "#B5");
2024                         }
2025                 }
2026
2027                 [Test] public void IsNull_ByDataColumn()
2028                 {
2029                         DataTable dt = new DataTable();
2030                         DataColumn dc0 = new DataColumn("Col0",typeof(int));
2031                         DataColumn dc1 = new DataColumn("Col1",typeof(int));
2032                         dt.Columns.Add(dc0);
2033                         dt.Columns.Add(dc1);
2034                         dt.Rows.Add(new object[] {1234});
2035                         DataRow dr = dt.Rows[0];
2036
2037                         // IsNull_I 2
2038                         Assert.AreEqual(false , dr.IsNull(dc0) , "DRW85");
2039
2040                         // IsNull_I 2
2041                         Assert.AreEqual(true , dr.IsNull(dc1) , "DRW86");
2042                 }
2043
2044                 [Test] public void IsNull_ByDataColumnDataRowVersion()
2045                 {
2046                         DataTable dt = new DataTable();
2047                         DataColumn dc0 = new DataColumn("Col0",typeof(int));
2048                         DataColumn dc1 = new DataColumn("Col1",typeof(int));
2049                         dt.Columns.Add(dc0);
2050                         dt.Columns.Add(dc1);
2051                         dt.Rows.Add(new object[] {1234});
2052                         DataRow dr = dt.Rows[0];
2053
2054                         // IsNull - col0 Current
2055                         Assert.AreEqual(false, dr.IsNull(dc0,DataRowVersion.Current) , "DRW87");
2056
2057                         // IsNull - col1 Current
2058                         Assert.AreEqual(true, dr.IsNull(dc1,DataRowVersion.Current) , "DRW88");
2059
2060                         // IsNull - col0 Default
2061                         Assert.AreEqual(false, dr.IsNull(dc0,DataRowVersion.Default) , "DRW89");
2062                         // IsNull - col1 Default
2063                         Assert.AreEqual(true, dr.IsNull(dc1,DataRowVersion.Default) , "DRW90");
2064
2065                         dr.BeginEdit();
2066                         dr[0] = 9; //Change value, Create RowVersion Proposed
2067
2068                         // IsNull - col0 Proposed
2069                         Assert.AreEqual(false, dr.IsNull(dc0,DataRowVersion.Proposed) , "DRW91");
2070                         // IsNull - col1 Proposed
2071                         Assert.AreEqual(true, dr.IsNull(dc1,DataRowVersion.Proposed) , "DRW92");
2072
2073                         dr.AcceptChanges();
2074                         dr.Delete();
2075
2076                         // IsNull - col0 Original
2077                         Assert.AreEqual(false, dr.IsNull(dc0,DataRowVersion.Original) , "DRW93");
2078                 }
2079
2080                 [Test] public void IsNull_ByIndex()
2081                 {
2082                         DataTable dt = new DataTable();
2083                         DataColumn dc0 = new DataColumn("Col0",typeof(int));
2084                         DataColumn dc1 = new DataColumn("Col1",typeof(int));
2085                         dt.Columns.Add(dc0);
2086                         dt.Columns.Add(dc1);
2087                         dt.Rows.Add(new object[] {1234});
2088                         DataRow dr = dt.Rows[0];
2089
2090                         // IsNull_I 2
2091                         Assert.AreEqual(false , dr.IsNull(0) , "DRW94");
2092
2093                         // IsNull_I 2
2094                         Assert.AreEqual(true , dr.IsNull(1) , "DRW95");
2095                 }
2096
2097                 [Test]
2098                 public void IsNull_ByName()
2099                 {
2100                         DataTable dt = new DataTable();
2101                         DataColumn dc0 = new DataColumn("Col0",typeof(int));
2102                         DataColumn dc1 = new DataColumn("Col1",typeof(int));
2103                         dt.Columns.Add(dc0);
2104                         dt.Columns.Add(dc1);
2105                         dt.Rows.Add(new object[] {1234});
2106                         DataRow dr = dt.Rows[0];
2107
2108 #region --- assignment  ----
2109                         // IsNull_S 1
2110                         Assert.AreEqual(false, dr.IsNull("Col0"), "DRW96");
2111
2112                         // IsNull_S 2
2113                         Assert.AreEqual(true, dr.IsNull("Col1"), "DRW97");
2114 #endregion
2115
2116 #region --- bug 3124 ---
2117
2118                         // IsNull_S 1
2119                         MemoryStream st = new MemoryStream();
2120                         StreamWriter sw = new StreamWriter(st);
2121                         sw.Write("<?xml version=\"1.0\" standalone=\"yes\"?><NewDataSet>");
2122                         sw.Write("<Table><EmployeeNo>9</EmployeeNo></Table>");
2123                         sw.Write("</NewDataSet>");
2124                         sw.Flush();
2125                         st.Position=0;
2126                         DataSet ds = new DataSet();
2127                         ds.ReadXml(st);
2128                         //  Here we add the expression column
2129                         ds.Tables[0].Columns.Add("ValueListValueMember", typeof(object), "EmployeeNo");
2130
2131                         foreach( DataRow row in ds.Tables[0].Rows )
2132                         {
2133                                 Console.WriteLine(row["ValueListValueMember"].ToString() + " " );
2134                                 if( row.IsNull("ValueListValueMember") == true )
2135                                         Assert.AreEqual("Failed", "SubTest", "DRW98");
2136                                 else
2137                                         Assert.AreEqual("Passed", "Passed", "DRW99");
2138                         }
2139
2140 #endregion
2141                 }
2142
2143                 [Test]
2144                 public void IsNull_BeforeGetValue ()
2145                 {
2146                         DataTable table = new DataTable ();
2147
2148                         // add the row, with the value in the column
2149                         DataColumn staticColumn = table.Columns.Add ("static", typeof(string), null); // static
2150                         DataRow row = table.Rows.Add ("the value");
2151                         Assert.IsFalse (row.IsNull ("static"), "static null check failed");
2152                         Assert.AreEqual ("the value", row ["static"], "static value check failed");
2153
2154                         // add the first derived column
2155                         DataColumn firstColumn = table.Columns.Add ("first", typeof(string), "static"); // first -> static
2156                         Assert.IsFalse (row.IsNull ("first"), "first level null check failed");
2157                         Assert.AreEqual ("the value", row ["first"], "first level value check failed");
2158
2159                         // add the second level of related
2160                         DataColumn secondColumn = table.Columns.Add ("second", typeof(string), "first"); // second -> first -> static
2161                         Assert.IsFalse (row.IsNull ("second"), "second level null check failed");
2162                         Assert.AreEqual ("the value", row ["second"], "second level value check failed");
2163                 }
2164
2165                 [Test]
2166                 public void IsNull_NullValueArguments ()
2167                 {
2168                         DataTable table = new DataTable ();
2169
2170                         // add the row, with the value in the column
2171                         DataColumn staticColumn = table.Columns.Add ("static", typeof(string), null);
2172                         DataRow row = table.Rows.Add ("the value");
2173
2174                         try {
2175                                 row.IsNull ((string)null);
2176                                 Assert.Fail ("expected an arg null exception for passing a null string");
2177                         } catch (ArgumentNullException) {
2178                                 // do nothing as null columns aren't allowed
2179                         }
2180
2181                         try {
2182                                 row.IsNull ("");
2183                                 Assert.Fail ("expected an arg exception for passing an empty string");
2184                         } catch (ArgumentException) {
2185                                 // do nothing as we can't find a col with no name
2186                         }
2187
2188                         try {
2189                                 row.IsNull (null, DataRowVersion.Default);
2190                                 Assert.Fail ("null column with version check failed");
2191                         } catch (ArgumentNullException) {
2192                                 // do nothing as null columns aren't allowed
2193                         }
2194                 }
2195
2196                 [Test] public void Item()
2197                 {
2198                         // init table with columns
2199                         DataTable myTable = new DataTable("myTable");
2200
2201                         myTable.Columns.Add(new DataColumn("Id",typeof(int)));
2202                         myTable.Columns.Add(new DataColumn("Name",typeof(string)));
2203                         DataColumn dc = myTable.Columns[0];
2204
2205                         myTable.Rows.Add(new object[] {1,"Ofer"});
2206                         myTable.Rows.Add(new object[] {2,"Ofer"});
2207
2208                         myTable.AcceptChanges();
2209
2210                         DataRow myRow = myTable.Rows[0];
2211
2212                         //Start checking
2213
2214                         // Item - index
2215                         Assert.AreEqual(1 , (int)myRow[0] , "DRW100");
2216
2217                         // Item - string
2218                         Assert.AreEqual(1 ,  (int)myRow["Id"] , "DRW101");
2219
2220                         // Item - Column
2221                         Assert.AreEqual(1 ,  (int)myRow[dc] , "DRW102");
2222
2223                         // Item - index,Current
2224                         Assert.AreEqual(1 ,  (int)myRow[0,DataRowVersion.Current ] , "DRW103");
2225
2226                         // Item - string,Current
2227                         Assert.AreEqual(1 ,  (int)myRow["Id",DataRowVersion.Current] , "DRW104");
2228
2229                         // Item - columnn,Current
2230                         Assert.AreEqual(1 ,  (int)myRow[dc,DataRowVersion.Current] , "DRW105");
2231
2232                         //      testMore();
2233                 }
2234
2235                 /*public void testMore()
2236                 {
2237                         DataTable dt = DataProvider.CreateParentDataTable();
2238                         dt.Rows[0].BeginEdit();
2239                         dt.Rows[0][0] = 10;
2240                         dt.Rows[0].EndEdit();
2241                         dt.AcceptChanges();
2242                 }*/
2243
2244                 [Test] public void RejectChanges()
2245                 {
2246                         DataTable dt = new DataTable();
2247                         DataColumn dc0 = new DataColumn("Col0",typeof(int));
2248                         DataColumn dc1 = new DataColumn("Col1",typeof(int));
2249                         dt.Columns.Add(dc0);
2250                         dt.Columns.Add(dc1);
2251                         dt.Rows.Add(new object[] {1234});
2252                         dt.AcceptChanges();
2253                         DataRow dr = dt.Rows[0];
2254
2255                         dr[0] = 567;
2256                         dr[1] = 789;
2257                         dr.RejectChanges();
2258
2259                         // RejectChanges - row 0
2260                         Assert.AreEqual(1234  ,  (int)dr[0], "DRW106");
2261
2262                         // RejectChanges - row 1
2263                         Assert.AreEqual(DBNull.Value  ,  dr[1] , "DRW107");
2264
2265                         dr.Delete();
2266                         dr.RejectChanges();
2267
2268                         // RejectChanges - count
2269                         Assert.AreEqual(1 ,  dt.Rows.Count , "DRW108");
2270                 }
2271
2272                 [Test] public void RowState()
2273                 {
2274                         DataTable myTable = new DataTable("myTable");
2275                         DataColumn dc = new DataColumn("Name",typeof(string));
2276                         myTable.Columns.Add(dc);
2277                         DataRow myRow;
2278
2279                         // Create a new DataRow.
2280                         myRow = myTable.NewRow();
2281
2282                         // Detached row.
2283
2284                         // Detached
2285                         Assert.AreEqual(DataRowState.Detached ,  myRow.RowState , "DRW109");
2286
2287                         myTable.Rows.Add(myRow);
2288                         // New row.
2289
2290                         // Added
2291                         Assert.AreEqual(DataRowState.Added ,  myRow.RowState , "DRW110");
2292
2293                         myTable.AcceptChanges();
2294                         // Unchanged row.
2295
2296                         // Unchanged
2297                         Assert.AreEqual(DataRowState.Unchanged ,  myRow.RowState , "DRW111");
2298
2299                         myRow["Name"] = "Scott";
2300                         // Modified row.
2301
2302                         // Modified
2303                         Assert.AreEqual(DataRowState.Modified ,  myRow.RowState , "DRW112");
2304
2305                         myRow.Delete();
2306                         // Deleted row.
2307
2308                         // Deleted
2309                         Assert.AreEqual(DataRowState.Deleted ,  myRow.RowState , "DRW113");
2310                 }
2311
2312                 [Test] public void SetColumnError_ByDataColumnError()
2313                 {
2314                         string sColErr = "Error!";
2315                         DataTable dt = new DataTable("myTable");
2316                         DataColumn dc = new DataColumn("Column1");
2317                         dt.Columns.Add(dc);
2318                         DataRow dr = dt.NewRow();
2319
2320                         // empty string
2321                         Assert.AreEqual(String.Empty,  dr.GetColumnError(dc) , "DRW114");
2322
2323                         dr.SetColumnError(dc,sColErr );
2324
2325                         // error string
2326                         Assert.AreEqual(sColErr, dr.GetColumnError(dc) , "DRW115");
2327                 }
2328
2329                 [Test] public void SetColumnError_ByIndexError()
2330                 {
2331                         string sColErr = "Error!";
2332                         DataTable dt = new DataTable("myTable");
2333                         DataColumn dc = new DataColumn("Column1");
2334                         dt.Columns.Add(dc);
2335                         DataRow dr = dt.NewRow();
2336
2337                         // empty string
2338                         Assert.AreEqual(String.Empty ,  dr.GetColumnError(0) , "DRW116");
2339
2340                         dr.SetColumnError(0,sColErr );
2341
2342                         // error string
2343                         Assert.AreEqual(sColErr  ,  dr.GetColumnError(0) , "DRW117");
2344                         dr.SetColumnError (0, "");
2345                         Assert.AreEqual("",  dr.GetColumnError (0) , "DRW118");
2346                 }
2347
2348                 [Test] public void SetColumnError_ByColumnNameError()
2349                 {
2350                         string sColErr = "Error!";
2351                         DataTable dt = new DataTable("myTable");
2352                         DataColumn dc = new DataColumn("Column1");
2353                         dt.Columns.Add(dc);
2354                         DataRow dr = dt.NewRow();
2355
2356                         // empty string
2357                         Assert.AreEqual(String.Empty,  dr.GetColumnError("Column1") , "DRW118");
2358
2359                         dr.SetColumnError("Column1",sColErr );
2360
2361                         // error string
2362                         Assert.AreEqual(sColErr,  dr.GetColumnError("Column1") , "DRW119");
2363                 }
2364
2365                 [Test] public void SetParentRow_ByDataRow()
2366                 {
2367                         DataRow drParent,drChild;
2368                         DataRow drArrExcepted,drArrResult;
2369                         DataTable dtChild,dtParent;
2370                         DataSet ds = new DataSet();
2371                         //Create tables
2372                         dtChild = DataProvider.CreateChildDataTable();
2373                         dtParent= DataProvider.CreateParentDataTable();
2374                         //Add tables to dataset
2375                         ds.Tables.Add(dtChild);
2376                         ds.Tables.Add(dtParent);
2377                         //Add Relation
2378                         DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"]);
2379                         ds.Relations.Add(dRel);
2380
2381                         drParent = dtParent.Rows[0];
2382                         drChild = dtChild.Select("ParentId=" + drParent["ParentId"])[0];
2383
2384                         drChild.SetParentRow(drParent);
2385
2386                         //Get Excepted result
2387                         drArrExcepted = drParent;
2388                         //Get Result DataRowVersion.Current
2389                         drArrResult = drChild.GetParentRow("Parent-Child",DataRowVersion.Current);
2390
2391                         // SetParentRow
2392                         Assert.AreEqual(drArrExcepted ,  drArrResult, "DRW120");
2393                 }
2394
2395                 [Test]
2396                 public void testMore()
2397                 {
2398                         DataSet ds = DataProvider.CreateForigenConstraint();
2399                         DataRow drParent = ds.Tables[0].Rows[0];
2400                         //DataRow[] drArray =  ds.Tables[1].Rows[0].GetParentRows(ds.Tables[1].ParentRelations[0]);
2401                         ds.Tables[1].Rows[0].SetParentRow(drParent);
2402                 }
2403
2404                 [Test]
2405                 public void test()
2406                 {
2407                         // test SetParentRow
2408                         DataTable parent = DataProvider.CreateParentDataTable();
2409                         DataTable child = DataProvider.CreateChildDataTable();
2410                         DataRow dr = parent.Rows[0];
2411                         dr.Delete();
2412                         parent.AcceptChanges();
2413
2414                         child.Rows[0].SetParentRow(dr);
2415                 }
2416
2417                 public void checkForLoops()
2418                 {
2419                         DataSet ds = new DataSet();
2420                         //Create tables
2421                         DataTable  dtChild = DataProvider.CreateChildDataTable();
2422                         DataTable dtParent= DataProvider.CreateParentDataTable();
2423                         //Add tables to dataset
2424                         ds.Tables.Add(dtChild);
2425                         ds.Tables.Add(dtParent);
2426
2427                         dtChild.Rows.Clear();
2428                         dtParent.Rows.Clear();
2429
2430                         dtParent.ChildRelations.Add(dtParent.Columns[0],dtChild.Columns[0]);
2431                         dtChild.ChildRelations.Add(dtChild.Columns[0],dtParent.Columns[0]);
2432
2433                         dtChild.Rows[0].SetParentRow(dtParent.Rows[0]);
2434                         dtParent.Rows[0].SetParentRow(dtChild.Rows[0]);
2435                 }
2436
2437                 public void checkForLoopsAdvenced()
2438                 {
2439                         //Create tables
2440                         DataTable  dtChild = new DataTable();
2441                         dtChild.Columns.Add("Col1",typeof(int));
2442                         dtChild.Columns.Add("Col2",typeof(int));
2443
2444                         DataRelation drl = new DataRelation("drl1",dtChild.Columns[0],dtChild.Columns[1]);
2445                         dtChild.ChildRelations.Add(drl);
2446                         dtChild.Rows[0].SetParentRow(dtChild.Rows[1]);
2447                         dtChild.Rows[1].SetParentRow(dtChild.Rows[0]);
2448                 }
2449
2450                 [Test] public void SetParentRow_ByDataRowDataRelation()
2451                 {
2452                         DataRow drParent,drChild;
2453                         DataRow drArrExcepted,drArrResult;
2454                         DataTable dtChild,dtParent;
2455                         DataSet ds = new DataSet();
2456                         //Create tables
2457                         dtChild = DataProvider.CreateChildDataTable();
2458                         dtParent= DataProvider.CreateParentDataTable();
2459                         //Add tables to dataset
2460                         ds.Tables.Add(dtChild);
2461                         ds.Tables.Add(dtParent);
2462                         //Add Relation
2463                         DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"]);
2464                         ds.Relations.Add(dRel);
2465
2466                         drParent = dtParent.Rows[0];
2467                         drChild = dtChild.Select("ParentId=" + drParent["ParentId"])[0];
2468
2469                         drChild.SetParentRow(drParent ,dRel);
2470
2471                         //Get Excepted result
2472                         drArrExcepted = drParent;
2473                         //Get Result DataRowVersion.Current
2474                         drArrResult = drChild.GetParentRow("Parent-Child",DataRowVersion.Current);
2475
2476                         // SetParentRow
2477                         Assert.AreEqual(drArrExcepted ,  drArrResult, "DRW121");
2478                 }
2479
2480                 [Test] public void Table()
2481                 {
2482                         DataTable dt1,dt2;
2483                         dt2 = new DataTable("myTable");
2484                         DataRow dr = dt2.NewRow();
2485                         dt1 = dr.Table;
2486
2487                         // ctor
2488                         Assert.AreEqual(dt2, dt1 , "DRW122");
2489                 }
2490
2491                 [Test] public new  void ToString()
2492                 {
2493                         DataRow dr;
2494                         DataTable dtParent;
2495                         dtParent= DataProvider.CreateParentDataTable();
2496                         dr = dtParent.Rows[0];
2497
2498                         // ToString
2499                         Assert.AreEqual(true, dr.ToString().ToLower().StartsWith("system.data.datarow") , "DRW123");
2500                 }
2501
2502                 [Test] public void DataRow_RowError()
2503                 {
2504                         DataTable dt = new DataTable ("myTable");
2505                         DataRow dr = dt.NewRow ();
2506
2507                         Assert.AreEqual ( dr.RowError, string.Empty );
2508
2509                         dr.RowError = "Err";
2510                         Assert.AreEqual ( dr.RowError , "Err" );
2511                 }
2512
2513                 [Test]
2514                 [ExpectedException (typeof (ConstraintException))]
2515                 public void DataRow_RowError2()
2516                 {
2517                         DataTable dt1 = DataProvider.CreateUniqueConstraint();
2518
2519                         dt1.BeginLoadData();
2520
2521                         DataRow  dr = dt1.NewRow();
2522                         dr[0] = 3;
2523                         dt1.Rows.Add(dr);
2524                         dt1.EndLoadData();
2525                 }
2526
2527                 [Test]
2528                 [ExpectedException (typeof (ConstraintException))]
2529                 public void DataRow_RowError3()
2530                 {
2531                         DataSet ds= DataProvider.CreateForigenConstraint();
2532                         ds.Tables[0].BeginLoadData();
2533                         ds.Tables[0].Rows[0][0] = 10;
2534                         ds.Tables[0].EndLoadData(); //Foreign constraint violation
2535                 }
2536
2537
2538                 [Test]
2539                 public void TestRowErrors ()
2540                 {
2541                         DataTable table = new DataTable ();
2542                         DataColumn col1 = table.Columns.Add ("col1", typeof (int));
2543                         DataColumn col2 = table.Columns.Add ("col2", typeof (int));
2544                         DataColumn col3 = table.Columns.Add ("col3", typeof (int));
2545
2546                         col1.AllowDBNull = false;
2547                         table.Constraints.Add ("uc", new DataColumn[] {col2,col3}, false);
2548                         table.BeginLoadData ();
2549                         table.Rows.Add (new object[] {null,1,1});
2550                         table.Rows.Add (new object[] {1,1,1});
2551                         try {
2552                                 table.EndLoadData ();
2553                                 Assert.Fail ("#0");
2554                         } catch (ConstraintException) {}
2555                         Assert.IsTrue (table.HasErrors, "#1");
2556                         DataRow[] rows = table.GetErrors ();
2557
2558                         Assert.AreEqual (2, rows.Length, "#2");
2559                         Assert.AreEqual ("Column 'col1' does not allow DBNull.Value.", table.Rows [0].RowError, "#3");
2560                         Assert.AreEqual ("Column 'col2, col3' is constrained to be unique.  Value '1, 1' is already present."
2561                                         , table.Rows [1].RowError, "#4");
2562
2563                         Assert.AreEqual (table.Rows [0].RowError, table.Rows [0].GetColumnError (0), "#5");
2564                         Assert.AreEqual (table.Rows [1].RowError, table.Rows [0].GetColumnError (1), "#6");
2565                         Assert.AreEqual (table.Rows [1].RowError, table.Rows [0].GetColumnError (2), "#7");
2566
2567                         Assert.AreEqual ("", table.Rows [1].GetColumnError (0), "#8");
2568                         Assert.AreEqual (table.Rows [1].RowError, table.Rows [1].GetColumnError (1), "#9");
2569                         Assert.AreEqual (table.Rows [1].RowError, table.Rows [1].GetColumnError (2), "#10");
2570                 }
2571
2572                 [Test]
2573                 public void BeginEdit()
2574                 {
2575                         DataTable myTable = new DataTable("myTable");
2576                         DataColumn dc = new DataColumn("Id",typeof(int));
2577                         dc.Unique=true;
2578                         myTable.Columns.Add(dc);
2579                         myTable.Rows.Add(new object[] {1});
2580                         myTable.Rows.Add(new object[] {2});
2581                         myTable.Rows.Add(new object[] {3});
2582
2583                         DataRow myRow = myTable.Rows[0];
2584
2585                         try
2586                         {
2587                                 myRow[0] = 2; //row[0] now conflict with row[1]
2588                                 Assert.Fail("DRW121: failed to throw ConstraintException");
2589                         }
2590                         catch (ConstraintException) {}
2591                         catch (AssertionException exc) {throw  exc;}
2592                         catch (Exception exc)
2593                         {
2594                                 Assert.Fail("DRW122: Add. Wrong exception type. Got:" + exc);
2595                         }
2596
2597                         //Will NOT! throw exception
2598                         myRow.BeginEdit();
2599                         myRow[0] = 2; //row[0] now conflict with row[1]
2600
2601                         DataTable dt = DataProvider.CreateParentDataTable();
2602                         DataRow dr = dt.Rows[0];
2603                         dr.Delete();
2604                         try
2605                         {
2606                                 dr.BeginEdit();
2607                                 Assert.Fail("DRW123: failed to throw DeletedRowInaccessibleException");
2608                         }
2609                         catch (DeletedRowInaccessibleException) {}
2610                         catch (AssertionException exc) {throw  exc;}
2611                         catch (Exception exc)
2612                         {
2613                                 Assert.Fail("DRW124: Add. Wrong exception type. Got:" + exc);
2614                         }
2615                 }
2616
2617                 [Test]
2618                 public void GetChildRows_DataRelation()
2619                 {
2620                         DataRow dr;
2621                         DataRow[] drArrExcepted,drArrResult;
2622                         DataTable dtChild,dtParent;
2623                         DataSet ds = new DataSet();
2624
2625                         //Create tables
2626                         dtChild = DataProvider.CreateChildDataTable();
2627                         dtParent= DataProvider.CreateParentDataTable();
2628
2629                         //Add tables to dataset
2630                         ds.Tables.Add(dtChild);
2631                         ds.Tables.Add(dtParent);
2632                         dr = dtParent.Rows[0];
2633
2634                         //Add Relation
2635                         DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"]);
2636                         ds.Relations.Add(dRel);
2637                         //Get Excepted result
2638                         drArrExcepted = dtChild.Select("ParentId=" + dr["ParentId"]);
2639                         //Get Result
2640                         drArrResult = dr.GetChildRows(dRel);
2641
2642                         Assert.AreEqual(drArrExcepted, drArrResult, "DRW125");
2643                 }
2644
2645                 [Test]
2646                 public void GetParentRows_DataRelation_DataRowVersion()
2647                 {
2648                         DataRow drParent,drChild;
2649                         DataRow[] drArrExcepted,drArrResult;
2650                         DataTable dtChild,dtParent;
2651                         DataSet ds = new DataSet();
2652                         //Create tables
2653                         dtChild = DataProvider.CreateChildDataTable();
2654                         dtParent= DataProvider.CreateParentDataTable();
2655                         //Add tables to dataset
2656                         ds.Tables.Add(dtChild);
2657                         ds.Tables.Add(dtParent);
2658
2659                         drParent = dtParent.Rows[0];
2660                         drChild = dtChild.Select("ParentId=" + drParent["ParentId"])[0];
2661
2662                         //Duplicate several rows in order to create Many to Many relation
2663                         dtParent.ImportRow(drParent);
2664                         dtParent.ImportRow(drParent);
2665                         dtParent.ImportRow(drParent);
2666
2667                         //Add Relation
2668                         DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"],false);
2669                         ds.Relations.Add(dRel);
2670
2671                         //Get Excepted result
2672                         drArrExcepted = dtParent.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.CurrentRows );
2673                         //Get Result DataRowVersion.Current
2674                         drArrResult = drChild.GetParentRows(dRel,DataRowVersion.Current);
2675                         Assert.AreEqual(drArrExcepted, drArrResult, "DRW126");
2676
2677                         //Get Excepted result
2678                         drArrExcepted = dtParent.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.OriginalRows );
2679                         //Get Result DataRowVersion.Current
2680                         drArrResult = drChild.GetParentRows(dRel,DataRowVersion.Original );
2681                         Assert.AreEqual(drArrExcepted, drArrResult, "DRW127");
2682
2683                         //Get Excepted result, in this case Current = Default
2684                         drArrExcepted = dtParent.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.CurrentRows);
2685                         //Get Result DataRowVersion.Current
2686                         drArrResult = drChild.GetParentRows(dRel,DataRowVersion.Default  );
2687                         Assert.AreEqual(drArrExcepted, drArrResult, "DRW128");
2688
2689                         try
2690                         {
2691                                 DataTable dtOtherParent = DataProvider.CreateParentDataTable();
2692                                 DataTable dtOtherChild = DataProvider.CreateChildDataTable();
2693
2694                                 DataRelation drl = new DataRelation("newRelation",dtOtherParent.Columns[0],dtOtherChild.Columns[0]);
2695                                 drChild.GetParentRows(drl,DataRowVersion.Current);
2696                                 Assert.Fail("DRW129: failed to throw ArgumentException");
2697                         }
2698                         catch (ArgumentException) {}
2699                         catch (AssertionException exc) {throw  exc;}
2700                         catch (Exception exc)
2701                         {
2702                                 Assert.Fail("DRW130: Add. Wrong exception type. Got:" + exc);
2703                         }
2704                 }
2705
2706                 [Test]
2707                 public void ItemArray()
2708                 {
2709                         DataTable dt = GetDataTable();
2710                         DataRow dr = dt.Rows[0];
2711
2712                         Assert.AreEqual(1, (int)dr.ItemArray[0] , "DRW131" );
2713
2714                         Assert.AreEqual("Ofer", (string)dr.ItemArray[1] , "DRW132" );
2715
2716                         dt = GetDataTable();
2717
2718                         dr = dt.Rows[0];
2719
2720                         //Changing row via itemArray
2721
2722                         dt.Rows[0].ItemArray = new object[] {2,"Oren"};
2723
2724                         Assert.AreEqual(2, (Int32)dr.ItemArray[0] , "DRW133" );
2725                         Assert.AreEqual("Oren", (string)dr.ItemArray[1] , "DRW134" );
2726
2727                         try
2728                         {
2729                                 dt.Rows[0].ItemArray = new object[] {2,"Oren","some1else"};
2730                                 Assert.Fail("DRW135: failed to throw ArgumentException");
2731                         }
2732                         catch (ArgumentException) {}
2733                         catch (AssertionException exc) {throw  exc;}
2734                         catch (Exception exc)
2735                         {
2736                                 Assert.Fail("DRW136: Add. Wrong exception type. Got:" + exc);
2737                         }
2738                 }
2739
2740                 [Test]
2741                 public void ItemArray_NewTable ()
2742                 {
2743                         DataTable dt = new DataTable("Customers");
2744
2745                         dt.Columns.Add("name", typeof (string));
2746                         dt.Columns.Add("address", typeof (string));
2747                         dt.Columns.Add("phone", typeof (string));
2748
2749                         DataRow dr = dt.NewRow();
2750                         dr["name"] = "myName";
2751                         dr["address"] = "myAddress";
2752                         dr["phone"] = "myPhone";
2753
2754                         // Should not throw RowNotInTableException
2755                         object[] obj = dr.ItemArray;
2756                 }
2757
2758                 private DataTable GetDataTable()
2759                 {
2760                         DataTable dt = new DataTable("myTable");
2761                         dt.Columns.Add("Id",typeof(int));
2762                         dt.Columns.Add("Name",typeof(string));
2763
2764                         DataRow dr = dt.NewRow();
2765                         dr.ItemArray = new object[] {1,"Ofer"};
2766
2767                         dt.Rows.Add(dr);
2768
2769                         return dt;
2770                 }
2771
2772                 [Test]
2773                 public void RowError()
2774                 {
2775                         DataTable dt = new DataTable("myTable");
2776                         DataRow dr = dt.NewRow();
2777
2778                         Assert.AreEqual(string.Empty , dr.RowError, "DRW137");
2779
2780                         dr.RowError = "Err";
2781
2782                         Assert.AreEqual("Err", dr.RowError , "DRW138" );
2783
2784                         DataTable dt1 = DataProvider.CreateUniqueConstraint();
2785
2786                         try
2787                         {
2788                                 dt1.BeginLoadData();
2789
2790                                 dr = dt1.NewRow();
2791                                 dr[0] = 3;
2792                                 dt1.Rows.Add(dr);
2793                                 dt1.EndLoadData();
2794                                 Assert.Fail("DRW139: failed to throw ConstraintException");
2795                         }
2796                         catch (ConstraintException)
2797                         {
2798                                 Assert.AreEqual(2,dt1.GetErrors().Length,"DRW141");
2799                                 Assert.AreEqual(true,dt1.GetErrors()[0].RowError.Length > 10,"DRW142");
2800                                 Assert.AreEqual(true,dt1.GetErrors()[1].RowError.Length > 10,"DRW143");
2801                         }
2802                         catch (AssertionException exc) {throw  exc;}
2803                         catch (Exception exc)
2804                         {
2805                                 Assert.Fail("DRW144: Wrong exception type. Got:" + exc);
2806                         }
2807
2808
2809                         DataSet ds=null;
2810                         try
2811                         {
2812                                 ds= DataProvider.CreateForigenConstraint();
2813                                 ds.Tables[0].BeginLoadData();
2814                                 ds.Tables[0].Rows[0][0] = 10; //Forigen constraint violation
2815                                 //ds.Tables[0].AcceptChanges();
2816                                 ds.Tables[0].EndLoadData();
2817                                 Assert.Fail("DRW139: failed to throw ConstraintException");
2818                         }
2819                         catch (ConstraintException)
2820                         {
2821                                 Assert.AreEqual(3,ds.Tables[1].GetErrors().Length,"DRW145");
2822                                 for(int index=0;index<3;index++)
2823                                 {
2824                                         Assert.AreEqual(true,ds.Tables[1].GetErrors()[index].RowError.Length > 10,"RDW146");
2825                                 }
2826                         }
2827                         catch (AssertionException exc) {throw  exc;}
2828                         catch (Exception exc)
2829                         {
2830                                 Assert.Fail("DRW147: Wrong exception type. Got:" + exc);
2831                         }
2832                 }
2833
2834                 [Test]
2835                 public void bug78885 ()
2836                 {
2837                         DataSet ds = new DataSet ();
2838                         DataTable t = ds.Tables.Add ("table");
2839                         DataColumn id;
2840
2841                         id = t.Columns.Add ("userID", Type.GetType ("System.Int32"));
2842                         id.AutoIncrement = true;
2843                         t.Columns.Add ("name", Type.GetType ("System.String"));
2844                         t.Columns.Add ("address", Type.GetType ("System.String"));
2845                         t.Columns.Add ("zipcode", Type.GetType ("System.Int32"));
2846                         t.PrimaryKey = new DataColumn [] { id };
2847
2848                         DataRow tempRow;
2849                         tempRow = t.NewRow ();
2850                         tempRow ["name"] = "Joan";
2851                         tempRow ["address"] = "Balmes 152";
2852                         tempRow ["zipcode"] = "1";
2853                         t.Rows.Add (tempRow);
2854
2855                         t.RowChanged += new DataRowChangeEventHandler (RowChangedHandler);
2856
2857                         /* neither of the calls to EndEdit below generate a RowChangedHandler on MS.  the first one does on mono */
2858                         t.DefaultView [0].BeginEdit ();
2859                         t.DefaultView [0].EndEdit (); /* this generates a call to the row changed handler */
2860                         t.DefaultView [0].EndEdit (); /* this doesn't */
2861
2862                         Assert.IsFalse (_rowChanged);
2863                 }
2864
2865                 private void RowChangedHandler (object sender, DataRowChangeEventArgs e)
2866                 {
2867                         _rowChanged = true;
2868                 }
2869
2870 #if NET_2_0
2871                 [Test]
2872                 public void SetAdded_test()
2873                 {
2874                         DataTable table = new DataTable();
2875
2876                         DataRow row = table.NewRow();
2877                         try {
2878                                 row.SetAdded();
2879                                 Assert.Fail ("#1");
2880                         } catch (InvalidOperationException e) {
2881                         }
2882
2883                         table.Columns.Add("col1", typeof(int));
2884                         table.Columns.Add("col2", typeof(int));
2885                         table.Columns.Add("col3", typeof(int));
2886
2887                         row = table.Rows.Add(new object[] { 1, 2, 3 });
2888                         Assert.AreEqual(DataRowState.Added, row.RowState, "#1");
2889                         try {
2890                                 row.SetAdded();
2891                                 Assert.Fail ("#2");
2892                         } catch (InvalidOperationException e) {
2893                         }
2894                         Assert.AreEqual(DataRowState.Added, row.RowState, "#2");
2895
2896                         row.AcceptChanges();
2897                         row[0] = 10;
2898                         Assert.AreEqual(DataRowState.Modified, row.RowState, "#5");
2899                         try {
2900                                 row.SetAdded();
2901                                 Assert.Fail ("#3");
2902                         } catch (InvalidOperationException e) {
2903                         }
2904
2905                         row.AcceptChanges();
2906                         Assert.AreEqual(DataRowState.Unchanged, row.RowState, "#3");
2907                         row.SetAdded();
2908                         Assert.AreEqual(DataRowState.Added, row.RowState, "#4");
2909                 }
2910
2911                 [Test]
2912                 public void setAdded_testRollback ()
2913                 {
2914                         DataTable table = new DataTable ();
2915                         table.Columns.Add ("col1", typeof (int));
2916                         table.Columns.Add ("col2", typeof (int));
2917
2918                         table.Rows.Add (new object[] {1,1});
2919                         table.AcceptChanges ();
2920
2921                         table.Rows [0].SetAdded ();
2922                         table.RejectChanges ();
2923                         Assert.AreEqual (0, table.Rows.Count, "#1");
2924                 }
2925
2926                 [Test]
2927                 public void SetModified_test()
2928                 {
2929                         DataTable table = new DataTable();
2930
2931                         DataRow row = table.NewRow();
2932                         try {
2933                                 row.SetModified ();
2934                         } catch (InvalidOperationException) {}
2935
2936                         table.Columns.Add("col1", typeof(int));
2937                         table.Columns.Add("col2", typeof(int));
2938                         table.Columns.Add("col3", typeof(int));
2939
2940                         row = table.Rows.Add(new object[] { 1, 2, 3 });
2941                         Assert.AreEqual(DataRowState.Added, row.RowState, "#1");
2942                         try {
2943                                 row.SetModified();
2944                                 Assert.Fail ("#1");
2945                         } catch (InvalidOperationException e) {
2946                                 // Never premise English.
2947                                 //Assert.AreEqual (SetAddedModified_ErrMsg, e.Message, "#2");
2948                         }
2949
2950                         row.AcceptChanges();
2951                         row[0] = 10;
2952                         Assert.AreEqual(DataRowState.Modified, row.RowState, "#5");
2953                         try {
2954                                 row.SetModified ();
2955                                 Assert.Fail ("#2");
2956                         } catch (InvalidOperationException e) {
2957                                 // Never premise English.
2958                                 //Assert.AreEqual (SetAddedModified_ErrMsg, e.Message, "#2");
2959                         }
2960
2961                         row.AcceptChanges();
2962                         Assert.AreEqual(DataRowState.Unchanged, row.RowState, "#3");
2963                         row.SetModified ();
2964                         Assert.AreEqual(DataRowState.Modified, row.RowState, "#4");
2965                 }
2966
2967                 [Test]
2968                 public void setModified_testRollback()
2969                 {
2970                         DataTable table = new DataTable();
2971                         table.Columns.Add("col1", typeof(int));
2972                         table.Columns.Add("col2", typeof(int));
2973
2974                         DataRow row = table.Rows.Add(new object[] { 1, 1 });
2975                         table.AcceptChanges();
2976
2977                         row.SetModified ();
2978                         Assert.AreEqual(row.RowState, DataRowState.Modified, "#0");
2979                         Assert.AreEqual(1, row [0, DataRowVersion.Current], "#1");
2980                         Assert.AreEqual(1, row [0, DataRowVersion.Original], "#2");
2981                         table.RejectChanges ();
2982                         Assert.AreEqual(row.RowState, DataRowState.Unchanged, "#3");
2983                 }
2984 #endif
2985                 [Test]
2986                 public void DataRowExpressionDefaultValueTest ()
2987                 {
2988                         DataSet ds = new DataSet ();
2989                         DataTable custTable = ds.Tables.Add ("CustTable");
2990
2991                         DataColumn column = new DataColumn ("units", typeof (int));
2992                         column.AllowDBNull = false;
2993                         column.Caption = "Units";
2994                         column.DefaultValue = 1;
2995                         custTable.Columns.Add (column);
2996
2997                         column = new DataColumn ("price", typeof (decimal));
2998                         column.AllowDBNull = false;
2999                         column.Caption = "Price";
3000                         column.DefaultValue = 25;
3001                         custTable.Columns.Add (column);
3002
3003                         column = new DataColumn ("total", typeof (string));
3004                         column.Caption = "Total";
3005                         column.Expression = "price*units";
3006                         custTable.Columns.Add (column);
3007
3008                         DataRow row = custTable.NewRow ();
3009
3010                         Assert.AreEqual (DBNull.Value, row["Total"] , "#1 Should be System.DBNull");
3011                         custTable.Rows.Add (row);
3012
3013                         Assert.AreEqual ("25", row["Total"] , "#2 Should not be emptry string");
3014                 }
3015
3016                 void ColumnChanged (object sender, DataColumnChangeEventArgs e)
3017                 {
3018                         _eventsFired.Add (new EventInfo ("ColumnChanged", e));
3019                 }
3020
3021                 void ColumnChanging (object sender, DataColumnChangeEventArgs e)
3022                 {
3023                         _eventsFired.Add (new EventInfo ("ColumnChanging", e));
3024                 }
3025
3026                 class EventInfo
3027                 {
3028                         public EventInfo (string name, EventArgs args)
3029                         {
3030                                 this.name = name;
3031                                 this.args = args;
3032                         }
3033
3034                         public string Name {
3035                                 get { return name; }
3036                         }
3037
3038                         public EventArgs Args {
3039                                 get { return args; }
3040                         }
3041
3042                         private readonly string name;
3043                         private readonly EventArgs args;
3044                 }
3045
3046                 static bool AssertNotFound (DataRow rc, DataColumn dc, DataRowVersion version)
3047                 {
3048                         try {
3049                                 object value = rc [dc, version];
3050                                 return false;
3051                         } catch (VersionNotFoundException) {
3052                                 return true;
3053                         }
3054                 }
3055
3056                 class Person
3057                 {
3058                         public Person (string name)
3059                         {
3060                                 this.Name = name;
3061                         }
3062
3063                         public string Name;
3064                         public Address HomeAddress;
3065                 }
3066
3067                 struct Address
3068                 {
3069                         public Address (string street, int houseNumber)
3070                         {
3071                                 Street = street;
3072                                 HouseNumber = houseNumber;
3073                         }
3074
3075                         public override bool Equals (object o)
3076                         {
3077                                 if (!(o is Address))
3078                                         return false;
3079
3080                                 Address address = (Address) o;
3081                                 if (address.HouseNumber != HouseNumber)
3082                                         return false;
3083                                 if (address.Street != Street)
3084                                         return false;
3085                                 return true;
3086                         }
3087
3088                         public override int GetHashCode ()
3089                         {
3090                                 if (Street == null)
3091                                         return HouseNumber.GetHashCode ();
3092                                 return (Street.GetHashCode () ^ HouseNumber.GetHashCode ());
3093                         }
3094
3095                         public override string ToString ()
3096                         {
3097                                 if (Street == null)
3098                                         return HouseNumber.ToString (CultureInfo.InvariantCulture);
3099
3100                                 return string.Concat (Street, HouseNumber.ToString (CultureInfo.InvariantCulture));
3101                         }
3102
3103                         public string Street;
3104                         public int HouseNumber;
3105                 }
3106         }
3107 }