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

   1 // DataViewTest.cs - Nunit Test Cases for for testing the DataView
   2 // class
   3 // Authors:
   4 //      Punit Kumar Todi ( punit_todi@da-iict.org )
   5 //      Patrick Kalkman  kalkman@cistron.nl
   6 //      Umadevi S (sumadevi@novell.com)
   7 //      Atsushi Enomoto (atsushi@ximian.com)
   8 //      Sureshkumar T <tsureshkumar@novell.com>
   9 //
  10 // (C) 2003 Patrick Kalkman
  11 //
  12 // Copyright (C) 2004-2005 Novell, Inc (http://www.novell.com)
  13 //
  14 // Permission is hereby granted, free of charge, to any person obtaining
  15 // a copy of this software and associated documentation files (the
  16 // "Software"), to deal in the Software without restriction, including
  17 // without limitation the rights to use, copy, modify, merge, publish,
  18 // distribute, sublicense, and/or sell copies of the Software, and to
  19 // permit persons to whom the Software is furnished to do so, subject to
  20 // the following conditions:
  21 //
  22 // The above copyright notice and this permission notice shall be
  23 // included in all copies or substantial portions of the Software.
  24 //
  25 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  26 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  27 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  28 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  29 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  30 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  31 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  32 //
  33
  34
  35
  36 using NUnit.Framework;
  37 using System;
  38 using System.Data;
  39 using System.ComponentModel;
  40 using System.IO;
  41
  42 namespace MonoTests.System.Data
  43 {
  44         [TestFixture]
  45         public class DataViewTest : Assertion
  46         {
  47                 DataTable dataTable;
  48                 DataView  dataView;
  49                 Random rndm;
  50                 int seed, rowCount;
  51                 ListChangedEventArgs listChangedArgs;
  52                 TextWriter eventWriter;
  53
  54                 DataColumn dc1;
  55                 DataColumn dc2;
  56                 DataColumn dc3;
  57                 DataColumn dc4;
  58
  59                 [SetUp]
  60                 public void GetReady ()
  61                 {
  62                         dataTable = new DataTable ("itemTable");
  63                         dc1 = new DataColumn ("itemId");
  64                         dc2 = new DataColumn ("itemName");
  65                         dc3 = new DataColumn ("itemPrice");
  66                         dc4 = new DataColumn ("itemCategory");
  67
  68                         dataTable.Columns.Add (dc1);
  69                         dataTable.Columns.Add (dc2);
  70                         dataTable.Columns.Add (dc3);
  71                         dataTable.Columns.Add (dc4);
  72                         DataRow dr;
  73                         seed = 123;
  74                         rowCount = 5;
  75                         rndm = new Random (seed);
  76                         for (int i = 1; i <= rowCount; i++) {
  77                                 dr = dataTable.NewRow ();
  78                                 dr["itemId"] = "item " + i;
  79                                 dr["itemName"] = "name " + rndm.Next ();
  80                                 dr["itemPrice"] = "Rs. " + (rndm.Next () % 1000);
  81                                 dr["itemCategory"] = "Cat " + ((rndm.Next () % 10) + 1);
  82                                 dataTable.Rows.Add (dr);
  83                         }
  84                         dataTable.AcceptChanges ();
  85                         dataView = new DataView (dataTable);
  86                         dataView.ListChanged += new ListChangedEventHandler (OnListChanged);
  87                         listChangedArgs = null;
  88                 }
  89
  90                 protected void OnListChanged (object sender, ListChangedEventArgs args)
  91                 {
  92                         listChangedArgs = args;
  93                         // for debugging
  94                         /*Console.WriteLine("EventType :: " + listChangedArgs.ListChangedType +
  95                                                           "  oldIndex  :: " + listChangedArgs.OldIndex +
  96                                                           "  NewIndex  :: " + listChangedArgs.NewIndex);*/
  97
  98                 }
  99
 100                 private void PrintTableOrView (DataTable t, string label)
 101                 {
 102                         Console.WriteLine ("\n" + label);
 103                         for (int i = 0; i<t.Rows.Count; i++){
 104                                 foreach (DataColumn dc in t.Columns)
 105                                         Console.Write (t.Rows [i][dc] + "\t");
 106                                 Console.WriteLine ("");
 107                         }
 108                         Console.WriteLine ();
 109                 }
 110
 111                 private void PrintTableOrView (DataView dv, string label)
 112                 {
 113                         Console.WriteLine ("\n" + label);
 114                         Console.WriteLine ("Sort Key :: " + dv.Sort);
 115                         for (int i = 0; i < dv.Count; i++) {
 116                                 foreach (DataColumn dc in dv.Table.Columns)
 117                                         Console.Write (dv [i].Row [dc] + "\t");
 118                                 Console.WriteLine ("");
 119                         }
 120                         Console.WriteLine ();
 121                 }
 122
 123                 [TearDown]
 124                 public void Clean ()
 125                 {
 126                         dataTable = null;
 127                         dataView = null;
 128                 }
 129
 130                 [Test]
 131                 public void TestSort ()
 132                 {
 133                         DataView dv = new DataView ();
 134                         dv.Sort = "abc";
 135                         dv.Sort = string.Empty;
 136                         dv.Sort = "abc";
 137                         AssertEquals ("test#01", "abc", dv.Sort);
 138                 }
 139
 140                 [Test]
 141                 public void DataView ()
 142                 {
 143                         DataView dv1,dv2,dv3;
 144                         dv1 = new DataView ();
 145                         // AssertEquals ("test#01",null,dv1.Table);
 146                         AssertEquals ("test#02",true,dv1.AllowNew);
 147                         AssertEquals ("test#03",true,dv1.AllowEdit);
 148                         AssertEquals ("test#04",true,dv1.AllowDelete);
 149                         AssertEquals ("test#05",false,dv1.ApplyDefaultSort);
 150                         AssertEquals ("test#06",string.Empty,dv1.RowFilter);
 151                         AssertEquals ("test#07",DataViewRowState.CurrentRows,dv1.RowStateFilter);
 152                         AssertEquals ("test#08",string.Empty,dv1.Sort);
 153
 154                         dv2 = new DataView (dataTable);
 155                         AssertEquals ("test#09","itemTable",dv2.Table.TableName);
 156                         AssertEquals ("test#10",string.Empty,dv2.Sort);
 157                         AssertEquals ("test#11",false,dv2.ApplyDefaultSort);
 158                         AssertEquals ("test#12",dataTable.Rows[0],dv2[0].Row);
 159
 160                         dv3 = new DataView (dataTable,"","itemId DESC",DataViewRowState.CurrentRows);
 161                         AssertEquals ("test#13","",dv3.RowFilter);
 162                         AssertEquals ("test#14","itemId DESC",dv3.Sort);
 163                         AssertEquals ("test#15",DataViewRowState.CurrentRows,dv3.RowStateFilter);
 164                         //AssertEquals ("test#16",dataTable.Rows.[(dataTable.Rows.Count-1)],dv3[0]);
 165                 }
 166
 167                  [Test]
 168                  public void TestValue ()
 169                  {
 170                         DataView TestView = new DataView (dataTable);
 171                         Assertion.AssertEquals ("Dv #1", "item 1", TestView [0]["itemId"]);
 172                  }
 173
 174                  [Test]
 175                  public void TestCount ()
 176                  {
 177                         DataView TestView = new DataView (dataTable);
 178                         Assertion.AssertEquals ("Dv #3", 5, TestView.Count);
 179                  }
 180
 181                 [Test]
 182                 public void AllowNew ()
 183                 {
 184                         AssertEquals ("test#01",true,dataView.AllowNew);
 185                 }
 186
 187                 [Test]
 188                 public void ApplyDefaultSort ()
 189                 {
 190                         UniqueConstraint uc = new UniqueConstraint (dataTable.Columns["itemId"]);
 191                         dataTable.Constraints.Add (uc);
 192                         dataView.ApplyDefaultSort = true;
 193                         // dataView.Sort = "itemName";
 194                         // AssertEquals ("test#01","item 1",dataView[0]["itemId"]);
 195                         AssertEquals ("test#02",ListChangedType.Reset,listChangedArgs.ListChangedType);
 196                         // UnComment the line below to see if dataView is sorted
 197                         //   PrintTableOrView (dataView,"* OnApplyDefaultSort");
 198                 }
 199
 200                 [Test]
 201                 public void RowStateFilter ()
 202                 {
 203                         dataView.RowStateFilter = DataViewRowState.Deleted;
 204                         AssertEquals ("test#01",ListChangedType.Reset,listChangedArgs.ListChangedType);
 205                 }
 206
 207                 [Test]
 208                 public void RowStateFilter_2 ()
 209                 {
 210                         DataSet dataset = new DataSet ("new");
 211                         DataTable dt = new DataTable ("table1");
 212                         dataset.Tables.Add (dt);
 213                         dt.Columns.Add ("col1");
 214                         dt.Columns.Add ("col2");
 215                         dt.Rows.Add (new object [] {1,1});
 216                         dt.Rows.Add (new object [] {1,2});
 217                         dt.Rows.Add (new object [] {1,3});
 218                         dataset.AcceptChanges ();
 219
 220                         DataView dataView = new DataView (dataset.Tables [0]);
 221
 222                         // 'new'  table in this sample contains 6 records
 223                         dataView.AllowEdit = true;
 224                         dataView.AllowDelete = true;
 225                         string v;
 226
 227                         // Editing the row
 228                         dataView [0] ["col1"] = -1;
 229                         dataView.RowStateFilter = DataViewRowState.ModifiedOriginal;
 230                         v = dataView [0] [0].ToString ();
 231                         AssertEquals ("ModifiedOriginal.Count", 1, dataView.Count);
 232                         AssertEquals ("ModifiedOriginal.Value", "1", v);
 233
 234                         // Deleting the row
 235                         dataView.Delete (0);
 236                         dataView.RowStateFilter = DataViewRowState.Deleted;
 237
 238                         v = dataView [0] [0].ToString ();
 239                         AssertEquals ("Deleted.Count", 1, dataView.Count);
 240                         AssertEquals ("Deleted.Value", "1", v);
 241                 }
 242
 243                 //xamarin bug #18898 # / novell bug #595899
 244                 [Test]
 245                 public void Bug18898 ()
 246                 {
 247                         var table = new DataTable();
 248                         table.Columns.Add("col1");
 249                         table.Columns.Add("col2");
 250
 251                         table.Rows.Add("1", "2");
 252                         table.Rows.Add("4", "3");
 253
 254                         table.AcceptChanges();
 255
 256                         table.Rows.Add("5", "6");
 257
 258                         DataView dv = new DataView(table, string.Empty, string.Empty, DataViewRowState.Added);
 259                         dv.AllowNew = true;
 260                         var new_row = dv.AddNew();
 261                         new_row[0] = "7";
 262                         new_row[1] = "8";
 263
 264                         var another_new_row = dv.AddNew();
 265                         another_new_row[0] = "9";
 266                         another_new_row[1] = "10";
 267
 268                         AssertEquals ("#1", dv[2][0], "9");
 269
 270                         //This should not throw a System.Data.VersionNotFoundException: "There is no Proposed data to accces"
 271                         AssertEquals ("#1", dv[1][0], "7");
 272
 273                 }
 274
 275                 [Test]
 276                 public void NullTableGetItemPropertiesTest ()
 277                 {
 278                         DataView dataview = new DataView ();
 279                         PropertyDescriptorCollection col = ((ITypedList)dataview).GetItemProperties (null);
 280                         AssertEquals ("1", 0, col.Count);
 281                 }
 282
 283                 #region Sort Tests
 284                 [Test]
 285                 public void SortListChangedTest ()
 286                 {
 287                         dataView.Sort = "itemName DESC";
 288                         AssertEquals ("test#01",ListChangedType.Reset,listChangedArgs.ListChangedType);
 289                         // UnComment the line below to see if dataView is sorted
 290                         // PrintTableOrView (dataView);
 291                 }
 292
 293
 294                 [Test]
 295                 public void SortTestWeirdColumnName ()
 296                 {
 297                         DataTable dt = new DataTable ();
 298                         dt.Columns.Add ("id]", typeof (int));
 299                         dt.Columns.Add ("[id", typeof (int));
 300
 301                         DataView dv = dt.DefaultView;
 302                         dv.Sort = "id]";
 303                         //dv.Sort = "[id"; // this is not allowed
 304                         dv.Sort = "[id]]";
 305                         dv.Sort = "[[id]";
 306                         dv.Sort = "id] ASC";
 307                         dv.Sort = "[id]] DESC";
 308                         dv.Sort = "[[id] ASC";
 309                 }
 310
 311
 312                 [Test]
 313                 public void SortTests ()
 314                 {
 315                         DataTable dataTable = new DataTable ("itemTable");
 316                         DataColumn dc1 = new DataColumn ("itemId", typeof(int));
 317                         DataColumn dc2 = new DataColumn ("itemName", typeof(string));
 318
 319                         dataTable.Columns.Add (dc1);
 320                         dataTable.Columns.Add (dc2);
 321
 322                         dataTable.Rows.Add (new object[2] { 1, "First entry" });
 323                         dataTable.Rows.Add (new object[2] { 0, "Second entry" });
 324                         dataTable.Rows.Add (new object[2] { 3, "Third entry" });
 325                         dataTable.Rows.Add (new object[2] { 2, "Fourth entry" });
 326
 327                         DataView dataView = dataTable.DefaultView;
 328
 329                         string s = "Default sorting: ";
 330                         AssertEquals (s + "First entry has wrong item", 1, dataView[0][0]);
 331                         AssertEquals (s + "Second entry has wrong item", 0, dataView[1][0]);
 332                         AssertEquals (s + "Third entry has wrong item", 3, dataView[2][0]);
 333                         AssertEquals (s + "Fourth entry has wrong item", 2, dataView[3][0]);
 334
 335                         s = "Ascending sorting 1: ";
 336                         dataView.Sort = "itemId ASC";
 337                         AssertEquals (s + "First entry has wrong item", 0, dataView[0][0]);
 338                         AssertEquals (s + "Second entry has wrong item", 1, dataView[1][0]);
 339                         AssertEquals (s + "Third entry has wrong item", 2, dataView[2][0]);
 340                         AssertEquals (s + "Fourth entry has wrong item", 3, dataView[3][0]);
 341
 342                         // bug #77104 (2-5)
 343                         s = "Ascending sorting 2: ";
 344                         dataView.Sort = "itemId     ASC";
 345                         AssertEquals (s + "First entry has wrong item", 0, dataView[0][0]);
 346                         AssertEquals (s + "Second entry has wrong item", 1, dataView[1][0]);
 347                         AssertEquals (s + "Third entry has wrong item", 2, dataView[2][0]);
 348                         AssertEquals (s + "Fourth entry has wrong item", 3, dataView[3][0]);
 349
 350                         s = "Ascending sorting 3: ";
 351                         dataView.Sort = "[itemId] ASC";
 352                         AssertEquals (s + "First entry has wrong item", 0, dataView[0][0]);
 353                         AssertEquals (s + "Second entry has wrong item", 1, dataView[1][0]);
 354                         AssertEquals (s + "Third entry has wrong item", 2, dataView[2][0]);
 355                         AssertEquals (s + "Fourth entry has wrong item", 3, dataView[3][0]);
 356
 357                         s = "Ascending sorting 4: ";
 358                         dataView.Sort = "[itemId]       ASC";
 359                         AssertEquals (s + "First entry has wrong item", 0, dataView[0][0]);
 360                         AssertEquals (s + "Second entry has wrong item", 1, dataView[1][0]);
 361                         AssertEquals (s + "Third entry has wrong item", 2, dataView[2][0]);
 362                         AssertEquals (s + "Fourth entry has wrong item", 3, dataView[3][0]);
 363
 364                         s = "Ascending sorting 5: ";
 365                         try {
 366                                 dataView.Sort = "itemId \tASC";
 367                                 AssertEquals (s + "Tab cannot be a separator" , true, false);
 368                         }catch (IndexOutOfRangeException e) {
 369                         }
 370
 371                         s = "Descending sorting : ";
 372                         dataView.Sort = "itemId DESC";
 373                         AssertEquals (s + "First entry has wrong item", 3, dataView[0][0]);
 374                         AssertEquals (s + "Second entry has wrong item", 2, dataView[1][0]);
 375                         AssertEquals (s + "Third entry has wrong item", 1, dataView[2][0]);
 376                         AssertEquals (s + "Fourth entry has wrong item", 0, dataView[3][0]);
 377
 378                         s = "Reverted to default sorting: ";
 379                         dataView.Sort = null;
 380                         AssertEquals (s + "First entry has wrong item", 1, dataView[0][0]);
 381                         AssertEquals (s + "Second entry has wrong item", 0, dataView[1][0]);
 382                         AssertEquals (s + "Third entry has wrong item", 3, dataView[2][0]);
 383                         AssertEquals (s + "Fourth entry has wrong item", 2, dataView[3][0]);
 384                 }
 385
 386                 #endregion // Sort Tests
 387
 388                 [Test]
 389                 [ExpectedException(typeof(DataException))]
 390                 public void AddNew_1 ()
 391                 {
 392                         dataView.AllowNew = false;
 393                         DataRowView drv = dataView.AddNew ();
 394                 }
 395
 396                 [Test]
 397                 public void AddNew_2 ()
 398                 {
 399                         dataView.AllowNew = true;
 400                         DataRowView drv = dataView.AddNew ();
 401                         AssertEquals ("test#01",ListChangedType.ItemAdded,listChangedArgs.ListChangedType);
 402                         AssertEquals ("test#02",-1,listChangedArgs.OldIndex);
 403                         AssertEquals ("test#03",5,listChangedArgs.NewIndex);
 404                         AssertEquals ("test#04",drv["itemName"],dataView [dataView.Count - 1]["itemName"]);
 405                         listChangedArgs = null;
 406                         drv["itemId"] = "item " + 1001;
 407                         drv["itemName"] = "name " + rndm.Next();
 408                         drv["itemPrice"] = "Rs. " + (rndm.Next() % 1000);
 409                         drv["itemCategory"] = "Cat " + ((rndm.Next() % 10) + 1);
 410                         // Actually no events are arisen when items are set.
 411                         AssertNull ("test#05", listChangedArgs);
 412                         drv.CancelEdit ();
 413                         AssertEquals ("test#06",ListChangedType.ItemDeleted,listChangedArgs.ListChangedType);
 414                         AssertEquals ("test#07",-1,listChangedArgs.OldIndex);
 415                         AssertEquals ("test#08",5,listChangedArgs.NewIndex);
 416                 }
 417
 418                 [Test]
 419                 public void BeginInit ()
 420                 {
 421                         DataTable table = new DataTable ("table");
 422                         DataView dv = new DataView ();
 423                         DataColumn col1 = new DataColumn ("col1");
 424                         DataColumn col2 = new DataColumn ("col2");
 425
 426                         dv.BeginInit ();
 427                         table.BeginInit ();
 428                         table.Columns.AddRange (new DataColumn[] {col1,col2});
 429
 430                         dv.Table = table;
 431                         AssertNull ("#1", dv.Table);
 432                         dv.EndInit ();
 433
 434                         AssertEquals ("#2", table, dv.Table);
 435                         AssertEquals ("#3", 0, table.Columns.Count);
 436
 437                         table.EndInit ();
 438                         AssertEquals ("#4", 2, table.Columns.Count);
 439                 }
 440
 441                 private bool dvInitialized;
 442                 private void OnDataViewInitialized (object src, EventArgs args)
 443                 {
 444                         dvInitialized = true;
 445                 }
 446                 [Test]
 447                 public void BeginInit2 ()
 448                 {
 449                         DataTable table = new DataTable ("table");
 450                         DataView dv = new DataView ();
 451                         DataColumn col1 = new DataColumn ("col1");
 452                         DataColumn col2 = new DataColumn ("col2");
 453
 454                         dvInitialized = false;
 455
 456                         dv.Initialized += new EventHandler (OnDataViewInitialized);
 457
 458                         dv.BeginInit ();
 459                         table.BeginInit ();
 460                         table.Columns.AddRange (new DataColumn[] {col1,col2});
 461
 462                         dv.Table = table;
 463                         AssertNull ("#1", dv.Table);
 464                         dv.EndInit ();
 465
 466                         dv.Initialized -= new EventHandler (OnDataViewInitialized);
 467
 468                         AssertEquals ("#2", table, dv.Table);
 469                         AssertEquals ("#3", 0, table.Columns.Count);
 470
 471                         table.EndInit ();
 472                         AssertEquals ("#4", 2, table.Columns.Count);
 473                         AssertEquals("DataViewInitialized #5", dvInitialized, true);
 474                 }
 475
 476                 [Test]
 477                 [ExpectedException(typeof(ArgumentException))]
 478                 public void Find_1 ()
 479                 {
 480                         /* since the sort key is not specified. Must raise a ArgumentException */
 481                         int sIndex = dataView.Find ("abc");
 482                 }
 483
 484                 [Test]
 485                 public void Find_2 ()
 486                 {
 487                         int randInt;
 488                         DataRowView drv;
 489                         randInt = rndm.Next () % rowCount;
 490                         dataView.Sort = "itemId";
 491                         drv = dataView [randInt];
 492                         AssertEquals ("test#01",randInt,dataView.Find (drv ["itemId"]));
 493
 494                         dataView.Sort = "itemId DESC";
 495                         drv = dataView [randInt];
 496                         AssertEquals ("test#02",randInt,dataView.Find (drv ["itemId"]));
 497
 498                         dataView.Sort = "itemId, itemName";
 499                         drv = dataView [randInt];
 500                         object [] keys = new object [2];
 501                         keys [0] = drv ["itemId"];
 502                         keys [1] = drv ["itemName"];
 503                         AssertEquals ("test#03",randInt,dataView.Find (keys));
 504
 505                         dataView.Sort = "itemId";
 506                         AssertEquals ("test#04",-1,dataView.Find("no item"));
 507
 508                 }
 509
 510                 [Test]
 511                 [ExpectedException (typeof (ArgumentException))]
 512                 public void Find_3 ()
 513                 {
 514                         dataView.Sort = "itemID, itemName";
 515                         /* expecting order key count mismatch */
 516                         dataView.Find ("itemValue");
 517                 }
 518
 519                 [Test]
 520                 [Ignore("Test code not implemented")]
 521                 public void GetEnumerator ()
 522                 {
 523                         //TODO
 524                 }
 525
 526                 [Test]
 527                 public void ToStringTest ()
 528                 {
 529                         AssertEquals ("test#01","System.Data.DataView",dataView.ToString());
 530                 }
 531
 532                 [Test]
 533                 public void TestingEventHandling ()
 534                 {
 535                         dataView.Sort = "itemId";
 536                         DataRow dr;
 537                         dr = dataTable.NewRow ();
 538                         dr ["itemId"] = "item 0";
 539                         dr ["itemName"] = "name " + rndm.Next ();
 540                         dr ["itemPrice"] = "Rs. " + (rndm.Next () % 1000);
 541                         dr ["itemCategory"] = "Cat " + ((rndm.Next () % 10) + 1);
 542                         dataTable.Rows.Add(dr);
 543
 544                         //PrintTableOrView(dataView, "ItemAdded");
 545                         AssertEquals ("test#01",ListChangedType.ItemAdded,listChangedArgs.ListChangedType);
 546                         listChangedArgs = null;
 547
 548                         dr ["itemId"] = "aitem 0";
 549                         // PrintTableOrView(dataView, "ItemChanged");
 550                         AssertEquals ("test#02",ListChangedType.ItemChanged,listChangedArgs.ListChangedType);
 551                         listChangedArgs = null;
 552
 553                         dr ["itemId"] = "zitem 0";
 554                         // PrintTableOrView(dataView, "ItemMoved");
 555                         AssertEquals ("test#03",ListChangedType.ItemMoved,listChangedArgs.ListChangedType);
 556                         listChangedArgs = null;
 557
 558                         dataTable.Rows.Remove (dr);
 559                         // PrintTableOrView(dataView, "ItemDeleted");
 560                         AssertEquals ("test#04",ListChangedType.ItemDeleted,listChangedArgs.ListChangedType);
 561
 562                         listChangedArgs = null;
 563                         DataColumn dc5 = new DataColumn ("itemDesc");
 564                         dataTable.Columns.Add (dc5);
 565                         // PrintTableOrView(dataView, "PropertyDescriptorAdded");
 566                         AssertEquals ("test#05",ListChangedType.PropertyDescriptorAdded,listChangedArgs.ListChangedType);
 567
 568                         listChangedArgs = null;
 569                         dc5.ColumnName = "itemDescription";
 570                         // PrintTableOrView(dataView, "PropertyDescriptorChanged");
 571                         // AssertEquals ("test#06",ListChangedType.PropertyDescriptorChanged,listChangedArgs.ListChangedType);
 572
 573                         listChangedArgs = null;
 574                         dataTable.Columns.Remove (dc5);
 575                         // PrintTableOrView(dataView, "PropertyDescriptorDeleted");
 576                         AssertEquals ("test#07",ListChangedType.PropertyDescriptorDeleted,listChangedArgs.ListChangedType);
 577                 }
 578
 579                 [Test]
 580                 public void TestFindRows ()
 581                 {
 582                         DataView TestView = new DataView (dataTable);
 583                         TestView.Sort = "itemId";
 584                         DataRowView[] Result = TestView.FindRows ("item 3");
 585                         Assertion.AssertEquals ("Dv #1", 1, Result.Length);
 586                         Assertion.AssertEquals ("Dv #2", "item 3", Result [0]["itemId"]);
 587                 }
 588
 589                 [Test]
 590                 [ExpectedException (typeof (ArgumentException))]
 591                 public void FindRowsWithoutSort ()
 592                 {
 593                         DataTable dt = new DataTable ("table");
 594                         dt.Columns.Add ("col1");
 595                         dt.Columns.Add ("col2");
 596                         dt.Columns.Add ("col3");
 597                         dt.Rows.Add (new object [] {1,2,3});
 598                         dt.Rows.Add (new object [] {4,5,6});
 599                         dt.Rows.Add (new object [] {4,7,8});
 600                         dt.Rows.Add (new object [] {5,7,8});
 601                         dt.Rows.Add (new object [] {4,8,9});
 602                         DataView dv = new DataView (dt);
 603                         dv.Find (1);
 604                 }
 605
 606                 [Test]
 607                 [ExpectedException (typeof (ArgumentException))]
 608                 public void FindRowsInconsistentKeyLength ()
 609                 {
 610                         DataTable dt = new DataTable ("table");
 611                         dt.Columns.Add ("col1");
 612                         dt.Columns.Add ("col2");
 613                         dt.Columns.Add ("col3");
 614                         dt.Rows.Add (new object [] {1,2,3});
 615                         dt.Rows.Add (new object [] {4,5,6});
 616                         dt.Rows.Add (new object [] {4,7,8});
 617                         dt.Rows.Add (new object [] {5,7,8});
 618                         dt.Rows.Add (new object [] {4,8,9});
 619                         DataView dv = new DataView (dt, null, "col1",
 620                                 DataViewRowState.CurrentRows);
 621                         dv.FindRows (new object [] {1, 2, 3});
 622                 }
 623
 624                 [Test]
 625                 [ExpectedException (typeof (DeletedRowInaccessibleException))]
 626                 public void TestDelete ()
 627                 {
 628                         DataView TestView = new DataView (dataTable);
 629                         TestView.Delete (0);
 630                         DataRow r = TestView.Table.Rows [0];
 631                         Assertion.Assert ("Dv #1", !((string)r ["itemId"] == "item 1"));
 632                 }
 633
 634                 [Test]
 635                 [ExpectedException (typeof (IndexOutOfRangeException))]
 636                 public void TestDeleteOutOfBounds ()
 637                 {
 638                         DataView TestView = new DataView (dataTable);
 639                         TestView.Delete (100);
 640                 }
 641
 642                 [Test]
 643                 [ExpectedException (typeof (DataException))]
 644                 public void TestDeleteNotAllowed ()
 645                  {
 646                         DataView TestView = new DataView (dataTable);
 647                         TestView.AllowDelete = false;
 648                         TestView.Delete (0);
 649                 }
 650
 651                 [Test]
 652                 [ExpectedException (typeof (DataException))]
 653                 public void TestDeleteClosed ()
 654                 {
 655                         DataView TestView = new DataView (dataTable);
 656                         TestView.Dispose (); // Close the table
 657                         TestView.Delete (0);
 658                 }
 659
 660                 [Test] // based on bug #74631
 661                 public void TestDeleteAndCount ()
 662                 {
 663                         DataSet dataset = new DataSet ("new");
 664                         DataTable dt = new DataTable ("table1");
 665                         dataset.Tables.Add (dt);
 666                         dt.Columns.Add ("col1");
 667                         dt.Columns.Add ("col2");
 668                         dt.Rows.Add (new object []{1,1});
 669                         dt.Rows.Add (new object []{1,2});
 670                         dt.Rows.Add (new object []{1,3});
 671
 672                         DataView dataView = new DataView (dataset.Tables[0]);
 673
 674                         AssertEquals ("before delete", 3, dataView.Count);
 675                         dataView.AllowDelete = true;
 676
 677                         // Deleting the first row
 678                         dataView.Delete (0);
 679
 680                         AssertEquals ("before delete", 2, dataView.Count);
 681                 }
 682
 683                 [Test]
 684                 public void ListChangeOnSetItem ()
 685                 {
 686                         DataTable dt = new DataTable ("table");
 687                         dt.Columns.Add ("col1");
 688                         dt.Columns.Add ("col2");
 689                         dt.Columns.Add ("col3");
 690                         dt.Rows.Add (new object [] {1, 2, 3});
 691                         dt.AcceptChanges ();
 692                         DataView dv = new DataView (dt);
 693                         dv.ListChanged += new ListChangedEventHandler (OnChange);
 694                         dv [0] ["col1"] = 4;
 695                 }
 696
 697                 ListChangedEventArgs ListChangeArgOnSetItem;
 698
 699                 void OnChange (object o, ListChangedEventArgs e)
 700                 {
 701                         if (ListChangeArgOnSetItem != null)
 702                                 throw new Exception ("The event is already fired.");
 703                         ListChangeArgOnSetItem = e;
 704                 }
 705
 706                 [Test]
 707                 public void CancelEditAndEvents ()
 708                 {
 709                         string reference = " =====ItemAdded:3 ------4 =====ItemAdded:4 ------5 =====ItemAdded:5 ------6 =====ItemDeleted:5 ------5 =====ItemAdded:5";
 710
 711                         eventWriter = new StringWriter ();
 712
 713                         DataTable dt = new DataTable ();
 714                         dt.Columns.Add ("col1");
 715                         dt.Columns.Add ("col2");
 716                         dt.Columns.Add ("col3");
 717                         dt.Rows.Add (new object [] {1,2,3});
 718                         dt.Rows.Add (new object [] {1,2,3});
 719                         dt.Rows.Add (new object [] {1,2,3});
 720
 721                         DataView dv = new DataView (dt);
 722                         dv.ListChanged += new ListChangedEventHandler (ListChanged);
 723                         DataRowView a1 = dv.AddNew ();
 724                         eventWriter.Write (" ------" + dv.Count);
 725                         // I wonder why but MS fires another event here.
 726                         a1 = dv.AddNew ();
 727                         eventWriter.Write (" ------" + dv.Count);
 728                         // I wonder why but MS fires another event here.
 729                         DataRowView a2 = dv.AddNew ();
 730                         eventWriter.Write (" ------" + dv.Count);
 731                         a2.CancelEdit ();
 732                         eventWriter.Write (" ------" + dv.Count);
 733                         DataRowView a3 = dv.AddNew ();
 734
 735                         AssertEquals (reference, eventWriter.ToString ());
 736                 }
 737
 738                 [Test]
 739                 public void ColumnChangeName ()
 740                 {
 741                         string result = @"setting table...
 742 ---- OnListChanged PropertyDescriptorChanged,0,0
 743 ----- UpdateIndex : True
 744 ---- OnListChanged Reset,-1,-1
 745 table was set.
 746 ---- OnListChanged PropertyDescriptorChanged,0,0
 747 ";
 748
 749                         eventWriter = new StringWriter ();
 750
 751                         ComplexEventSequence1View dv =
 752                                 new ComplexEventSequence1View (dataTable, eventWriter);
 753
 754                         dc2.ColumnName = "new_column_name";
 755
 756                         AssertEquals (result.Replace ("\r\n", "\n"), eventWriter.ToString ().Replace ("\r\n", "\n"));
 757                 }
 758
 759                 private void ListChanged (object o, ListChangedEventArgs e)
 760                 {
 761                         eventWriter.Write (" =====" + e.ListChangedType + ":" + e.NewIndex);
 762                 }
 763
 764                 [Test]
 765                 [NUnit.Framework.Category ("NotWorking")]
 766                 public void ComplexEventSequence2 ()
 767                 {
 768                         string result = @"setting table...
 769 ---- OnListChanged PropertyDescriptorChanged,0,0
 770 ----- UpdateIndex : True
 771 ---- OnListChanged Reset,-1,-1
 772 table was set.
 773 ---- OnListChanged PropertyDescriptorAdded,0,0
 774  col1 added.
 775 ---- OnListChanged PropertyDescriptorAdded,0,0
 776  col2 added.
 777 ---- OnListChanged PropertyDescriptorAdded,0,0
 778  col3 added.
 779 ---- OnListChanged Reset,-1,-1
 780 added tables to dataset
 781 ---- OnListChanged PropertyDescriptorAdded,0,0
 782 added relation 1
 783 ---- OnListChanged PropertyDescriptorAdded,0,0
 784 added relation 2
 785 ---- OnListChanged PropertyDescriptorDeleted,0,0
 786 removed relation 2
 787 ";
 788
 789                         eventWriter = new StringWriter ();
 790
 791                         DataSet ds = new DataSet ();
 792                         DataTable dt = new DataTable ("table");
 793                         DataTable dt2 = new DataTable ("table2");
 794                         ComplexEventSequence1View dv =
 795                                 new ComplexEventSequence1View (dt, eventWriter);
 796                         dt.Columns.Add ("col1");
 797                         eventWriter.WriteLine (" col1 added.");
 798                         dt.Columns.Add ("col2");
 799                         eventWriter.WriteLine (" col2 added.");
 800                         dt.Columns.Add ("col3");
 801                         eventWriter.WriteLine (" col3 added.");
 802
 803                         dt2.Columns.Add ("col1");
 804                         dt2.Columns.Add ("col2");
 805                         dt2.Columns.Add ("col3");
 806
 807                         ds.Tables.Add (dt);
 808                         ds.Tables.Add (dt2);
 809
 810                         eventWriter.WriteLine ("added tables to dataset");
 811                         ds.Relations.Add ("Relation", dt.Columns ["col1"], dt2.Columns ["col1"]);
 812                         eventWriter.WriteLine ("added relation 1");
 813
 814                         DataRelation dr = ds.Relations.Add ("Relation2", dt2.Columns ["col2"], dt.Columns ["col2"]);
 815                         eventWriter.WriteLine ("added relation 2");
 816
 817                         ds.Relations.Remove (dr);
 818                         eventWriter.WriteLine ("removed relation 2");
 819
 820                         AssertEquals (result.Replace ("\r\n", "\n"), eventWriter.ToString ().Replace ("\r\n", "\n"));
 821                 }
 822
 823                 [Test]
 824                 [NUnit.Framework.Category ("NotWorking")]
 825                 public void ComplexEventSequence1 ()
 826                 {
 827                         string result = @"setting table...
 828 ---- OnListChanged PropertyDescriptorChanged,0,0
 829 ----- UpdateIndex : True
 830 ---- OnListChanged Reset,-1,-1
 831 table was set.
 832 ---- OnListChanged PropertyDescriptorAdded,0,0
 833  col1 added.
 834 ---- OnListChanged PropertyDescriptorAdded,0,0
 835  col2 added.
 836 ---- OnListChanged PropertyDescriptorAdded,0,0
 837  col3 added.
 838  uniq added.
 839 ----- UpdateIndex : True
 840 ---- OnListChanged Reset,-1,-1
 841  sort changed.
 842 ---- OnListChanged PropertyDescriptorDeleted,0,0
 843  col3 removed.
 844 ----- UpdateIndex : True
 845 ---- OnListChanged Reset,-1,-1
 846  rowfilter changed.
 847 ----- UpdateIndex : True
 848 ---- OnListChanged Reset,-1,-1
 849  rowstatefilter changed.
 850 ----- UpdateIndex : True
 851 ---- OnListChanged Reset,-1,-1
 852  rowstatefilter changed.
 853 ---- OnListChanged ItemAdded,0,-1
 854  added row to Rows.
 855 ---- OnListChanged ItemAdded,0,-1
 856  added row to Rows.
 857 ---- OnListChanged ItemAdded,0,-1
 858  added row to Rows.
 859 ---- OnListChanged ItemAdded,3,-1
 860  AddNew() invoked.
 861 4
 862 ---- OnListChanged ItemDeleted,3,-1
 863 ---- OnListChanged ItemMoved,-2147483648,3
 864  EndEdit() invoked.
 865 3
 866 ---- OnListChanged ItemMoved,0,-2147483648
 867  value changed to appear.
 868 4
 869 ---- OnListChanged ItemMoved,3,0
 870  value moved.
 871 4
 872 ---- OnListChanged ItemMoved,1,3
 873  value moved again.
 874 4
 875 ---- OnListChanged PropertyDescriptorChanged,0,0
 876 ----- UpdateIndex : True
 877 ---- OnListChanged Reset,-1,-1
 878 table changed.
 879 ";
 880
 881                         eventWriter = new StringWriter ();
 882
 883                         DataTable dt = new DataTable ("table");
 884                         ComplexEventSequence1View dv =
 885                                 new ComplexEventSequence1View (dt, eventWriter);
 886                         dt.Columns.Add ("col1");
 887                         eventWriter.WriteLine (" col1 added.");
 888                         dt.Columns.Add ("col2");
 889                         eventWriter.WriteLine (" col2 added.");
 890                         dt.Columns.Add ("col3");
 891                         eventWriter.WriteLine (" col3 added.");
 892                         dt.Constraints.Add (new UniqueConstraint (dt.Columns [0]));
 893                         eventWriter.WriteLine (" uniq added.");
 894                         dv.Sort = "col2";
 895                         eventWriter.WriteLine (" sort changed.");
 896                         dt.Columns.Remove ("col3");
 897                         eventWriter.WriteLine (" col3 removed.");
 898                         dv.RowFilter = "col1 <> 0";
 899                         eventWriter.WriteLine (" rowfilter changed.");
 900                         dv.RowStateFilter = DataViewRowState.Deleted;
 901                         eventWriter.WriteLine (" rowstatefilter changed.");
 902                         // FIXME: should be also tested.
 903 //                      dv.ApplyDefaultSort = true;
 904 //                      eventWriter.WriteLine (" apply default sort changed.");
 905                         dv.RowStateFilter = DataViewRowState.CurrentRows;
 906                         eventWriter.WriteLine (" rowstatefilter changed.");
 907                         dt.Rows.Add (new object [] {1, 3});
 908                         eventWriter.WriteLine (" added row to Rows.");
 909                         dt.Rows.Add (new object [] {2, 2});
 910                         eventWriter.WriteLine (" added row to Rows.");
 911                         dt.Rows.Add (new object [] {3, 1});
 912                         eventWriter.WriteLine (" added row to Rows.");
 913                         DataRowView drv = dv.AddNew ();
 914                         eventWriter.WriteLine (" AddNew() invoked.");
 915                         eventWriter.WriteLine (dv.Count);
 916                         drv [0] = 0;
 917                         drv.EndEdit ();
 918                         eventWriter.WriteLine (" EndEdit() invoked.");
 919                         eventWriter.WriteLine (dv.Count);
 920                         dt.Rows [dt.Rows.Count - 1] [0] = 4;
 921                         eventWriter.WriteLine (" value changed to appear.");
 922                         eventWriter.WriteLine (dv.Count);
 923                         dt.Rows [dt.Rows.Count - 1] [1] = 4;
 924                         eventWriter.WriteLine (" value moved.");
 925                         eventWriter.WriteLine (dv.Count);
 926                         dt.Rows [dt.Rows.Count - 1] [1] = 1.5;
 927                         eventWriter.WriteLine (" value moved again.");
 928                         eventWriter.WriteLine (dv.Count);
 929                         dv.Table = new DataTable ("table2");
 930                         eventWriter.WriteLine ("table changed.");
 931
 932                         AssertEquals (result.Replace ("\r\n", "\n"), eventWriter.ToString ().Replace ("\r\n", "\n"));
 933                 }
 934
 935                 [Test]
 936                 public void DefaultColumnNameAddListChangedTest ()
 937                 {
 938                         string result = @"setting table...
 939 ---- OnListChanged PropertyDescriptorChanged,0,0
 940 ----- UpdateIndex : True
 941 ---- OnListChanged Reset,-1,-1
 942 table was set.
 943 ---- OnListChanged PropertyDescriptorAdded,0,0
 944  default named column added.
 945 ---- OnListChanged PropertyDescriptorAdded,0,0
 946  non-default named column added.
 947 ---- OnListChanged PropertyDescriptorAdded,0,0
 948  another default named column added (Column2).
 949 ---- OnListChanged PropertyDescriptorAdded,0,0
 950  add a column with the same name as the default columnnames.
 951 ---- OnListChanged PropertyDescriptorAdded,0,0
 952  add a column with a null name.
 953 ---- OnListChanged PropertyDescriptorAdded,0,0
 954  add a column with an empty name.
 955 ";
 956                         eventWriter = new StringWriter ();
 957                         DataTable dt = new DataTable ("table");
 958                         ComplexEventSequence1View dv =
 959                                 new ComplexEventSequence1View (dt, eventWriter);
 960                         dt.Columns.Add ();
 961                         eventWriter.WriteLine (" default named column added.");
 962                         dt.Columns.Add ("non-defaultNamedColumn");
 963                         eventWriter.WriteLine (" non-default named column added.");
 964                         DataColumn c = dt.Columns.Add ();
 965                         eventWriter.WriteLine (" another default named column added ({0}).", c.ColumnName);
 966                         dt.Columns.Add ("Column3");
 967                         eventWriter.WriteLine (" add a column with the same name as the default columnnames.");
 968                         dt.Columns.Add ((string)null);
 969                         eventWriter.WriteLine (" add a column with a null name.");
 970                         dt.Columns.Add ("");
 971                         eventWriter.WriteLine (" add a column with an empty name.");
 972
 973                         AssertEquals (result.Replace ("\r\n", "\n"), eventWriter.ToString ().Replace ("\r\n", "\n"));
 974                 }
 975
 976                 public class ComplexEventSequence1View : DataView
 977                 {
 978                         TextWriter w;
 979
 980                         public ComplexEventSequence1View (DataTable dt,
 981                                 TextWriter w) : base ()
 982                         {
 983                                 this.w = w;
 984                                 w.WriteLine ("setting table...");
 985                                 Table = dt;
 986                                 w.WriteLine ("table was set.");
 987                         }
 988
 989                         protected override void OnListChanged (ListChangedEventArgs e)
 990                         {
 991                                 if (w != null)
 992                                         w.WriteLine ("---- OnListChanged " + e.ListChangedType + "," + e.NewIndex + "," + e.OldIndex);
 993                                 base.OnListChanged (e);
 994                         }
 995
 996                         protected override void UpdateIndex (bool force)
 997                         {
 998                                 if (w != null)
 999                                         w.WriteLine ("----- UpdateIndex : " + force);
1000                                 base.UpdateIndex (force);
1001                         }
1002                 }
1003         }
1004 }