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 NUnit.Framework;
  30 using System;
  31 using System.IO;
  32 using System.ComponentModel;
  33 using System.Data;
  34 using MonoTests.System.Data.Test.Utils;
  35
  36 namespace MonoTests.System.Data
  37 {
  38         [TestFixture] public class DataRowTest2
  39         {
  40                 [Test] public void AcceptChanges()
  41                 {
  42                         DataTable myTable = new DataTable("myTable");
  43                         DataRow myRow;
  44                         myRow = myTable.NewRow();
  45                         myTable.Rows.Add(myRow);
  46
  47                         // DataRow AcceptChanges
  48                         // DataRowState.Added -> DataRowState.Unchanged
  49                         myTable.AcceptChanges();
  50                         Assert.AreEqual(DataRowState.Unchanged , myRow.RowState , "DRW1");
  51                 }
  52
  53                 [Test] public void CancelEdit()
  54                 {
  55                         DataTable myTable = new DataTable("myTable");
  56                         DataColumn dc = new DataColumn("Id",typeof(int));
  57                         dc.Unique=true;
  58                         myTable.Columns.Add(dc);
  59                         myTable.Rows.Add(new object[] {1});
  60                         myTable.Rows.Add(new object[] {2});
  61                         myTable.Rows.Add(new object[] {3});
  62
  63                         DataRow myRow = myTable.Rows[0];
  64                         myRow.BeginEdit();
  65                         myRow[0] = 7;
  66                         myRow.CancelEdit();
  67
  68                         // DataRow CancelEdit
  69                         Assert.AreEqual(true ,  (int)myRow[0] == 1, "DRW2");
  70                 }
  71
  72                 [Test] public void ClearErrors()
  73                 {
  74                         DataTable dt = new DataTable("myTable");
  75                         DataRow dr = dt.NewRow();
  76                         dr.RowError = "err";
  77
  78                         // DataRow ClearErrors
  79                         Assert.AreEqual(true ,  dr.HasErrors , "DRW3");
  80
  81                         // DataRow ClearErrors
  82                         dr.ClearErrors();
  83                         Assert.AreEqual(false ,  dr.HasErrors , "DRW4");
  84                 }
  85
  86                 [Test] public void Delete()
  87                 {
  88                         DataTable myTable = new DataTable("myTable");
  89                         DataColumn dc = new DataColumn("Id",typeof(int));
  90                         dc.Unique=true;
  91                         myTable.Columns.Add(dc);
  92                         myTable.Rows.Add(new object[] {1});
  93                         myTable.Rows.Add(new object[] {2});
  94                         myTable.Rows.Add(new object[] {3});
  95                         myTable.AcceptChanges();
  96
  97                         DataRow myRow = myTable.Rows[0];
  98                         myRow.Delete();
  99
 100                         // Delete1
 101                         Assert.AreEqual(DataRowState.Deleted  ,  myRow.RowState , "DRW5");
 102
 103                         // Delete2
 104                         myTable.AcceptChanges();
 105                         Assert.AreEqual(DataRowState.Detached  ,  myRow.RowState , "DRW6");
 106                 }
 107
 108                 [Test] public void EndEdit()
 109                 {
 110                         DataTable myTable = new DataTable("myTable");
 111                         DataColumn dc = new DataColumn("Id",typeof(int));
 112                         dc.Unique=true;
 113                         myTable.Columns.Add(dc);
 114                         myTable.Rows.Add(new object[] {1});
 115                         myTable.Rows.Add(new object[] {2});
 116                         myTable.Rows.Add(new object[] {3});
 117
 118                         DataRow myRow = myTable.Rows[0];
 119
 120                         int iProposed;
 121                         //After calling the DataRow object's BeginEdit method, if you change the value, the Current and Proposed values become available
 122                         myRow.BeginEdit();
 123                         myRow[0] = 7;
 124                         iProposed = (int)myRow[0,DataRowVersion.Proposed];
 125                         myRow.EndEdit();
 126
 127                         // EndEdit
 128                         Assert.AreEqual(iProposed ,  (int)myRow[0,DataRowVersion.Current] , "DRW7");
 129                 }
 130
 131                 [Test] public void Equals()
 132                 {
 133                         DataTable myTable = new DataTable("myTable");
 134                         DataRow dr1,dr2;
 135                         dr1 = myTable.NewRow();
 136                         dr2 = myTable.NewRow();
 137
 138                         // not equals
 139                         Assert.AreEqual(false  , dr1.Equals(dr2), "DRW8");
 140
 141                 dr1=dr2;
 142                         // equals
 143                         Assert.AreEqual(true , dr1.Equals(dr2), "DRW9");
 144                 }
 145
 146                 [Test] public void GetChildRows_ByDataRealtion()
 147                 {
 148                         DataRow dr;
 149                         DataRow[] drArrExcepted,drArrResult;
 150                         DataTable dtChild,dtParent;
 151                         DataSet ds = new DataSet();
 152
 153                         //Create tables
 154                         dtChild = DataProvider.CreateChildDataTable();
 155                         dtParent= DataProvider.CreateParentDataTable();
 156
 157                         //Add tables to dataset
 158                         ds.Tables.Add(dtChild);
 159                         ds.Tables.Add(dtParent);
 160                         dr = dtParent.Rows[0];
 161
 162                         //Add Relation
 163                         DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"]);
 164                         ds.Relations.Add(dRel);
 165                         //Get Excepted result
 166                         drArrExcepted = dtChild.Select("ParentId=" + dr["ParentId"]);
 167                         //Get Result
 168                         drArrResult = dr.GetChildRows(dRel);
 169
 170                         // GetChildRows_D
 171                         Assert.AreEqual(drArrExcepted,  drArrResult, "DRW10");
 172                 }
 173
 174                 [Test] public void GetChildRows_ByDataRealtionDataRowVersion()
 175                 {
 176                         DataRow drParent;
 177                         DataRow[] drArrExcepted,drArrResult;
 178                         DataTable dtChild,dtParent;
 179                         DataSet ds = new DataSet();
 180                         //Create tables
 181                         dtChild = DataProvider.CreateChildDataTable();
 182                         dtParent= DataProvider.CreateParentDataTable();
 183                         //Add tables to dataset
 184                         ds.Tables.Add(dtChild);
 185                         ds.Tables.Add(dtParent);
 186                         //Add Relation
 187                         DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"]);
 188                         ds.Relations.Add(dRel);
 189
 190                         drParent = dtParent.Rows[0];
 191
 192                         // Teting: DateTime.Now.ToShortTimeString()
 193                         //Get Excepted result
 194                         drArrExcepted = dtChild.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.CurrentRows );
 195                         //Get Result DataRowVersion.Current
 196                         drArrResult = drParent.GetChildRows(dRel,DataRowVersion.Current);
 197                         Assert.AreEqual(drArrExcepted,  drArrResult, "DRW11");
 198
 199                         // Teting: DataRow.GetParentRows_D_D
 200                         //Get Excepted result
 201                         drArrExcepted = dtChild.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.OriginalRows );
 202                         //Get Result DataRowVersion.Current
 203                         drArrResult = drParent.GetChildRows(dRel,DataRowVersion.Original );
 204                         Assert.AreEqual(drArrExcepted,  drArrResult, "DRW12");
 205
 206                         // Teting: DataRow.GetParentRows_D_D
 207                         //Get Excepted result, in this case Current = Default
 208                         drArrExcepted = dtChild.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.CurrentRows);
 209                         //Get Result DataRowVersion.Current
 210                         drArrResult = drParent.GetChildRows(dRel,DataRowVersion.Default  );
 211                         Assert.AreEqual(drArrExcepted,  drArrResult, "DRW13");
 212
 213                         // Teting: DataRow.GetParentRows_D_D
 214                         drParent.BeginEdit();
 215                         drParent["String1"] = "Value";
 216                         //Get Excepted result
 217                         drArrExcepted = dtChild.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.CurrentRows );
 218                         //Get Result DataRowVersion.Current
 219                         drArrResult = drParent.GetChildRows(dRel,DataRowVersion.Proposed  );
 220                         Assert.AreEqual(drArrExcepted,  drArrResult, "DRW14");
 221                 }
 222
 223                 [Test] public void GetChildRows_ByName()
 224                 {
 225                         DataRow dr;
 226                         DataRow[] drArrExcepted,drArrResult;
 227                         DataTable dtChild,dtParent;
 228                         DataSet ds = new DataSet();
 229
 230                         //Create tables
 231                         dtChild = DataProvider.CreateChildDataTable();
 232                         dtParent= DataProvider.CreateParentDataTable();
 233
 234                         //Add tables to dataset
 235                         ds.Tables.Add(dtChild);
 236                         ds.Tables.Add(dtParent);
 237                         dr = dtParent.Rows[0];
 238
 239                         //Add Relation
 240                         DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"]);
 241                         ds.Relations.Add(dRel);
 242                         //Get Excepted result
 243                         drArrExcepted = dtChild.Select("ParentId=" + dr["ParentId"]);
 244                         //Get Result
 245                         drArrResult = dr.GetChildRows("Parent-Child");
 246
 247                         // GetChildRows_S
 248                         Assert.AreEqual(drArrExcepted,  drArrResult, "DRW15");
 249                 }
 250
 251                 [Test] public void GetChildRows_ByNameDataRowVersion()
 252                 {
 253                         DataRow drParent;
 254                         DataRow[] drArrExcepted,drArrResult;
 255                         DataTable dtChild,dtParent;
 256                         DataSet ds = new DataSet();
 257                         //Create tables
 258                         dtChild = DataProvider.CreateChildDataTable();
 259                         dtParent= DataProvider.CreateParentDataTable();
 260                         //Add tables to dataset
 261                         ds.Tables.Add(dtChild);
 262                         ds.Tables.Add(dtParent);
 263                         //Add Relation
 264                         DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"]);
 265                         ds.Relations.Add(dRel);
 266
 267                         drParent = dtParent.Rows[0];
 268
 269                         // GetChildRows_SD 1
 270                         //Get Excepted result
 271                         drArrExcepted = dtChild.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.CurrentRows );
 272                         //Get Result DataRowVersion.Current
 273                         drArrResult = drParent.GetChildRows("Parent-Child",DataRowVersion.Current);
 274                         Assert.AreEqual(drArrExcepted,  drArrResult, "DRW16");
 275
 276                         // GetChildRows_SD 2
 277                         //Get Excepted result
 278                         drArrExcepted = dtChild.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.OriginalRows );
 279                         //Get Result DataRowVersion.Current
 280                         drArrResult = drParent.GetChildRows("Parent-Child",DataRowVersion.Original );
 281                         Assert.AreEqual(drArrExcepted,  drArrResult, "DRW17");
 282
 283                         // GetParentRows_SD 3
 284                         //Get Excepted result, in this case Current = Default
 285                         drArrExcepted = dtChild.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.CurrentRows);
 286                         //Get Result DataRowVersion.Current
 287                         drArrResult = drParent.GetChildRows("Parent-Child",DataRowVersion.Default  );
 288                         Assert.AreEqual(drArrExcepted,  drArrResult, "DRW18");
 289
 290                         // GetParentRows_SD 4
 291                         drParent.BeginEdit();
 292                         drParent["String1"] = "Value";
 293                         //Get Excepted result
 294                         drArrExcepted = dtChild.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.CurrentRows );
 295                         //Get Result DataRowVersion.Current
 296                         drArrResult = drParent.GetChildRows("Parent-Child",DataRowVersion.Proposed  );
 297                         Assert.AreEqual(drArrExcepted,  drArrResult, "DRW19");
 298                 }
 299
 300                 [Test] public void GetColumnError_ByIndex()
 301                 {
 302                         string sColErr = "Error!";
 303                         DataTable dt = new DataTable("myTable");
 304                         DataColumn dc = new DataColumn("Column1");
 305                         dt.Columns.Add(dc);
 306                         DataRow dr = dt.NewRow();
 307
 308                         // GetColumnError 1
 309                         Assert.AreEqual(String.Empty ,  dr.GetColumnError(0) , "DRW20");
 310
 311                         dr.SetColumnError(0,sColErr );
 312
 313                         // GetColumnError 2
 314                         Assert.AreEqual(sColErr ,  dr.GetColumnError(0) , "DRW21");
 315                 }
 316
 317                 [Test] public void GetColumnError_ByName()
 318                 {
 319                         string sColErr = "Error!";
 320                         DataTable dt = new DataTable("myTable");
 321                         DataColumn dc = new DataColumn("Column1");
 322                         dt.Columns.Add(dc);
 323                         DataRow dr = dt.NewRow();
 324
 325                         // GetColumnError 1
 326                         Assert.AreEqual(String.Empty ,  dr.GetColumnError("Column1") , "DRW22");
 327
 328                         dr.SetColumnError("Column1",sColErr );
 329
 330                         // GetColumnError 2
 331                         Assert.AreEqual(sColErr ,  dr.GetColumnError("Column1") , "DRW23");
 332                 }
 333
 334                 [Test] public void GetColumnsInError()
 335                 {
 336                         string sColErr = "Error!";
 337                         DataColumn[] dcArr;
 338                         DataTable dt = new DataTable("myTable");
 339                         //init some columns
 340                         dt.Columns.Add(new DataColumn());
 341                         dt.Columns.Add(new DataColumn());
 342                         dt.Columns.Add(new DataColumn());
 343                         dt.Columns.Add(new DataColumn());
 344                         dt.Columns.Add(new DataColumn());
 345
 346                         //init some rows
 347                         dt.Rows.Add(new object[] {});
 348                         dt.Rows.Add(new object[] {});
 349                         dt.Rows.Add(new object[] {});
 350
 351                         DataRow dr = dt.Rows[1];
 352
 353                         dcArr = dr.GetColumnsInError();
 354
 355                         // GetColumnsInError 1
 356                         Assert.AreEqual(0,  dcArr.Length , "DRW24");
 357
 358                         dr.SetColumnError(0,sColErr);
 359                         dr.SetColumnError(2,sColErr);
 360                         dr.SetColumnError(4,sColErr);
 361
 362                         dcArr = dr.GetColumnsInError();
 363
 364                         // GetColumnsInError 2
 365                         Assert.AreEqual(3, dcArr.Length , "DRW25");
 366
 367                         //check that the right columns taken
 368                         // GetColumnsInError 3
 369                         Assert.AreEqual(dt.Columns[0], dcArr[0], "DRW26");
 370
 371                         // GetColumnsInError 4
 372                         Assert.AreEqual(dt.Columns[2], dcArr[1], "DRW27");
 373
 374                         // GetColumnsInError 5
 375                         Assert.AreEqual(dt.Columns[4], dcArr[2], "DRW28");
 376                 }
 377
 378                 [Test] public new void GetHashCode()
 379                 {
 380                         int iHashCode;
 381                         DataRow dr;
 382                         DataTable dt = new DataTable();
 383                         dr = dt.NewRow();
 384
 385                         iHashCode = dr.GetHashCode();
 386                         for (int i=0; i<10; i++)
 387                         {       //must return the same value each time
 388                                 // GetHashCode #" + i
 389                                 Assert.AreEqual(dr.GetHashCode() ,  iHashCode , "DRW29");
 390                         }
 391                 }
 392
 393                 [Test] public void GetParentRow_ByDataRelation()
 394                 {
 395                         DataRow drExcepted,drResult,drChild;
 396                         DataTable dtChild,dtParent;
 397                         DataSet ds = new DataSet();
 398
 399                         //Create tables
 400                         dtChild = DataProvider.CreateChildDataTable();
 401                         dtParent = DataProvider.CreateParentDataTable();
 402
 403                         //Add tables to dataset
 404                         ds.Tables.Add(dtChild);
 405                         ds.Tables.Add(dtParent);
 406
 407                         //Add Relation
 408                         DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"]);
 409                         ds.Relations.Add(dRel);
 410
 411                         //Excepted result
 412                         drExcepted = dtParent.Rows[0];
 413
 414                         //Get Result
 415                         drChild = dtChild.Select("ParentId=" + drExcepted["ParentId"])[0];
 416                         drResult = drChild.GetParentRow(dRel);
 417
 418                         // GetParentRow_D
 419                         Assert.AreEqual(drExcepted.ItemArray,  drResult.ItemArray , "DRW30");
 420                 }
 421
 422                 [Test] public void GetParentRow_ByDataRelationDataRowVersion()
 423                 {
 424                         DataRow drParent,drChild;
 425                         DataRow drArrExcepted,drArrResult;
 426                         DataTable dtChild,dtParent;
 427                         DataSet ds = new DataSet();
 428                         //Create tables
 429                         dtChild = DataProvider.CreateChildDataTable();
 430                         dtParent= DataProvider.CreateParentDataTable();
 431                         //Add tables to dataset
 432                         ds.Tables.Add(dtChild);
 433                         ds.Tables.Add(dtParent);
 434                         //Add Relation
 435                         DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"]);
 436                         ds.Relations.Add(dRel);
 437
 438                         drParent = dtParent.Rows[0];
 439                         drChild = dtChild.Select("ParentId=" + drParent["ParentId"])[0];
 440
 441                         // GetParentRow_DD 1
 442                         //Get Excepted result
 443                         drArrExcepted = drParent;
 444                         //Get Result DataRowVersion.Current
 445                         drArrResult = drChild.GetParentRow(dRel,DataRowVersion.Current);
 446                         Assert.AreEqual(drArrExcepted.ItemArray,  drArrResult.ItemArray , "DRW31");
 447
 448                         // GetParentRow_DD 2
 449                         //Get Excepted result
 450                         drArrExcepted = drParent;
 451                         //Get Result DataRowVersion.Current
 452                         drArrResult = drChild.GetParentRow(dRel,DataRowVersion.Original );
 453                         Assert.AreEqual(drArrExcepted.ItemArray,  drArrResult.ItemArray , "DRW32");
 454
 455                         // GetParentRow_DD 3
 456                         //Get Excepted result, in this case Current = Default
 457                         drArrExcepted = drParent;
 458                         //Get Result DataRowVersion.Current
 459                         drArrResult = drChild.GetParentRow(dRel,DataRowVersion.Default  );
 460                         Assert.AreEqual(drArrExcepted.ItemArray,  drArrResult.ItemArray , "DRW33");
 461
 462                         // GetParentRow_DD 4
 463                         drChild.BeginEdit();
 464                         drChild["String1"] = "Value";
 465                         //Get Excepted result
 466                         drArrExcepted = drParent;
 467                         //Get Result DataRowVersion.Current
 468                         drArrResult = drChild.GetParentRow(dRel,DataRowVersion.Proposed  );
 469                         Assert.AreEqual(drArrExcepted.ItemArray,  drArrResult.ItemArray , "DRW34");
 470                 }
 471
 472                 [Test] public void GetParentRow_ByName()
 473                 {
 474                         DataRow drExcepted,drResult,drChild;
 475                         DataTable dtChild,dtParent;
 476                         DataSet ds = new DataSet();
 477
 478                         //Create tables
 479                         dtChild = DataProvider.CreateChildDataTable();
 480                         dtParent = DataProvider.CreateParentDataTable();
 481
 482                         //Add tables to dataset
 483                         ds.Tables.Add(dtChild);
 484                         ds.Tables.Add(dtParent);
 485
 486                         //Add Relation
 487                         DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"]);
 488                         ds.Relations.Add(dRel);
 489
 490                         //Excepted result
 491                         drExcepted = dtParent.Rows[0];
 492
 493                         //Get Result
 494                         drChild = dtChild.Select("ParentId=" + drExcepted["ParentId"])[0];
 495                         drResult = drChild.GetParentRow("Parent-Child");
 496
 497                         // GetParentRow_S
 498                         Assert.AreEqual(drExcepted.ItemArray,  drResult.ItemArray , "DRW35");
 499                 }
 500
 501                 [Test] public void GetParentRow_ByNameDataRowVersion()
 502                 {
 503                         DataRow drParent,drChild;
 504                         DataRow drArrExcepted,drArrResult;
 505                         DataTable dtChild,dtParent;
 506                         DataSet ds = new DataSet();
 507                         //Create tables
 508                         dtChild = DataProvider.CreateChildDataTable();
 509                         dtParent= DataProvider.CreateParentDataTable();
 510                         //Add tables to dataset
 511                         ds.Tables.Add(dtChild);
 512                         ds.Tables.Add(dtParent);
 513                         //Add Relation
 514                         DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"]);
 515                         ds.Relations.Add(dRel);
 516
 517                         drParent = dtParent.Rows[0];
 518                         drChild = dtChild.Select("ParentId=" + drParent["ParentId"])[0];
 519
 520                         // GetParentRow_SD 1
 521                         //Get Excepted result
 522                         drArrExcepted = drParent;
 523                         //Get Result DataRowVersion.Current
 524                         drArrResult = drChild.GetParentRow("Parent-Child",DataRowVersion.Current);
 525                         Assert.AreEqual(drArrExcepted.ItemArray,  drArrResult.ItemArray , "DRW36");
 526
 527                         // GetParentRow_SD 2
 528                         //Get Excepted result
 529                         drArrExcepted = drParent;
 530                         //Get Result DataRowVersion.Current
 531                         drArrResult = drChild.GetParentRow("Parent-Child",DataRowVersion.Original );
 532                         Assert.AreEqual(drArrExcepted.ItemArray,  drArrResult.ItemArray , "DRW37");
 533
 534                         // GetParentRow_SD 3
 535                         //Get Excepted result, in this case Current = Default
 536                         drArrExcepted = drParent;
 537                         //Get Result DataRowVersion.Current
 538                         drArrResult = drChild.GetParentRow("Parent-Child",DataRowVersion.Default  );
 539                         Assert.AreEqual(drArrExcepted.ItemArray,  drArrResult.ItemArray , "DRW38");
 540
 541                         // GetParentRow_SD 4
 542                         drChild.BeginEdit();
 543                         drChild["String1"] = "Value";
 544                         //Get Excepted result
 545                         drArrExcepted = drParent;
 546                         //Get Result DataRowVersion.Current
 547                         drArrResult = drChild.GetParentRow("Parent-Child",DataRowVersion.Proposed  );
 548                         Assert.AreEqual(drArrExcepted.ItemArray,  drArrResult.ItemArray , "DRW39");
 549                 }
 550
 551                 [Test] public void GetParentRows_ByDataRelation()
 552                 {
 553                         DataRow dr;
 554                         DataRow[] drArrExcepted,drArrResult;
 555                         DataTable dtChild,dtParent;
 556                         DataSet ds = new DataSet();
 557
 558                         //Create tables
 559                         dtChild = DataProvider.CreateChildDataTable();
 560                         dtParent = DataProvider.CreateParentDataTable();
 561
 562                         //Add tables to dataset
 563                         ds.Tables.Add(dtChild);
 564                         ds.Tables.Add(dtParent);
 565                         dr = dtParent.Rows[0];
 566
 567                         //Duplicate several rows in order to create Many to Many relation
 568                         dtParent.ImportRow(dr);
 569                         dtParent.ImportRow(dr);
 570                         dtParent.ImportRow(dr);
 571
 572                         //Add Relation
 573                         DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"],false);
 574                         ds.Relations.Add(dRel);
 575                         //Get Excepted result
 576                         drArrExcepted = dtParent.Select("ParentId=" + dr["ParentId"]);
 577                         dr = dtChild.Select("ParentId=" + dr["ParentId"])[0];
 578                         //Get Result
 579                         drArrResult = dr.GetParentRows(dRel);
 580
 581                         // GetParentRows_D
 582                         Assert.AreEqual(drArrExcepted,  drArrResult, "DRW40");
 583                 }
 584
 585                 [Test] public void GetParentRows_ByName()
 586                 {
 587                         DataRow dr;
 588                         DataRow[] drArrExcepted,drArrResult;
 589                         DataTable dtChild,dtParent;
 590                         DataSet ds = new DataSet();
 591
 592                         //Create tables
 593                         dtChild = DataProvider.CreateChildDataTable();
 594                         dtParent = DataProvider.CreateParentDataTable();
 595
 596                         //Add tables to dataset
 597                         ds.Tables.Add(dtChild);
 598                         ds.Tables.Add(dtParent);
 599                         dr = dtParent.Rows[0];
 600
 601                         //Duplicate several rows in order to create Many to Many relation
 602                         dtParent.ImportRow(dr);
 603                         dtParent.ImportRow(dr);
 604                         dtParent.ImportRow(dr);
 605
 606                         //Add Relation
 607                         DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"],false);
 608                         ds.Relations.Add(dRel);
 609                         //Get Excepted result
 610                         drArrExcepted = dtParent.Select("ParentId=" + dr["ParentId"]);
 611                         dr = dtChild.Select("ParentId=" + dr["ParentId"])[0];
 612                         //Get Result
 613                         drArrResult = dr.GetParentRows("Parent-Child");
 614
 615                         // GetParentRows_S
 616                         Assert.AreEqual(drArrExcepted,  drArrResult, "DRW41");
 617                 }
 618
 619                 [Test] public void GetParentRows_ByNameDataRowVersion()
 620                 {
 621                         DataRow drParent,drChild;
 622                         DataRow[] drArrExcepted,drArrResult;
 623                         DataTable dtChild,dtParent;
 624                         DataSet ds = new DataSet();
 625                         //Create tables
 626                         dtChild = DataProvider.CreateChildDataTable();
 627                         dtParent= DataProvider.CreateParentDataTable();
 628                         //Add tables to dataset
 629                         ds.Tables.Add(dtChild);
 630                         ds.Tables.Add(dtParent);
 631                         //Add Relation
 632                         DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"],false);
 633                         ds.Relations.Add(dRel);
 634
 635                         //Create several copies of the first row
 636                         drParent = dtParent.Rows[0];    //row[0] has versions: Default,Current,Original
 637                         dtParent.ImportRow(drParent);   //row[1] has versions: Default,Current,Original
 638                         dtParent.ImportRow(drParent);   //row[2] has versions: Default,Current,Original
 639                         dtParent.ImportRow(drParent);   //row[3] has versions: Default,Current,Original
 640                         dtParent.ImportRow(drParent);   //row[4] has versions: Default,Current,Original
 641                         dtParent.ImportRow(drParent);   //row[5] has versions: Default,Current,Original
 642                         dtParent.AcceptChanges();
 643
 644                         //Get the first child row for drParent
 645                         drChild = dtChild.Select("ParentId=" + drParent["ParentId"])[0];
 646
 647                         DataRow[] drTemp = dtParent.Select("ParentId=" + drParent["ParentId"]);
 648                         //                              Console.WriteLine("********");
 649                         //                              foreach (DataRow d in drTemp)
 650                         //                              {
 651                         //                                      CheckRowVersion(d);
 652                         //                              }
 653                         drTemp[0].BeginEdit();
 654                         drTemp[0]["String1"] = "NewValue"; //row now has versions: Proposed,Current,Original,Default
 655                         drTemp[1].BeginEdit();
 656                         drTemp[1]["String1"] = "NewValue"; //row now has versions: Proposed,Current,Original,Default
 657
 658                         //              Console.WriteLine("********");
 659                         //              foreach (DataRow d in drTemp)
 660                         //              {
 661                         //                      CheckRowVersion(d);
 662                         //              }
 663                         //              Console.WriteLine("********");
 664
 665                         // Check DataRowVersion.Current
 666                         //Check DataRowVersion.Current
 667                         drArrExcepted = dtParent.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.CurrentRows );
 668                         drArrResult = drChild.GetParentRows("Parent-Child",DataRowVersion.Current);
 669                         Assert.AreEqual(drArrExcepted,  drArrResult, "DRW42");
 670
 671                         //Check DataRowVersion.Current
 672                         // Teting: DataRow.GetParentRows_D_D ,DataRowVersion.Original
 673                         drArrExcepted = dtParent.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.OriginalRows );
 674                         drArrResult = drChild.GetParentRows("Parent-Child",DataRowVersion.Original );
 675                         Assert.AreEqual(drArrExcepted,  drArrResult, "DRW43");
 676
 677                         //Check DataRowVersion.Default
 678                         // Teting: DataRow.GetParentRows_D_D ,DataRowVersion.Default
 679                         drArrExcepted = dtParent.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.CurrentRows);
 680                         drArrResult = drChild.GetParentRows("Parent-Child",DataRowVersion.Default  );
 681                         Assert.AreEqual(drArrExcepted,  drArrResult, "DRW44");
 682
 683                 /* .Net don't work as expected
 684                         //Check DataRowVersion.Proposed
 685                         // Teting: DataRow.GetParentRows_D_D ,DataRowVersion.Proposed
 686                         drArrExcepted = dtParent.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.ModifiedCurrent);
 687                         //drArrExcepted = dtParent.Select("ParentId=" + drParent["ParentId"],"",DataViewRowState.ModifiedOriginal );
 688
 689                         drArrResult = drChild.GetParentRows("Parent-Child",DataRowVersion.Proposed  );
 690                         Assert.AreEqual(drArrExcepted,  drArrResult, "DRW45");
 691                 */
 692                 }
 693
 694                 private void CheckRowVersion(DataRow dr)
 695                 {
 696                         Console.WriteLine("");
 697                         if (dr.HasVersion(DataRowVersion.Current)) Console.WriteLine("Has " + DataRowVersion.Current.ToString());
 698                         if (dr.HasVersion(DataRowVersion.Default)) Console.WriteLine("Has " + DataRowVersion.Default.ToString());
 699                         if (dr.HasVersion(DataRowVersion.Original)) Console.WriteLine("Has " + DataRowVersion.Original.ToString());
 700                         if (dr.HasVersion(DataRowVersion.Proposed)) Console.WriteLine("Has " + DataRowVersion.Proposed.ToString());
 701                 }
 702
 703                 [Test] public new void GetType()
 704                 {
 705                         Type myType;
 706                         DataTable dt = new DataTable();
 707                         DataRow dr = dt.NewRow();
 708                         myType = typeof(DataRow);
 709
 710                         // GetType
 711                         Assert.AreEqual(typeof(DataRow), myType , "DRW46");
 712                 }
 713
 714                 [Test] public void HasErrors()
 715                 {
 716                         DataTable dt = new DataTable("myTable");
 717                         DataRow dr = dt.NewRow();
 718
 719                         // HasErrors (default)
 720                         Assert.AreEqual(false, dr.HasErrors, "DRW47");
 721
 722                         dr.RowError = "Err";
 723
 724                         // HasErrors (set/get)
 725                         Assert.AreEqual(true , dr.HasErrors , "DRW48");
 726                 }
 727
 728                 [Test] public void HasVersion_ByDataRowVersion()
 729                 {
 730                         DataTable t = new DataTable("atable");
 731                         t.Columns.Add("id", typeof(int));
 732                         t.Columns.Add("name", typeof(string));
 733                         t.Columns[0].DefaultValue = 1;
 734                         t.Columns[1].DefaultValue = "something";
 735
 736                         // row r is detached
 737                         DataRow r = t.NewRow();
 738
 739                         // HasVersion Test #10
 740                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Current) , "DRW49");
 741
 742                         // HasVersion Test #11
 743                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Original) , "DRW50");
 744
 745                         // HasVersion Test #12
 746                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Default) , "DRW51");
 747
 748                         // HasVersion Test #13
 749                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Proposed) , "DRW52");
 750
 751                         r[0] = 4;
 752                         r[1] = "four";
 753
 754                         // HasVersion Test #20
 755                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Current) , "DRW53");
 756
 757                         // HasVersion Test #21
 758                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Original) , "DRW54");
 759
 760                         // HasVersion Test #22
 761                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Default) , "DRW55");
 762
 763                         // HasVersion Test #23
 764                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Proposed) , "DRW56");
 765
 766                         t.Rows.Add(r);
 767                         // now it is "added"
 768
 769                         // HasVersion Test #30
 770                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Current) , "DRW57");
 771
 772                         // HasVersion Test #31
 773                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Original) , "DRW58");
 774
 775                         // HasVersion Test #32
 776                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Default) , "DRW59");
 777
 778                         // HasVersion Test #33
 779                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Proposed) , "DRW60");
 780
 781                         t.AcceptChanges();
 782                         // now it is "unchanged"
 783
 784                         // HasVersion Test #40
 785                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Current) , "DRW61");
 786
 787                         // HasVersion Test #41
 788                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Original) , "DRW62");
 789
 790                         // HasVersion Test #42
 791                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Default) , "DRW63");
 792
 793                         // HasVersion Test #43
 794                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Proposed) , "DRW64");
 795
 796                         r.BeginEdit();
 797                         r[1] = "newvalue";
 798
 799                         // HasVersion Test #50
 800                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Current) , "DRW65");
 801
 802                         // HasVersion Test #51
 803                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Original) , "DRW66");
 804
 805                         // HasVersion Test #52
 806                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Default) , "DRW67");
 807
 808                         // HasVersion Test #53
 809                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Proposed) , "DRW68");
 810
 811                         r.EndEdit();
 812                         // now it is "modified"
 813                         // HasVersion Test #60
 814                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Current) , "DRW69");
 815
 816                         // HasVersion Test #61
 817                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Original) , "DRW70");
 818
 819                         // HasVersion Test #62
 820                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Default) , "DRW71");
 821
 822                         // HasVersion Test #63
 823                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Proposed) , "DRW72");
 824
 825                         // this or t.AcceptChanges
 826                         r.AcceptChanges();
 827                         // now it is "unchanged" again
 828                         // HasVersion Test #70
 829                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Current) , "DRW73");
 830
 831                         // HasVersion Test #71
 832                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Original) , "DRW74");
 833
 834                         // HasVersion Test #72
 835                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Default) , "DRW75");
 836
 837                         // HasVersion Test #73
 838                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Proposed) , "DRW76");
 839
 840                         r.Delete();
 841                         // now it is "deleted"
 842
 843                         // HasVersion Test #80
 844                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Current) , "DRW77");
 845
 846                         // HasVersion Test #81
 847                         Assert.AreEqual(true , r.HasVersion(DataRowVersion.Original) , "DRW78");
 848
 849                         // HasVersion Test #82
 850                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Default) , "DRW79");
 851
 852                         // HasVersion Test #83
 853                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Proposed) , "DRW80");
 854
 855                         r.AcceptChanges();
 856                         // back to detached
 857                         // HasVersion Test #90
 858                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Current) , "DRW81");
 859
 860                         // HasVersion Test #91
 861                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Original) , "DRW82");
 862
 863                         // HasVersion Test #92
 864                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Default) , "DRW83");
 865
 866                         // HasVersion Test #93
 867                         Assert.AreEqual(false , r.HasVersion(DataRowVersion.Proposed) , "DRW84");
 868                 }
 869
 870                 [Test] public void IsNull_ByDataColumn()
 871                 {
 872                         DataTable dt = new DataTable();
 873                         DataColumn dc0 = new DataColumn("Col0",typeof(int));
 874                         DataColumn dc1 = new DataColumn("Col1",typeof(int));
 875                         dt.Columns.Add(dc0);
 876                         dt.Columns.Add(dc1);
 877                         dt.Rows.Add(new object[] {1234});
 878                         DataRow dr = dt.Rows[0];
 879
 880                         // IsNull_I 2
 881                         Assert.AreEqual(false , dr.IsNull(dc0) , "DRW85");
 882
 883                         // IsNull_I 2
 884                         Assert.AreEqual(true , dr.IsNull(dc1) , "DRW86");
 885                 }
 886
 887                 [Test] public void IsNull_ByDataColumnDataRowVersion()
 888                 {
 889                         DataTable dt = new DataTable();
 890                         DataColumn dc0 = new DataColumn("Col0",typeof(int));
 891                         DataColumn dc1 = new DataColumn("Col1",typeof(int));
 892                         dt.Columns.Add(dc0);
 893                         dt.Columns.Add(dc1);
 894                         dt.Rows.Add(new object[] {1234});
 895                         DataRow dr = dt.Rows[0];
 896
 897                         // IsNull - col0 Current
 898                         Assert.AreEqual(false, dr.IsNull(dc0,DataRowVersion.Current) , "DRW87");
 899
 900                         // IsNull - col1 Current
 901                         Assert.AreEqual(true, dr.IsNull(dc1,DataRowVersion.Current) , "DRW88");
 902
 903                         // IsNull - col0 Default
 904                         Assert.AreEqual(false, dr.IsNull(dc0,DataRowVersion.Default) , "DRW89");
 905                         // IsNull - col1 Default
 906                         Assert.AreEqual(true, dr.IsNull(dc1,DataRowVersion.Default) , "DRW90");
 907
 908                         dr.BeginEdit();
 909                         dr[0] = 9; //Change value, Create RowVersion Proposed
 910
 911                         // IsNull - col0 Proposed
 912                         Assert.AreEqual(false, dr.IsNull(dc0,DataRowVersion.Proposed) , "DRW91");
 913                         // IsNull - col1 Proposed
 914                         Assert.AreEqual(true, dr.IsNull(dc1,DataRowVersion.Proposed) , "DRW92");
 915
 916                         dr.AcceptChanges();
 917                         dr.Delete();
 918
 919                         // IsNull - col0 Original
 920                         Assert.AreEqual(false, dr.IsNull(dc0,DataRowVersion.Original) , "DRW93");
 921                 }
 922
 923                 [Test] public void IsNull_ByIndex()
 924                 {
 925                         DataTable dt = new DataTable();
 926                         DataColumn dc0 = new DataColumn("Col0",typeof(int));
 927                         DataColumn dc1 = new DataColumn("Col1",typeof(int));
 928                         dt.Columns.Add(dc0);
 929                         dt.Columns.Add(dc1);
 930                         dt.Rows.Add(new object[] {1234});
 931                         DataRow dr = dt.Rows[0];
 932
 933                         // IsNull_I 2
 934                         Assert.AreEqual(false , dr.IsNull(0) , "DRW94");
 935
 936                         // IsNull_I 2
 937                         Assert.AreEqual(true , dr.IsNull(1) , "DRW95");
 938                 }
 939
 940                 [Test] public void IsNull_ByName()
 941                 {
 942                         DataTable dt = new DataTable();
 943                         DataColumn dc0 = new DataColumn("Col0",typeof(int));
 944                         DataColumn dc1 = new DataColumn("Col1",typeof(int));
 945                         dt.Columns.Add(dc0);
 946                         dt.Columns.Add(dc1);
 947                         dt.Rows.Add(new object[] {1234});
 948                         DataRow dr = dt.Rows[0];
 949
 950 #region --- assignment  ----
 951                         // IsNull_S 1
 952                         Assert.AreEqual(false, dr.IsNull("Col0"), "DRW96");
 953
 954                         // IsNull_S 2
 955                         Assert.AreEqual(true, dr.IsNull("Col1"), "DRW97");
 956 #endregion
 957
 958 #region --- bug 3124 ---
 959
 960                         // IsNull_S 1
 961                         MemoryStream st = new MemoryStream();
 962                         StreamWriter sw = new StreamWriter(st);
 963                         sw.Write("<?xml version=\"1.0\" standalone=\"yes\"?><NewDataSet>");
 964                         sw.Write("<Table><EmployeeNo>9</EmployeeNo></Table>");
 965                         sw.Write("</NewDataSet>");
 966                         sw.Flush();
 967                         st.Position=0;
 968                         DataSet ds = new DataSet();
 969                         ds.ReadXml(st);
 970                         //  Here we add the expression column
 971                         ds.Tables[0].Columns.Add("ValueListValueMember", typeof(object), "EmployeeNo");
 972
 973                         foreach( DataRow row in ds.Tables[0].Rows )
 974                         {
 975                                 // Console.WriteLine(row["ValueListValueMember"].ToString() + " " );
 976                                 if( row.IsNull("ValueListValueMember") == true )
 977                                         Assert.AreEqual("Failed", "SubTest", "DRW98");
 978                                 else
 979                                         Assert.AreEqual("Passed", "Passed", "DRW99");
 980                         }
 981
 982 #endregion
 983                 }
 984
 985                 [Test] public void Item()
 986                 {
 987                         // init table with columns
 988                         DataTable myTable = new DataTable("myTable");
 989
 990                         myTable.Columns.Add(new DataColumn("Id",typeof(int)));
 991                         myTable.Columns.Add(new DataColumn("Name",typeof(string)));
 992                         DataColumn dc = myTable.Columns[0];
 993
 994                         myTable.Rows.Add(new object[] {1,"Ofer"});
 995                         myTable.Rows.Add(new object[] {2,"Ofer"});
 996
 997                         myTable.AcceptChanges();
 998
 999                         DataRow myRow = myTable.Rows[0];
1000
1001                         //Start checking
1002
1003                         // Item - index
1004                         Assert.AreEqual(1 , (int)myRow[0] , "DRW100");
1005
1006                         // Item - string
1007                         Assert.AreEqual(1 ,  (int)myRow["Id"] , "DRW101");
1008
1009                         // Item - Column
1010                         Assert.AreEqual(1 ,  (int)myRow[dc] , "DRW102");
1011
1012                         // Item - index,Current
1013                         Assert.AreEqual(1 ,  (int)myRow[0,DataRowVersion.Current ] , "DRW103");
1014
1015                         // Item - string,Current
1016                         Assert.AreEqual(1 ,  (int)myRow["Id",DataRowVersion.Current] , "DRW104");
1017
1018                         // Item - columnn,Current
1019                         Assert.AreEqual(1 ,  (int)myRow[dc,DataRowVersion.Current] , "DRW105");
1020
1021                         //      testMore();
1022                 }
1023
1024                 /*public void testMore()
1025                 {
1026                         DataTable dt = DataProvider.CreateParentDataTable();
1027                         dt.Rows[0].BeginEdit();
1028                         dt.Rows[0][0] = 10;
1029                         dt.Rows[0].EndEdit();
1030                         dt.AcceptChanges();
1031                 }*/
1032
1033                 [Test] public void RejectChanges()
1034                 {
1035                         DataTable dt = new DataTable();
1036                         DataColumn dc0 = new DataColumn("Col0",typeof(int));
1037                         DataColumn dc1 = new DataColumn("Col1",typeof(int));
1038                         dt.Columns.Add(dc0);
1039                         dt.Columns.Add(dc1);
1040                         dt.Rows.Add(new object[] {1234});
1041                         dt.AcceptChanges();
1042                         DataRow dr = dt.Rows[0];
1043
1044                         dr[0] = 567;
1045                         dr[1] = 789;
1046                         dr.RejectChanges();
1047
1048                         // RejectChanges - row 0
1049                         Assert.AreEqual(1234  ,  (int)dr[0], "DRW106");
1050
1051                         // RejectChanges - row 1
1052                         Assert.AreEqual(DBNull.Value  ,  dr[1] , "DRW107");
1053
1054                         dr.Delete();
1055                         dr.RejectChanges();
1056
1057                         // RejectChanges - count
1058                         Assert.AreEqual(1 ,  dt.Rows.Count , "DRW108");
1059                 }
1060
1061                 [Test] public void RowState()
1062                 {
1063                         DataTable myTable = new DataTable("myTable");
1064                         DataColumn dc = new DataColumn("Name",typeof(string));
1065                         myTable.Columns.Add(dc);
1066                         DataRow myRow;
1067
1068                         // Create a new DataRow.
1069                         myRow = myTable.NewRow();
1070
1071                         // Detached row.
1072
1073                         // Detached
1074                         Assert.AreEqual(DataRowState.Detached ,  myRow.RowState , "DRW109");
1075
1076                         myTable.Rows.Add(myRow);
1077                         // New row.
1078
1079                         // Added
1080                         Assert.AreEqual(DataRowState.Added ,  myRow.RowState , "DRW110");
1081
1082                         myTable.AcceptChanges();
1083                         // Unchanged row.
1084
1085                         // Unchanged
1086                         Assert.AreEqual(DataRowState.Unchanged ,  myRow.RowState , "DRW111");
1087
1088                         myRow["Name"] = "Scott";
1089                         // Modified row.
1090
1091                         // Modified
1092                         Assert.AreEqual(DataRowState.Modified ,  myRow.RowState , "DRW112");
1093
1094                         myRow.Delete();
1095                         // Deleted row.
1096
1097                         // Deleted
1098                         Assert.AreEqual(DataRowState.Deleted ,  myRow.RowState , "DRW113");
1099                 }
1100
1101                 [Test] public void SetColumnError_ByDataColumnError()
1102                 {
1103                         string sColErr = "Error!";
1104                         DataTable dt = new DataTable("myTable");
1105                         DataColumn dc = new DataColumn("Column1");
1106                         dt.Columns.Add(dc);
1107                         DataRow dr = dt.NewRow();
1108
1109                         // empty string
1110                         Assert.AreEqual(String.Empty,  dr.GetColumnError(dc) , "DRW114");
1111
1112                         dr.SetColumnError(dc,sColErr );
1113
1114                         // error string
1115                         Assert.AreEqual(sColErr, dr.GetColumnError(dc) , "DRW115");
1116                 }
1117
1118                 [Test] public void SetColumnError_ByIndexError()
1119                 {
1120                         string sColErr = "Error!";
1121                         DataTable dt = new DataTable("myTable");
1122                         DataColumn dc = new DataColumn("Column1");
1123                         dt.Columns.Add(dc);
1124                         DataRow dr = dt.NewRow();
1125
1126                         // empty string
1127                         Assert.AreEqual(String.Empty ,  dr.GetColumnError(0) , "DRW116");
1128
1129                         dr.SetColumnError(0,sColErr );
1130
1131                         // error string
1132                         Assert.AreEqual(sColErr  ,  dr.GetColumnError(0) , "DRW117");
1133                 }
1134
1135                 [Test] public void SetColumnError_ByColumnNameError()
1136                 {
1137                         string sColErr = "Error!";
1138                         DataTable dt = new DataTable("myTable");
1139                         DataColumn dc = new DataColumn("Column1");
1140                         dt.Columns.Add(dc);
1141                         DataRow dr = dt.NewRow();
1142
1143                         // empty string
1144                         Assert.AreEqual(String.Empty,  dr.GetColumnError("Column1") , "DRW118");
1145
1146                         dr.SetColumnError("Column1",sColErr );
1147
1148                         // error string
1149                         Assert.AreEqual(sColErr,  dr.GetColumnError("Column1") , "DRW119");
1150                 }
1151
1152                 [Test] public void SetParentRow_ByDataRow()
1153                 {
1154                         DataRow drParent,drChild;
1155                         DataRow drArrExcepted,drArrResult;
1156                         DataTable dtChild,dtParent;
1157                         DataSet ds = new DataSet();
1158                         //Create tables
1159                         dtChild = DataProvider.CreateChildDataTable();
1160                         dtParent= DataProvider.CreateParentDataTable();
1161                         //Add tables to dataset
1162                         ds.Tables.Add(dtChild);
1163                         ds.Tables.Add(dtParent);
1164                         //Add Relation
1165                         DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"]);
1166                         ds.Relations.Add(dRel);
1167
1168                         drParent = dtParent.Rows[0];
1169                         drChild = dtChild.Select("ParentId=" + drParent["ParentId"])[0];
1170
1171                         drChild.SetParentRow(drParent);
1172
1173                         //Get Excepted result
1174                         drArrExcepted = drParent;
1175                         //Get Result DataRowVersion.Current
1176                         drArrResult = drChild.GetParentRow("Parent-Child",DataRowVersion.Current);
1177
1178                         // SetParentRow
1179                         Assert.AreEqual(drArrExcepted ,  drArrResult, "DRW120");
1180                 }
1181
1182                 public void testMore()
1183                 {
1184                         DataSet ds = DataProvider.CreateForigenConstraint();
1185                         DataRow drParent = ds.Tables[0].Rows[0];
1186                         //DataRow[] drArray =  ds.Tables[1].Rows[0].GetParentRows(ds.Tables[1].ParentRelations[0]);
1187                         ds.Tables[1].Rows[0].SetParentRow(drParent);
1188                 }
1189
1190                 public void test()
1191                 {
1192                         // test SetParentRow
1193                         DataTable parent = DataProvider.CreateParentDataTable();
1194                         DataTable child = DataProvider.CreateChildDataTable();
1195                         DataRow dr = parent.Rows[0];
1196                         dr.Delete();
1197                         parent.AcceptChanges();
1198
1199                         child.Rows[0].SetParentRow(dr);
1200                 }
1201
1202                 public void checkForLoops()
1203                 {
1204                         DataSet ds = new DataSet();
1205                         //Create tables
1206                         DataTable  dtChild = DataProvider.CreateChildDataTable();
1207                         DataTable dtParent= DataProvider.CreateParentDataTable();
1208                         //Add tables to dataset
1209                         ds.Tables.Add(dtChild);
1210                         ds.Tables.Add(dtParent);
1211
1212                         dtChild.Rows.Clear();
1213                         dtParent.Rows.Clear();
1214
1215                         dtParent.ChildRelations.Add(dtParent.Columns[0],dtChild.Columns[0]);
1216                         dtChild.ChildRelations.Add(dtChild.Columns[0],dtParent.Columns[0]);
1217
1218                         dtChild.Rows[0].SetParentRow(dtParent.Rows[0]);
1219                         dtParent.Rows[0].SetParentRow(dtChild.Rows[0]);
1220                 }
1221
1222                 public void checkForLoopsAdvenced()
1223                 {
1224                         //Create tables
1225                         DataTable  dtChild = new DataTable();
1226                         dtChild.Columns.Add("Col1",typeof(int));
1227                         dtChild.Columns.Add("Col2",typeof(int));
1228
1229                         DataRelation drl = new DataRelation("drl1",dtChild.Columns[0],dtChild.Columns[1]);
1230                         dtChild.ChildRelations.Add(drl);
1231                         dtChild.Rows[0].SetParentRow(dtChild.Rows[1]);
1232                         dtChild.Rows[1].SetParentRow(dtChild.Rows[0]);
1233                 }
1234
1235                 [Test] public void SetParentRow_ByDataRowDataRelation()
1236                 {
1237                         DataRow drParent,drChild;
1238                         DataRow drArrExcepted,drArrResult;
1239                         DataTable dtChild,dtParent;
1240                         DataSet ds = new DataSet();
1241                         //Create tables
1242                         dtChild = DataProvider.CreateChildDataTable();
1243                         dtParent= DataProvider.CreateParentDataTable();
1244                         //Add tables to dataset
1245                         ds.Tables.Add(dtChild);
1246                         ds.Tables.Add(dtParent);
1247                         //Add Relation
1248                         DataRelation dRel = new DataRelation("Parent-Child",dtParent.Columns["ParentId"],dtChild.Columns["ParentId"]);
1249                         ds.Relations.Add(dRel);
1250
1251                         drParent = dtParent.Rows[0];
1252                         drChild = dtChild.Select("ParentId=" + drParent["ParentId"])[0];
1253
1254                         drChild.SetParentRow(drParent ,dRel);
1255
1256                         //Get Excepted result
1257                         drArrExcepted = drParent;
1258                         //Get Result DataRowVersion.Current
1259                         drArrResult = drChild.GetParentRow("Parent-Child",DataRowVersion.Current);
1260
1261                         // SetParentRow
1262                         Assert.AreEqual(drArrExcepted ,  drArrResult, "DRW121");
1263                 }
1264
1265                 [Test] public void Table()
1266                 {
1267                         DataTable dt1,dt2;
1268                         dt2 = new DataTable("myTable");
1269                         DataRow dr = dt2.NewRow();
1270                         dt1 = dr.Table;
1271
1272                         // ctor
1273                         Assert.AreEqual(dt2, dt1 , "DRW122");
1274                 }
1275
1276                 [Test] public new  void ToString()
1277                 {
1278                         DataRow dr;
1279                         DataTable dtParent;
1280                         dtParent= DataProvider.CreateParentDataTable();
1281                         dr = dtParent.Rows[0];
1282
1283                         // ToString
1284                         Assert.AreEqual(true, dr.ToString().ToLower().StartsWith("system.data.datarow") , "DRW123");
1285                 }
1286
1287                 [Test] public void DataRow_RowError()
1288                 {
1289                         DataTable dt = new DataTable ("myTable"); \r
1290                         DataRow dr = dt.NewRow ();\r
1291         \r
1292                         Assert.AreEqual ( dr.RowError, string.Empty );\r
1293                                                 \r
1294                         dr.RowError = "Err";
1295                         Assert.AreEqual ( dr.RowError , "Err" );
1296                 }
1297
1298                 [Test]
1299                 [ExpectedException (typeof (ConstraintException))]
1300                 public void DataRow_RowError2()
1301                 {
1302                         DataTable dt1 = DataProvider.CreateUniqueConstraint();\r
1303 \r
1304                         dt1.BeginLoadData();\r
1305 \r
1306                         DataRow  dr = dt1.NewRow();\r
1307                         dr[0] = 3;\r
1308                         dt1.Rows.Add(dr);\r
1309                         dt1.EndLoadData();
1310                 }
1311
1312                 [Test]
1313                 [ExpectedException (typeof (ConstraintException))]
1314                 public void DataRow_RowError3()
1315                 {
1316                         DataSet ds= DataProvider.CreateForigenConstraint();\r
1317                         ds.Tables[0].BeginLoadData();\r
1318                         ds.Tables[0].Rows[0][0] = 10; \r
1319                         ds.Tables[0].EndLoadData(); //Foreign constraint violation
1320                 }
1321         }
1322 }