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 #if NET_2_0
 442                 private bool dvInitialized;
 443                 private void OnDataViewInitialized (object src, EventArgs args)
 444                 {
 445                         dvInitialized = true;
 446                 }
 447                 [Test]
 448                 public void BeginInit2 ()
 449                 {
 450                         DataTable table = new DataTable ("table");
 451                         DataView dv = new DataView ();
 452                         DataColumn col1 = new DataColumn ("col1");
 453                         DataColumn col2 = new DataColumn ("col2");
 454
 455                         dvInitialized = false;
 456
 457                         dv.Initialized += new EventHandler (OnDataViewInitialized);
 458
 459                         dv.BeginInit ();
 460                         table.BeginInit ();
 461                         table.Columns.AddRange (new DataColumn[] {col1,col2});
 462
 463                         dv.Table = table;
 464                         AssertNull ("#1", dv.Table);
 465                         dv.EndInit ();
 466
 467                         dv.Initialized -= new EventHandler (OnDataViewInitialized);
 468
 469                         AssertEquals ("#2", table, dv.Table);
 470                         AssertEquals ("#3", 0, table.Columns.Count);
 471
 472                         table.EndInit ();
 473                         AssertEquals ("#4", 2, table.Columns.Count);
 474                         AssertEquals("DataViewInitialized #5", dvInitialized, true);
 475                 }
 476 #endif
 477
 478                 [Test]
 479                 [ExpectedException(typeof(ArgumentException))]
 480                 public void Find_1 ()
 481                 {
 482                         /* since the sort key is not specified. Must raise a ArgumentException */
 483                         int sIndex = dataView.Find ("abc");
 484                 }
 485
 486                 [Test]
 487                 public void Find_2 ()
 488                 {
 489                         int randInt;
 490                         DataRowView drv;
 491                         randInt = rndm.Next () % rowCount;
 492                         dataView.Sort = "itemId";
 493                         drv = dataView [randInt];
 494                         AssertEquals ("test#01",randInt,dataView.Find (drv ["itemId"]));
 495
 496                         dataView.Sort = "itemId DESC";
 497                         drv = dataView [randInt];
 498                         AssertEquals ("test#02",randInt,dataView.Find (drv ["itemId"]));
 499
 500                         dataView.Sort = "itemId, itemName";
 501                         drv = dataView [randInt];
 502                         object [] keys = new object [2];
 503                         keys [0] = drv ["itemId"];
 504                         keys [1] = drv ["itemName"];
 505                         AssertEquals ("test#03",randInt,dataView.Find (keys));
 506
 507                         dataView.Sort = "itemId";
 508                         AssertEquals ("test#04",-1,dataView.Find("no item"));
 509
 510                 }
 511
 512                 [Test]
 513                 [ExpectedException (typeof (ArgumentException))]
 514 #if TARGET_JVM
 515                 [NUnit.Framework.Category ("NotWorking")] // defect 5446
 516 #endif
 517                 public void Find_3 ()
 518                 {
 519                         dataView.Sort = "itemID, itemName";
 520                         /* expecting order key count mismatch */
 521                         dataView.Find ("itemValue");
 522                 }
 523
 524                 [Test]
 525                 [Ignore("Test code not implemented")]
 526                 public void GetEnumerator ()
 527                 {
 528                         //TODO
 529                 }
 530
 531                 [Test]
 532                 public void ToStringTest ()
 533                 {
 534                         AssertEquals ("test#01","System.Data.DataView",dataView.ToString());
 535                 }
 536
 537                 [Test]
 538                 public void TestingEventHandling ()
 539                 {
 540                         dataView.Sort = "itemId";
 541                         DataRow dr;
 542                         dr = dataTable.NewRow ();
 543                         dr ["itemId"] = "item 0";
 544                         dr ["itemName"] = "name " + rndm.Next ();
 545                         dr ["itemPrice"] = "Rs. " + (rndm.Next () % 1000);
 546                         dr ["itemCategory"] = "Cat " + ((rndm.Next () % 10) + 1);
 547                         dataTable.Rows.Add(dr);
 548
 549                         //PrintTableOrView(dataView, "ItemAdded");
 550                         AssertEquals ("test#01",ListChangedType.ItemAdded,listChangedArgs.ListChangedType);
 551                         listChangedArgs = null;
 552
 553                         dr ["itemId"] = "aitem 0";
 554                         // PrintTableOrView(dataView, "ItemChanged");
 555                         AssertEquals ("test#02",ListChangedType.ItemChanged,listChangedArgs.ListChangedType);
 556                         listChangedArgs = null;
 557
 558                         dr ["itemId"] = "zitem 0";
 559                         // PrintTableOrView(dataView, "ItemMoved");
 560                         AssertEquals ("test#03",ListChangedType.ItemMoved,listChangedArgs.ListChangedType);
 561                         listChangedArgs = null;
 562
 563                         dataTable.Rows.Remove (dr);
 564                         // PrintTableOrView(dataView, "ItemDeleted");
 565                         AssertEquals ("test#04",ListChangedType.ItemDeleted,listChangedArgs.ListChangedType);
 566
 567                         listChangedArgs = null;
 568                         DataColumn dc5 = new DataColumn ("itemDesc");
 569                         dataTable.Columns.Add (dc5);
 570                         // PrintTableOrView(dataView, "PropertyDescriptorAdded");
 571                         AssertEquals ("test#05",ListChangedType.PropertyDescriptorAdded,listChangedArgs.ListChangedType);
 572
 573                         listChangedArgs = null;
 574                         dc5.ColumnName = "itemDescription";
 575                         // PrintTableOrView(dataView, "PropertyDescriptorChanged");
 576                         // AssertEquals ("test#06",ListChangedType.PropertyDescriptorChanged,listChangedArgs.ListChangedType);
 577
 578                         listChangedArgs = null;
 579                         dataTable.Columns.Remove (dc5);
 580                         // PrintTableOrView(dataView, "PropertyDescriptorDeleted");
 581                         AssertEquals ("test#07",ListChangedType.PropertyDescriptorDeleted,listChangedArgs.ListChangedType);
 582                 }
 583
 584                 [Test]
 585                 public void TestFindRows ()
 586                 {
 587                         DataView TestView = new DataView (dataTable);
 588                         TestView.Sort = "itemId";
 589                         DataRowView[] Result = TestView.FindRows ("item 3");
 590                         Assertion.AssertEquals ("Dv #1", 1, Result.Length);
 591                         Assertion.AssertEquals ("Dv #2", "item 3", Result [0]["itemId"]);
 592                 }
 593
 594                 [Test]
 595                 [ExpectedException (typeof (ArgumentException))]
 596                 public void FindRowsWithoutSort ()
 597                 {
 598                         DataTable dt = new DataTable ("table");
 599                         dt.Columns.Add ("col1");
 600                         dt.Columns.Add ("col2");
 601                         dt.Columns.Add ("col3");
 602                         dt.Rows.Add (new object [] {1,2,3});
 603                         dt.Rows.Add (new object [] {4,5,6});
 604                         dt.Rows.Add (new object [] {4,7,8});
 605                         dt.Rows.Add (new object [] {5,7,8});
 606                         dt.Rows.Add (new object [] {4,8,9});
 607                         DataView dv = new DataView (dt);
 608                         dv.Find (1);
 609                 }
 610
 611                 [Test]
 612                 [ExpectedException (typeof (ArgumentException))]
 613                 public void FindRowsInconsistentKeyLength ()
 614                 {
 615                         DataTable dt = new DataTable ("table");
 616                         dt.Columns.Add ("col1");
 617                         dt.Columns.Add ("col2");
 618                         dt.Columns.Add ("col3");
 619                         dt.Rows.Add (new object [] {1,2,3});
 620                         dt.Rows.Add (new object [] {4,5,6});
 621                         dt.Rows.Add (new object [] {4,7,8});
 622                         dt.Rows.Add (new object [] {5,7,8});
 623                         dt.Rows.Add (new object [] {4,8,9});
 624                         DataView dv = new DataView (dt, null, "col1",
 625                                 DataViewRowState.CurrentRows);
 626                         dv.FindRows (new object [] {1, 2, 3});
 627                 }
 628
 629                 [Test]
 630                 [ExpectedException (typeof (DeletedRowInaccessibleException))]
 631                 public void TestDelete ()
 632                 {
 633                         DataView TestView = new DataView (dataTable);
 634                         TestView.Delete (0);
 635                         DataRow r = TestView.Table.Rows [0];
 636                         Assertion.Assert ("Dv #1", !((string)r ["itemId"] == "item 1"));
 637                 }
 638
 639                 [Test]
 640                 [ExpectedException (typeof (IndexOutOfRangeException))]
 641                 public void TestDeleteOutOfBounds ()
 642                 {
 643                         DataView TestView = new DataView (dataTable);
 644                         TestView.Delete (100);
 645                 }
 646
 647                 [Test]
 648                 [ExpectedException (typeof (DataException))]
 649                 public void TestDeleteNotAllowed ()
 650                  {
 651                         DataView TestView = new DataView (dataTable);
 652                         TestView.AllowDelete = false;
 653                         TestView.Delete (0);
 654                 }
 655
 656                 [Test]
 657                 [ExpectedException (typeof (DataException))]
 658                 public void TestDeleteClosed ()
 659                 {
 660                         DataView TestView = new DataView (dataTable);
 661                         TestView.Dispose (); // Close the table
 662                         TestView.Delete (0);
 663                 }
 664
 665                 [Test] // based on bug #74631
 666                 public void TestDeleteAndCount ()
 667                 {
 668                         DataSet dataset = new DataSet ("new");
 669                         DataTable dt = new DataTable ("table1");
 670                         dataset.Tables.Add (dt);
 671                         dt.Columns.Add ("col1");
 672                         dt.Columns.Add ("col2");
 673                         dt.Rows.Add (new object []{1,1});
 674                         dt.Rows.Add (new object []{1,2});
 675                         dt.Rows.Add (new object []{1,3});
 676
 677                         DataView dataView = new DataView (dataset.Tables[0]);
 678
 679                         AssertEquals ("before delete", 3, dataView.Count);
 680                         dataView.AllowDelete = true;
 681
 682                         // Deleting the first row
 683                         dataView.Delete (0);
 684
 685                         AssertEquals ("before delete", 2, dataView.Count);
 686                 }
 687
 688                 [Test]
 689                 public void ListChangeOnSetItem ()
 690                 {
 691                         DataTable dt = new DataTable ("table");
 692                         dt.Columns.Add ("col1");
 693                         dt.Columns.Add ("col2");
 694                         dt.Columns.Add ("col3");
 695                         dt.Rows.Add (new object [] {1, 2, 3});
 696                         dt.AcceptChanges ();
 697                         DataView dv = new DataView (dt);
 698                         dv.ListChanged += new ListChangedEventHandler (OnChange);
 699                         dv [0] ["col1"] = 4;
 700                 }
 701
 702                 ListChangedEventArgs ListChangeArgOnSetItem;
 703
 704                 void OnChange (object o, ListChangedEventArgs e)
 705                 {
 706                         if (ListChangeArgOnSetItem != null)
 707                                 throw new Exception ("The event is already fired.");
 708                         ListChangeArgOnSetItem = e;
 709                 }
 710
 711                 [Test]
 712                 public void CancelEditAndEvents ()
 713                 {
 714                         string reference = " =====ItemAdded:3 ------4 =====ItemAdded:4 ------5 =====ItemAdded:5 ------6 =====ItemDeleted:5 ------5 =====ItemAdded:5";
 715
 716                         eventWriter = new StringWriter ();
 717
 718                         DataTable dt = new DataTable ();
 719                         dt.Columns.Add ("col1");
 720                         dt.Columns.Add ("col2");
 721                         dt.Columns.Add ("col3");
 722                         dt.Rows.Add (new object [] {1,2,3});
 723                         dt.Rows.Add (new object [] {1,2,3});
 724                         dt.Rows.Add (new object [] {1,2,3});
 725
 726                         DataView dv = new DataView (dt);
 727                         dv.ListChanged += new ListChangedEventHandler (ListChanged);
 728                         DataRowView a1 = dv.AddNew ();
 729                         eventWriter.Write (" ------" + dv.Count);
 730                         // I wonder why but MS fires another event here.
 731                         a1 = dv.AddNew ();
 732                         eventWriter.Write (" ------" + dv.Count);
 733                         // I wonder why but MS fires another event here.
 734                         DataRowView a2 = dv.AddNew ();
 735                         eventWriter.Write (" ------" + dv.Count);
 736                         a2.CancelEdit ();
 737                         eventWriter.Write (" ------" + dv.Count);
 738                         DataRowView a3 = dv.AddNew ();
 739
 740                         AssertEquals (reference, eventWriter.ToString ());
 741                 }
 742
 743                 [Test]
 744                 public void ColumnChangeName ()
 745                 {
 746                         string result = @"setting table...
 747 ---- OnListChanged PropertyDescriptorChanged,0,0
 748 ----- UpdateIndex : True
 749 ---- OnListChanged Reset,-1,-1
 750 table was set.
 751 ---- OnListChanged PropertyDescriptorChanged,0,0
 752 ";
 753
 754                         eventWriter = new StringWriter ();
 755
 756                         ComplexEventSequence1View dv =
 757                                 new ComplexEventSequence1View (dataTable, eventWriter);
 758
 759                         dc2.ColumnName = "new_column_name";
 760
 761                         AssertEquals (result.Replace ("\r\n", "\n"), eventWriter.ToString ().Replace ("\r\n", "\n"));
 762                 }
 763
 764                 private void ListChanged (object o, ListChangedEventArgs e)
 765                 {
 766                         eventWriter.Write (" =====" + e.ListChangedType + ":" + e.NewIndex);
 767                 }
 768
 769                 [Test]
 770                 [NUnit.Framework.Category ("NotWorking")]
 771                 public void ComplexEventSequence2 ()
 772                 {
 773                         string result = @"setting table...
 774 ---- OnListChanged PropertyDescriptorChanged,0,0
 775 ----- UpdateIndex : True
 776 ---- OnListChanged Reset,-1,-1
 777 table was set.
 778 ---- OnListChanged PropertyDescriptorAdded,0,0
 779  col1 added.
 780 ---- OnListChanged PropertyDescriptorAdded,0,0
 781  col2 added.
 782 ---- OnListChanged PropertyDescriptorAdded,0,0
 783  col3 added.
 784 ---- OnListChanged Reset,-1,-1
 785 added tables to dataset
 786 ---- OnListChanged PropertyDescriptorAdded,0,0
 787 added relation 1
 788 ---- OnListChanged PropertyDescriptorAdded,0,0
 789 added relation 2
 790 ---- OnListChanged PropertyDescriptorDeleted,0,0
 791 removed relation 2
 792 ";
 793
 794                         eventWriter = new StringWriter ();
 795
 796                         DataSet ds = new DataSet ();
 797                         DataTable dt = new DataTable ("table");
 798                         DataTable dt2 = new DataTable ("table2");
 799                         ComplexEventSequence1View dv =
 800                                 new ComplexEventSequence1View (dt, eventWriter);
 801                         dt.Columns.Add ("col1");
 802                         eventWriter.WriteLine (" col1 added.");
 803                         dt.Columns.Add ("col2");
 804                         eventWriter.WriteLine (" col2 added.");
 805                         dt.Columns.Add ("col3");
 806                         eventWriter.WriteLine (" col3 added.");
 807
 808                         dt2.Columns.Add ("col1");
 809                         dt2.Columns.Add ("col2");
 810                         dt2.Columns.Add ("col3");
 811
 812                         ds.Tables.Add (dt);
 813                         ds.Tables.Add (dt2);
 814
 815                         eventWriter.WriteLine ("added tables to dataset");
 816                         ds.Relations.Add ("Relation", dt.Columns ["col1"], dt2.Columns ["col1"]);
 817                         eventWriter.WriteLine ("added relation 1");
 818
 819                         DataRelation dr = ds.Relations.Add ("Relation2", dt2.Columns ["col2"], dt.Columns ["col2"]);
 820                         eventWriter.WriteLine ("added relation 2");
 821
 822                         ds.Relations.Remove (dr);
 823                         eventWriter.WriteLine ("removed relation 2");
 824
 825                         AssertEquals (result.Replace ("\r\n", "\n"), eventWriter.ToString ().Replace ("\r\n", "\n"));
 826                 }
 827
 828                 [Test]
 829                 [NUnit.Framework.Category ("NotWorking")]
 830                 public void ComplexEventSequence1 ()
 831                 {
 832                         string result = @"setting table...
 833 ---- OnListChanged PropertyDescriptorChanged,0,0
 834 ----- UpdateIndex : True
 835 ---- OnListChanged Reset,-1,-1
 836 table was set.
 837 ---- OnListChanged PropertyDescriptorAdded,0,0
 838  col1 added.
 839 ---- OnListChanged PropertyDescriptorAdded,0,0
 840  col2 added.
 841 ---- OnListChanged PropertyDescriptorAdded,0,0
 842  col3 added.
 843  uniq added.
 844 ----- UpdateIndex : True
 845 ---- OnListChanged Reset,-1,-1
 846  sort changed.
 847 ---- OnListChanged PropertyDescriptorDeleted,0,0
 848  col3 removed.
 849 ----- UpdateIndex : True
 850 ---- OnListChanged Reset,-1,-1
 851  rowfilter changed.
 852 ----- UpdateIndex : True
 853 ---- OnListChanged Reset,-1,-1
 854  rowstatefilter changed.
 855 ----- UpdateIndex : True
 856 ---- OnListChanged Reset,-1,-1
 857  rowstatefilter changed.
 858 ---- OnListChanged ItemAdded,0,-1
 859  added row to Rows.
 860 ---- OnListChanged ItemAdded,0,-1
 861  added row to Rows.
 862 ---- OnListChanged ItemAdded,0,-1
 863  added row to Rows.
 864 ---- OnListChanged ItemAdded,3,-1
 865  AddNew() invoked.
 866 4
 867 ---- OnListChanged ItemDeleted,3,-1
 868 ---- OnListChanged ItemMoved,-2147483648,3
 869  EndEdit() invoked.
 870 3
 871 ---- OnListChanged ItemMoved,0,-2147483648
 872  value changed to appear.
 873 4
 874 ---- OnListChanged ItemMoved,3,0
 875  value moved.
 876 4
 877 ---- OnListChanged ItemMoved,1,3
 878  value moved again.
 879 4
 880 ---- OnListChanged PropertyDescriptorChanged,0,0
 881 ----- UpdateIndex : True
 882 ---- OnListChanged Reset,-1,-1
 883 table changed.
 884 ";
 885
 886                         eventWriter = new StringWriter ();
 887
 888                         DataTable dt = new DataTable ("table");
 889                         ComplexEventSequence1View dv =
 890                                 new ComplexEventSequence1View (dt, eventWriter);
 891                         dt.Columns.Add ("col1");
 892                         eventWriter.WriteLine (" col1 added.");
 893                         dt.Columns.Add ("col2");
 894                         eventWriter.WriteLine (" col2 added.");
 895                         dt.Columns.Add ("col3");
 896                         eventWriter.WriteLine (" col3 added.");
 897                         dt.Constraints.Add (new UniqueConstraint (dt.Columns [0]));
 898                         eventWriter.WriteLine (" uniq added.");
 899                         dv.Sort = "col2";
 900                         eventWriter.WriteLine (" sort changed.");
 901                         dt.Columns.Remove ("col3");
 902                         eventWriter.WriteLine (" col3 removed.");
 903                         dv.RowFilter = "col1 <> 0";
 904                         eventWriter.WriteLine (" rowfilter changed.");
 905                         dv.RowStateFilter = DataViewRowState.Deleted;
 906                         eventWriter.WriteLine (" rowstatefilter changed.");
 907                         // FIXME: should be also tested.
 908 //                      dv.ApplyDefaultSort = true;
 909 //                      eventWriter.WriteLine (" apply default sort changed.");
 910                         dv.RowStateFilter = DataViewRowState.CurrentRows;
 911                         eventWriter.WriteLine (" rowstatefilter changed.");
 912                         dt.Rows.Add (new object [] {1, 3});
 913                         eventWriter.WriteLine (" added row to Rows.");
 914                         dt.Rows.Add (new object [] {2, 2});
 915                         eventWriter.WriteLine (" added row to Rows.");
 916                         dt.Rows.Add (new object [] {3, 1});
 917                         eventWriter.WriteLine (" added row to Rows.");
 918                         DataRowView drv = dv.AddNew ();
 919                         eventWriter.WriteLine (" AddNew() invoked.");
 920                         eventWriter.WriteLine (dv.Count);
 921                         drv [0] = 0;
 922                         drv.EndEdit ();
 923                         eventWriter.WriteLine (" EndEdit() invoked.");
 924                         eventWriter.WriteLine (dv.Count);
 925                         dt.Rows [dt.Rows.Count - 1] [0] = 4;
 926                         eventWriter.WriteLine (" value changed to appear.");
 927                         eventWriter.WriteLine (dv.Count);
 928                         dt.Rows [dt.Rows.Count - 1] [1] = 4;
 929                         eventWriter.WriteLine (" value moved.");
 930                         eventWriter.WriteLine (dv.Count);
 931                         dt.Rows [dt.Rows.Count - 1] [1] = 1.5;
 932                         eventWriter.WriteLine (" value moved again.");
 933                         eventWriter.WriteLine (dv.Count);
 934                         dv.Table = new DataTable ("table2");
 935                         eventWriter.WriteLine ("table changed.");
 936
 937                         AssertEquals (result.Replace ("\r\n", "\n"), eventWriter.ToString ().Replace ("\r\n", "\n"));
 938                 }
 939
 940                 [Test]
 941                 public void DefaultColumnNameAddListChangedTest ()
 942                 {
 943 #if NET_2_0
 944                         string result = @"setting table...
 945 ---- OnListChanged PropertyDescriptorChanged,0,0
 946 ----- UpdateIndex : True
 947 ---- OnListChanged Reset,-1,-1
 948 table was set.
 949 ---- OnListChanged PropertyDescriptorAdded,0,0
 950  default named column added.
 951 ---- OnListChanged PropertyDescriptorAdded,0,0
 952  non-default named column added.
 953 ---- OnListChanged PropertyDescriptorAdded,0,0
 954  another default named column added (Column2).
 955 ---- OnListChanged PropertyDescriptorAdded,0,0
 956  add a column with the same name as the default columnnames.
 957 ---- OnListChanged PropertyDescriptorAdded,0,0
 958  add a column with a null name.
 959 ---- OnListChanged PropertyDescriptorAdded,0,0
 960  add a column with an empty name.
 961 ";
 962 #else
 963                         string result = @"setting table...
 964 ---- OnListChanged PropertyDescriptorChanged,0,0
 965 ----- UpdateIndex : True
 966 ---- OnListChanged Reset,-1,-1
 967 table was set.
 968 ---- OnListChanged PropertyDescriptorChanged,0,0
 969 ---- OnListChanged PropertyDescriptorAdded,0,0
 970  default named column added.
 971 ---- OnListChanged PropertyDescriptorAdded,0,0
 972  non-default named column added.
 973 ---- OnListChanged PropertyDescriptorChanged,0,0
 974 ---- OnListChanged PropertyDescriptorAdded,0,0
 975  another default named column added (Column2).
 976 ---- OnListChanged PropertyDescriptorAdded,0,0
 977  add a column with the same name as the default columnnames.
 978 ---- OnListChanged PropertyDescriptorChanged,0,0
 979 ---- OnListChanged PropertyDescriptorAdded,0,0
 980  add a column with a null name.
 981 ---- OnListChanged PropertyDescriptorChanged,0,0
 982 ---- OnListChanged PropertyDescriptorAdded,0,0
 983  add a column with an empty name.
 984 ";
 985 #endif
 986                         eventWriter = new StringWriter ();
 987                         DataTable dt = new DataTable ("table");
 988                         ComplexEventSequence1View dv =
 989                                 new ComplexEventSequence1View (dt, eventWriter);
 990                         dt.Columns.Add ();
 991                         eventWriter.WriteLine (" default named column added.");
 992                         dt.Columns.Add ("non-defaultNamedColumn");
 993                         eventWriter.WriteLine (" non-default named column added.");
 994                         DataColumn c = dt.Columns.Add ();
 995                         eventWriter.WriteLine (" another default named column added ({0}).", c.ColumnName);
 996                         dt.Columns.Add ("Column3");
 997                         eventWriter.WriteLine (" add a column with the same name as the default columnnames.");
 998                         dt.Columns.Add ((string)null);
 999                         eventWriter.WriteLine (" add a column with a null name.");
1000                         dt.Columns.Add ("");
1001                         eventWriter.WriteLine (" add a column with an empty name.");
1002
1003                         AssertEquals (result.Replace ("\r\n", "\n"), eventWriter.ToString ().Replace ("\r\n", "\n"));
1004                 }
1005
1006                 public class ComplexEventSequence1View : DataView
1007                 {
1008                         TextWriter w;
1009
1010                         public ComplexEventSequence1View (DataTable dt,
1011                                 TextWriter w) : base ()
1012                         {
1013                                 this.w = w;
1014                                 w.WriteLine ("setting table...");
1015                                 Table = dt;
1016                                 w.WriteLine ("table was set.");
1017                         }
1018
1019                         protected override void OnListChanged (ListChangedEventArgs e)
1020                         {
1021                                 if (w != null)
1022                                         w.WriteLine ("---- OnListChanged " + e.ListChangedType + "," + e.NewIndex + "," + e.OldIndex);
1023                                 base.OnListChanged (e);
1024                         }
1025
1026                         protected override void UpdateIndex (bool force)
1027                         {
1028                                 if (w != null)
1029                                         w.WriteLine ("----- UpdateIndex : " + force);
1030                                 base.UpdateIndex (force);
1031                         }
1032                 }
1033         }
1034 }