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                 [SetUp]
  55                 public void GetReady ()
  56                 {
  57                         dataTable = new DataTable ("itemTable");
  58                         DataColumn dc1 = new DataColumn ("itemId");
  59                         DataColumn dc2 = new DataColumn ("itemName");
  60                         DataColumn dc3 = new DataColumn ("itemPrice");
  61                         DataColumn dc4 = new DataColumn ("itemCategory");
  62
  63                         dataTable.Columns.Add (dc1);
  64                         dataTable.Columns.Add (dc2);
  65                         dataTable.Columns.Add (dc3);
  66                         dataTable.Columns.Add (dc4);
  67                         DataRow dr;
  68                         seed = 123;
  69                         rowCount = 5;
  70                         rndm = new Random (seed);
  71                         for (int i = 1; i <= rowCount; i++) {
  72                                 dr = dataTable.NewRow ();
  73                                 dr["itemId"] = "item " + i;
  74                                 dr["itemName"] = "name " + rndm.Next ();
  75                                 dr["itemPrice"] = "Rs. " + (rndm.Next () % 1000);
  76                                 dr["itemCategory"] = "Cat " + ((rndm.Next () % 10) + 1);
  77                                 dataTable.Rows.Add (dr);
  78                         }
  79                         dataTable.AcceptChanges ();
  80                         dataView = new DataView (dataTable);
  81                         dataView.ListChanged += new ListChangedEventHandler (OnListChanged);
  82                         listChangedArgs = null;
  83                 }
  84
  85                 protected void OnListChanged (object sender, ListChangedEventArgs args)
  86                 {
  87                         listChangedArgs = args;
  88                         // for debugging
  89                         /*Console.WriteLine("EventType :: " + listChangedArgs.ListChangedType +
  90                                                           "  oldIndex  :: " + listChangedArgs.OldIndex +
  91                                                           "  NewIndex  :: " + listChangedArgs.NewIndex);*/
  92
  93                 }
  94
  95                 private void PrintTableOrView (DataTable t, string label)
  96                 {
  97                         Console.WriteLine ("\n" + label);
  98                         for (int i = 0; i<t.Rows.Count; i++){
  99                                 foreach (DataColumn dc in t.Columns)
 100                                         Console.Write (t.Rows [i][dc] + "\t");
 101                                 Console.WriteLine ("");
 102                         }
 103                         Console.WriteLine ();
 104                 }
 105
 106                 private void PrintTableOrView (DataView dv, string label)
 107                 {
 108                         Console.WriteLine ("\n" + label);
 109                         Console.WriteLine ("Sort Key :: " + dv.Sort);
 110                         for (int i = 0; i < dv.Count; i++) {
 111                                 foreach (DataColumn dc in dv.Table.Columns)
 112                                         Console.Write (dv [i].Row [dc] + "\t");
 113                                 Console.WriteLine ("");
 114                         }
 115                         Console.WriteLine ();
 116                 }
 117
 118                 [TearDown]
 119                 public void Clean ()
 120                 {
 121                         dataTable = null;
 122                         dataView = null;
 123                 }
 124
 125                 [Test]
 126                 public void DataView ()
 127                 {
 128                         DataView dv1,dv2,dv3;
 129                         dv1 = new DataView ();
 130                         // AssertEquals ("test#01",null,dv1.Table);
 131                         AssertEquals ("test#02",true,dv1.AllowNew);
 132                         AssertEquals ("test#03",true,dv1.AllowEdit);
 133                         AssertEquals ("test#04",true,dv1.AllowDelete);
 134                         AssertEquals ("test#05",false,dv1.ApplyDefaultSort);
 135                         AssertEquals ("test#06",string.Empty,dv1.RowFilter);
 136                         AssertEquals ("test#07",DataViewRowState.CurrentRows,dv1.RowStateFilter);
 137                         AssertEquals ("test#08",string.Empty,dv1.Sort);
 138
 139                         dv2 = new DataView (dataTable);
 140                         AssertEquals ("test#09","itemTable",dv2.Table.TableName);
 141                         AssertEquals ("test#10",string.Empty,dv2.Sort);
 142                         AssertEquals ("test#11",false,dv2.ApplyDefaultSort);
 143                         AssertEquals ("test#12",dataTable.Rows[0],dv2[0].Row);
 144
 145                         dv3 = new DataView (dataTable,"","itemId DESC",DataViewRowState.CurrentRows);
 146                         AssertEquals ("test#13","",dv3.RowFilter);
 147                         AssertEquals ("test#14","itemId DESC",dv3.Sort);
 148                         AssertEquals ("test#15",DataViewRowState.CurrentRows,dv3.RowStateFilter);
 149                         //AssertEquals ("test#16",dataTable.Rows.[(dataTable.Rows.Count-1)],dv3[0]);
 150                 }
 151
 152                  [Test]
 153                  public void TestValue ()
 154                  {
 155                         DataView TestView = new DataView (dataTable);
 156                         Assertion.AssertEquals ("Dv #1", "item 1", TestView [0]["itemId"]);
 157                  }
 158
 159                  [Test]
 160                  public void TestCount ()
 161                  {
 162                         DataView TestView = new DataView (dataTable);
 163                         Assertion.AssertEquals ("Dv #3", 5, TestView.Count);
 164                  }
 165
 166                 [Test]
 167                 public void AllowNew ()
 168                 {
 169                         AssertEquals ("test#01",true,dataView.AllowNew);
 170                 }
 171
 172                 [Test]
 173                 public void ApplyDefaultSort ()
 174                 {
 175                         UniqueConstraint uc = new UniqueConstraint (dataTable.Columns["itemId"]);
 176                         dataTable.Constraints.Add (uc);
 177                         dataView.ApplyDefaultSort = true;
 178                         // dataView.Sort = "itemName";
 179                         // AssertEquals ("test#01","item 1",dataView[0]["itemId"]);
 180                         AssertEquals ("test#02",ListChangedType.Reset,listChangedArgs.ListChangedType);
 181                         // UnComment the line below to see if dataView is sorted
 182                         //   PrintTableOrView (dataView,"* OnApplyDefaultSort");
 183                 }
 184
 185                 [Test]
 186                 public void RowStateFilter ()
 187                 {
 188                         dataView.RowStateFilter = DataViewRowState.Deleted;
 189                         AssertEquals ("test#01",ListChangedType.Reset,listChangedArgs.ListChangedType);
 190                 }
 191
 192                 [Test]
 193                 public void RowStateFilter_2 ()
 194                 {
 195                         DataSet dataset = new DataSet ("new");
 196                         DataTable dt = new DataTable ("table1");
 197                         dataset.Tables.Add (dt);
 198                         dt.Columns.Add ("col1");
 199                         dt.Columns.Add ("col2");
 200                         dt.Rows.Add (new object [] {1,1});
 201                         dt.Rows.Add (new object [] {1,2});
 202                         dt.Rows.Add (new object [] {1,3});
 203                         dataset.AcceptChanges ();
 204
 205                         DataView dataView = new DataView (dataset.Tables [0]);
 206
 207                         // 'new'  table in this sample contains 6 records
 208                         dataView.AllowEdit = true;
 209                         dataView.AllowDelete = true;
 210                         string v;
 211
 212                         // Editing the row
 213                         dataView [0] ["col1"] = -1;
 214                         dataView.RowStateFilter = DataViewRowState.ModifiedOriginal;
 215                         v = dataView [0] [0].ToString ();
 216                         AssertEquals ("ModifiedOriginal.Count", 1, dataView.Count);
 217                         AssertEquals ("ModifiedOriginal.Value", "1", v);
 218
 219                         // Deleting the row
 220                         dataView.Delete (0);
 221                         dataView.RowStateFilter = DataViewRowState.Deleted;
 222
 223                         v = dataView [0] [0].ToString ();
 224                         AssertEquals ("Deleted.Count", 1, dataView.Count);
 225                         AssertEquals ("Deleted.Value", "1", v);
 226                 }
 227
 228
 229                 #region Sort Tests
 230                 [Test]
 231                 public void SortListChangedTest ()
 232                 {
 233                         dataView.Sort = "itemName DESC";
 234                         AssertEquals ("test#01",ListChangedType.Reset,listChangedArgs.ListChangedType);
 235                         // UnComment the line below to see if dataView is sorted
 236                         // PrintTableOrView (dataView);
 237                 }
 238
 239
 240                 [Test]
 241                 public void SortTestWeirdColumnName ()
 242                 {
 243                         DataTable dt = new DataTable ();
 244                         dt.Columns.Add ("id]", typeof (int));
 245                         dt.Columns.Add ("[id", typeof (int));
 246
 247                         DataView dv = dt.DefaultView;
 248                         dv.Sort = "id]";
 249                         //dv.Sort = "[id"; // this is not allowed
 250                         dv.Sort = "[id]]";
 251                         dv.Sort = "[[id]";
 252                         dv.Sort = "id] ASC";
 253                         dv.Sort = "[id]] DESC";
 254                         dv.Sort = "[[id] ASC";
 255                 }
 256
 257
 258                 [Test]
 259                 public void SortTests ()
 260                 {
 261                         DataTable dataTable = new DataTable ("itemTable");
 262                         DataColumn dc1 = new DataColumn ("itemId", typeof(int));
 263                         DataColumn dc2 = new DataColumn ("itemName", typeof(string));
 264
 265                         dataTable.Columns.Add (dc1);
 266                         dataTable.Columns.Add (dc2);
 267
 268                         dataTable.Rows.Add (new object[2] { 1, "First entry" });
 269                         dataTable.Rows.Add (new object[2] { 0, "Second entry" });
 270                         dataTable.Rows.Add (new object[2] { 3, "Third entry" });
 271                         dataTable.Rows.Add (new object[2] { 2, "Fourth entry" });
 272
 273                         DataView dataView = dataTable.DefaultView;
 274
 275                         string s = "Default sorting: ";
 276                         AssertEquals (s + "First entry has wrong item", 1, dataView[0][0]);
 277                         AssertEquals (s + "Second entry has wrong item", 0, dataView[1][0]);
 278                         AssertEquals (s + "Third entry has wrong item", 3, dataView[2][0]);
 279                         AssertEquals (s + "Fourth entry has wrong item", 2, dataView[3][0]);
 280
 281                         s = "Ascending sorting 1: ";
 282                         dataView.Sort = "itemId ASC";
 283                         AssertEquals (s + "First entry has wrong item", 0, dataView[0][0]);
 284                         AssertEquals (s + "Second entry has wrong item", 1, dataView[1][0]);
 285                         AssertEquals (s + "Third entry has wrong item", 2, dataView[2][0]);
 286                         AssertEquals (s + "Fourth entry has wrong item", 3, dataView[3][0]);
 287
 288                         // bug #77104 (2-5)
 289                         s = "Ascending sorting 2: ";
 290                         dataView.Sort = "itemId     ASC";
 291                         AssertEquals (s + "First entry has wrong item", 0, dataView[0][0]);
 292                         AssertEquals (s + "Second entry has wrong item", 1, dataView[1][0]);
 293                         AssertEquals (s + "Third entry has wrong item", 2, dataView[2][0]);
 294                         AssertEquals (s + "Fourth entry has wrong item", 3, dataView[3][0]);
 295
 296                         s = "Ascending sorting 3: ";
 297                         dataView.Sort = "[itemId] ASC";
 298                         AssertEquals (s + "First entry has wrong item", 0, dataView[0][0]);
 299                         AssertEquals (s + "Second entry has wrong item", 1, dataView[1][0]);
 300                         AssertEquals (s + "Third entry has wrong item", 2, dataView[2][0]);
 301                         AssertEquals (s + "Fourth entry has wrong item", 3, dataView[3][0]);
 302
 303                         s = "Ascending sorting 4: ";
 304                         dataView.Sort = "[itemId]       ASC";
 305                         AssertEquals (s + "First entry has wrong item", 0, dataView[0][0]);
 306                         AssertEquals (s + "Second entry has wrong item", 1, dataView[1][0]);
 307                         AssertEquals (s + "Third entry has wrong item", 2, dataView[2][0]);
 308                         AssertEquals (s + "Fourth entry has wrong item", 3, dataView[3][0]);
 309
 310                         s = "Ascending sorting 5: ";
 311                         try {
 312                                 dataView.Sort = "itemId \tASC";
 313                                 AssertEquals (s + "Tab cannot be a separator" , true, false);
 314                         }catch (IndexOutOfRangeException e) {
 315                         }
 316
 317                         s = "Descending sorting : ";
 318                         dataView.Sort = "itemId DESC";
 319                         AssertEquals (s + "First entry has wrong item", 3, dataView[0][0]);
 320                         AssertEquals (s + "Second entry has wrong item", 2, dataView[1][0]);
 321                         AssertEquals (s + "Third entry has wrong item", 1, dataView[2][0]);
 322                         AssertEquals (s + "Fourth entry has wrong item", 0, dataView[3][0]);
 323
 324                         s = "Reverted to default sorting: ";
 325                         dataView.Sort = null;
 326                         AssertEquals (s + "First entry has wrong item", 1, dataView[0][0]);
 327                         AssertEquals (s + "Second entry has wrong item", 0, dataView[1][0]);
 328                         AssertEquals (s + "Third entry has wrong item", 3, dataView[2][0]);
 329                         AssertEquals (s + "Fourth entry has wrong item", 2, dataView[3][0]);
 330                 }
 331
 332                 #endregion // Sort Tests
 333
 334                 [Test]
 335                 [ExpectedException(typeof(DataException))]
 336                 public void AddNew_1 ()
 337                 {
 338                         dataView.AllowNew = false;
 339                         DataRowView drv = dataView.AddNew ();
 340                 }
 341
 342                 [Test]
 343                 public void AddNew_2 ()
 344                 {
 345                         dataView.AllowNew = true;
 346                         DataRowView drv = dataView.AddNew ();
 347                         AssertEquals ("test#01",ListChangedType.ItemAdded,listChangedArgs.ListChangedType);
 348                         AssertEquals ("test#02",drv["itemName"],dataView [dataView.Count - 1]["itemName"]);
 349                         listChangedArgs = null;
 350                         drv["itemId"] = "item " + 1001;
 351                         drv["itemName"] = "name " + rndm.Next();
 352                         drv["itemPrice"] = "Rs. " + (rndm.Next() % 1000);
 353                         drv["itemCategory"] = "Cat " + ((rndm.Next() % 10) + 1);
 354                         // Actually no events are arisen when items are set.
 355                         AssertNull ("test#03", listChangedArgs);
 356                 }
 357
 358                 [Test]
 359                 [Ignore("Test code not implemented")]
 360                 public void BeginInit ()
 361                 {
 362                         //TODO
 363                 }
 364
 365                 [Test]
 366                 [ExpectedException(typeof(ArgumentException))]
 367                 public void Find_1 ()
 368                 {
 369                         /* since the sort key is not specified. Must raise a ArgumentException */
 370                         int sIndex = dataView.Find ("abc");
 371                 }
 372
 373                 [Test]
 374                 public void Find_2 ()
 375                 {
 376                         int randInt;
 377                         DataRowView drv;
 378                         randInt = rndm.Next () % rowCount;
 379                         dataView.Sort = "itemId";
 380                         drv = dataView [randInt];
 381                         AssertEquals ("test#01",randInt,dataView.Find (drv ["itemId"]));
 382
 383                         dataView.Sort = "itemId DESC";
 384                         drv = dataView [randInt];
 385                         AssertEquals ("test#02",randInt,dataView.Find (drv ["itemId"]));
 386
 387                         dataView.Sort = "itemId, itemName";
 388                         drv = dataView [randInt];
 389                         object [] keys = new object [2];
 390                         keys [0] = drv ["itemId"];
 391                         keys [1] = drv ["itemName"];
 392                         AssertEquals ("test#03",randInt,dataView.Find (keys));
 393
 394                         dataView.Sort = "itemId";
 395                         AssertEquals ("test#04",-1,dataView.Find("no item"));
 396
 397                 }
 398
 399                 [Test]
 400                 [ExpectedException (typeof (ArgumentException))]
 401                 public void Find_3 ()
 402                 {
 403                         dataView.Sort = "itemID, itemName";
 404                         /* expecting order key count mismatch */
 405                         dataView.Find ("itemValue");
 406                 }
 407
 408                 [Test]
 409                 [Ignore("Test code not implemented")]
 410                 public void GetEnumerator ()
 411                 {
 412                         //TODO
 413                 }
 414
 415                 [Test]
 416                 public void ToStringTest ()
 417                 {
 418                         AssertEquals ("test#01","System.Data.DataView",dataView.ToString());
 419                 }
 420
 421                 [Test]
 422                 public void TestingEventHandling ()
 423                 {
 424                         dataView.Sort = "itemId";
 425                         DataRow dr;
 426                         dr = dataTable.NewRow ();
 427                         dr ["itemId"] = "item 0";
 428                         dr ["itemName"] = "name " + rndm.Next ();
 429                         dr ["itemPrice"] = "Rs. " + (rndm.Next () % 1000);
 430                         dr ["itemCategory"] = "Cat " + ((rndm.Next () % 10) + 1);
 431                         dataTable.Rows.Add(dr);
 432
 433                         //PrintTableOrView(dataView, "ItemAdded");
 434                         AssertEquals ("test#01",ListChangedType.ItemAdded,listChangedArgs.ListChangedType);
 435                         listChangedArgs = null;
 436
 437                         dr ["itemId"] = "aitem 0";
 438                         // PrintTableOrView(dataView, "ItemChanged");
 439                         AssertEquals ("test#02",ListChangedType.ItemChanged,listChangedArgs.ListChangedType);
 440                         listChangedArgs = null;
 441
 442                         dr ["itemId"] = "zitem 0";
 443                         // PrintTableOrView(dataView, "ItemMoved");
 444                         AssertEquals ("test#03",ListChangedType.ItemMoved,listChangedArgs.ListChangedType);
 445                         listChangedArgs = null;
 446
 447                         dataTable.Rows.Remove (dr);
 448                         // PrintTableOrView(dataView, "ItemDeleted");
 449                         AssertEquals ("test#04",ListChangedType.ItemDeleted,listChangedArgs.ListChangedType);
 450
 451                         listChangedArgs = null;
 452                         DataColumn dc5 = new DataColumn ("itemDesc");
 453                         dataTable.Columns.Add (dc5);
 454                         // PrintTableOrView(dataView, "PropertyDescriptorAdded");
 455                         AssertEquals ("test#05",ListChangedType.PropertyDescriptorAdded,listChangedArgs.ListChangedType);
 456
 457                         listChangedArgs = null;
 458                         dc5.ColumnName = "itemDescription";
 459                         // PrintTableOrView(dataView, "PropertyDescriptorChanged");
 460                         // AssertEquals ("test#06",ListChangedType.PropertyDescriptorChanged,listChangedArgs.ListChangedType);
 461
 462                         listChangedArgs = null;
 463                         dataTable.Columns.Remove (dc5);
 464                         // PrintTableOrView(dataView, "PropertyDescriptorDeleted");
 465                         AssertEquals ("test#07",ListChangedType.PropertyDescriptorDeleted,listChangedArgs.ListChangedType);
 466                 }
 467
 468                 [Test]
 469                 public void TestFindRows ()
 470                 {
 471                         DataView TestView = new DataView (dataTable);
 472                         TestView.Sort = "itemId";
 473                         DataRowView[] Result = TestView.FindRows ("item 3");
 474                         Assertion.AssertEquals ("Dv #1", 1, Result.Length);
 475                         Assertion.AssertEquals ("Dv #2", "item 3", Result [0]["itemId"]);
 476                 }
 477
 478                 [Test]
 479                 [ExpectedException (typeof (ArgumentException))]
 480                 public void FindRowsWithoutSort ()
 481                 {
 482                         DataTable dt = new DataTable ("table");
 483                         dt.Columns.Add ("col1");
 484                         dt.Columns.Add ("col2");
 485                         dt.Columns.Add ("col3");
 486                         dt.Rows.Add (new object [] {1,2,3});
 487                         dt.Rows.Add (new object [] {4,5,6});
 488                         dt.Rows.Add (new object [] {4,7,8});
 489                         dt.Rows.Add (new object [] {5,7,8});
 490                         dt.Rows.Add (new object [] {4,8,9});
 491                         DataView dv = new DataView (dt);
 492                         dv.Find (1);
 493                 }
 494
 495                 [Test]
 496                 [ExpectedException (typeof (ArgumentException))]
 497                 public void FindRowsInconsistentKeyLength ()
 498                 {
 499                         DataTable dt = new DataTable ("table");
 500                         dt.Columns.Add ("col1");
 501                         dt.Columns.Add ("col2");
 502                         dt.Columns.Add ("col3");
 503                         dt.Rows.Add (new object [] {1,2,3});
 504                         dt.Rows.Add (new object [] {4,5,6});
 505                         dt.Rows.Add (new object [] {4,7,8});
 506                         dt.Rows.Add (new object [] {5,7,8});
 507                         dt.Rows.Add (new object [] {4,8,9});
 508                         DataView dv = new DataView (dt, null, "col1",
 509                                 DataViewRowState.CurrentRows);
 510                         dv.FindRows (new object [] {1, 2, 3});
 511                 }
 512
 513                 [Test]
 514                 [ExpectedException (typeof (DeletedRowInaccessibleException))]
 515                 public void TestDelete ()
 516                 {
 517                         DataView TestView = new DataView (dataTable);
 518                         TestView.Delete (0);
 519                         DataRow r = TestView.Table.Rows [0];
 520                         Assertion.Assert ("Dv #1", !(r ["itemId"] == "item 1"));
 521                 }
 522
 523                 [Test]
 524                 [ExpectedException (typeof (IndexOutOfRangeException))]
 525                 public void TestDeleteOutOfBounds ()
 526                 {
 527                         DataView TestView = new DataView (dataTable);
 528                         TestView.Delete (100);
 529                 }
 530
 531                 [Test]
 532                 [ExpectedException (typeof (DataException))]
 533                 public void TestDeleteNotAllowed ()
 534                  {
 535                         DataView TestView = new DataView (dataTable);
 536                         TestView.AllowDelete = false;
 537                         TestView.Delete (0);
 538                 }
 539
 540                 [Test]
 541                 [ExpectedException (typeof (DataException))]
 542                 public void TestDeleteClosed ()
 543                 {
 544                         DataView TestView = new DataView (dataTable);
 545                         TestView.Dispose (); // Close the table
 546                         TestView.Delete (0);
 547                 }
 548
 549                 [Test] // based on bug #74631
 550                 public void TestDeleteAndCount ()
 551                 {
 552                         DataSet dataset = new DataSet ("new");
 553                         DataTable dt = new DataTable ("table1");
 554                         dataset.Tables.Add (dt);
 555                         dt.Columns.Add ("col1");
 556                         dt.Columns.Add ("col2");
 557                         dt.Rows.Add (new object []{1,1});
 558                         dt.Rows.Add (new object []{1,2});
 559                         dt.Rows.Add (new object []{1,3});
 560
 561                         DataView dataView = new DataView (dataset.Tables[0]);
 562
 563                         AssertEquals ("before delete", 3, dataView.Count);
 564                         dataView.AllowDelete = true;
 565
 566                         // Deleting the first row
 567                         dataView.Delete (0);
 568
 569                         AssertEquals ("before delete", 2, dataView.Count);
 570                 }
 571
 572                 [Test]
 573                 public void ListChangeOnSetItem ()
 574                 {
 575                         DataTable dt = new DataTable ("table");
 576                         dt.Columns.Add ("col1");
 577                         dt.Columns.Add ("col2");
 578                         dt.Columns.Add ("col3");
 579                         dt.Rows.Add (new object [] {1, 2, 3});
 580                         dt.AcceptChanges ();
 581                         DataView dv = new DataView (dt);
 582                         dv.ListChanged += new ListChangedEventHandler (OnChange);
 583                         dv [0] ["col1"] = 4;
 584                 }
 585
 586                 ListChangedEventArgs ListChangeArgOnSetItem;
 587
 588                 void OnChange (object o, ListChangedEventArgs e)
 589                 {
 590                         if (ListChangeArgOnSetItem != null)
 591                                 throw new Exception ("The event is already fired.");
 592                         ListChangeArgOnSetItem = e;
 593                 }
 594
 595                 [Test]
 596                 [NUnit.Framework.Category ("NotWorking")]
 597                 public void CancelEditAndEvents ()
 598                 {
 599                         string reference = " =====ItemAdded:3 ------4 =====ItemAdded:3 =====ItemAdded:4 ------5 =====ItemAdded:4 =====ItemAdded:5 ------6 =====ItemDeleted:5 ------5 =====ItemAdded:5";
 600
 601                         eventWriter = new StringWriter ();
 602
 603                         DataTable dt = new DataTable ();
 604                         dt.Columns.Add ("col1");
 605                         dt.Columns.Add ("col2");
 606                         dt.Columns.Add ("col3");
 607                         dt.Rows.Add (new object [] {1,2,3});
 608                         dt.Rows.Add (new object [] {1,2,3});
 609                         dt.Rows.Add (new object [] {1,2,3});
 610
 611                         DataView dv = new DataView (dt);
 612                         dv.ListChanged += new ListChangedEventHandler (ListChanged);
 613                         DataRowView a1 = dv.AddNew ();
 614                         eventWriter.Write (" ------" + dv.Count);
 615                         // I wonder why but MS fires another event here.
 616                         a1 = dv.AddNew ();
 617                         eventWriter.Write (" ------" + dv.Count);
 618                         // I wonder why but MS fires another event here.
 619                         DataRowView a2 = dv.AddNew ();
 620                         eventWriter.Write (" ------" + dv.Count);
 621                         a2.CancelEdit ();
 622                         eventWriter.Write (" ------" + dv.Count);
 623                         DataRowView a3 = dv.AddNew ();
 624
 625                         AssertEquals (reference, eventWriter.ToString ());
 626                 }
 627
 628                 private void ListChanged (object o, ListChangedEventArgs e)
 629                 {
 630                         eventWriter.Write (" =====" + e.ListChangedType + ":" + e.NewIndex);
 631                 }
 632
 633                 [Test]
 634                 [NUnit.Framework.Category ("NotWorking")]
 635                 public void ComplexEventSequence1 ()
 636                 {
 637                         string result = @"setting table...
 638 ---- OnListChanged PropertyDescriptorChanged,0,0
 639 ----- UpdateIndex : True
 640 ---- OnListChanged Reset,-1,-1
 641 table was set.
 642 ---- OnListChanged PropertyDescriptorAdded,0,0
 643  col1 added.
 644 ---- OnListChanged PropertyDescriptorAdded,0,0
 645  col2 added.
 646 ---- OnListChanged PropertyDescriptorAdded,0,0
 647  col3 added.
 648  uniq added.
 649 ----- UpdateIndex : True
 650 ---- OnListChanged Reset,-1,-1
 651  sort changed.
 652 ---- OnListChanged PropertyDescriptorDeleted,0,0
 653  col3 removed.
 654 ----- UpdateIndex : True
 655 ---- OnListChanged Reset,-1,-1
 656  rowfilter changed.
 657 ----- UpdateIndex : True
 658 ---- OnListChanged Reset,-1,-1
 659  rowstatefilter changed.
 660 ----- UpdateIndex : True
 661 ---- OnListChanged Reset,-1,-1
 662  rowstatefilter changed.
 663 ---- OnListChanged ItemAdded,0,-1
 664  added row to Rows.
 665 ---- OnListChanged ItemAdded,0,-1
 666  added row to Rows.
 667 ---- OnListChanged ItemAdded,0,-1
 668  added row to Rows.
 669 ---- OnListChanged ItemAdded,3,-1
 670  AddNew() invoked.
 671 4
 672 ---- OnListChanged ItemDeleted,3,-1
 673 ---- OnListChanged ItemMoved,-2147483648,3
 674  EndEdit() invoked.
 675 3
 676 ---- OnListChanged ItemMoved,0,-2147483648
 677  value changed to appear.
 678 4
 679 ---- OnListChanged ItemMoved,3,0
 680  value moved.
 681 4
 682 ---- OnListChanged ItemMoved,1,3
 683  value moved again.
 684 4
 685 ---- OnListChanged PropertyDescriptorChanged,0,0
 686 ----- UpdateIndex : True
 687 ---- OnListChanged Reset,-1,-1
 688 table changed.
 689 ";
 690
 691                         eventWriter = new StringWriter ();
 692
 693                         DataTable dt = new DataTable ("table");
 694                         ComplexEventSequence1View dv =
 695                                 new ComplexEventSequence1View (dt, eventWriter);
 696                         dt.Columns.Add ("col1");
 697                         eventWriter.WriteLine (" col1 added.");
 698                         dt.Columns.Add ("col2");
 699                         eventWriter.WriteLine (" col2 added.");
 700                         dt.Columns.Add ("col3");
 701                         eventWriter.WriteLine (" col3 added.");
 702                         dt.Constraints.Add (new UniqueConstraint (dt.Columns [0]));
 703                         eventWriter.WriteLine (" uniq added.");
 704                         dv.Sort = "col2";
 705                         eventWriter.WriteLine (" sort changed.");
 706                         dt.Columns.Remove ("col3");
 707                         eventWriter.WriteLine (" col3 removed.");
 708                         dv.RowFilter = "col1 <> 0";
 709                         eventWriter.WriteLine (" rowfilter changed.");
 710                         dv.RowStateFilter = DataViewRowState.Deleted;
 711                         eventWriter.WriteLine (" rowstatefilter changed.");
 712                         // FIXME: should be also tested.
 713 //                      dv.ApplyDefaultSort = true;
 714 //                      eventWriter.WriteLine (" apply default sort changed.");
 715                         dv.RowStateFilter = DataViewRowState.CurrentRows;
 716                         eventWriter.WriteLine (" rowstatefilter changed.");
 717                         dt.Rows.Add (new object [] {1, 3});
 718                         eventWriter.WriteLine (" added row to Rows.");
 719                         dt.Rows.Add (new object [] {2, 2});
 720                         eventWriter.WriteLine (" added row to Rows.");
 721                         dt.Rows.Add (new object [] {3, 1});
 722                         eventWriter.WriteLine (" added row to Rows.");
 723                         DataRowView drv = dv.AddNew ();
 724                         eventWriter.WriteLine (" AddNew() invoked.");
 725                         eventWriter.WriteLine (dv.Count);
 726                         drv [0] = 0;
 727                         drv.EndEdit ();
 728                         eventWriter.WriteLine (" EndEdit() invoked.");
 729                         eventWriter.WriteLine (dv.Count);
 730                         dt.Rows [dt.Rows.Count - 1] [0] = 4;
 731                         eventWriter.WriteLine (" value changed to appear.");
 732                         eventWriter.WriteLine (dv.Count);
 733                         dt.Rows [dt.Rows.Count - 1] [1] = 4;
 734                         eventWriter.WriteLine (" value moved.");
 735                         eventWriter.WriteLine (dv.Count);
 736                         dt.Rows [dt.Rows.Count - 1] [1] = 1.5;
 737                         eventWriter.WriteLine (" value moved again.");
 738                         eventWriter.WriteLine (dv.Count);
 739                         dv.Table = new DataTable ("table2");
 740                         eventWriter.WriteLine ("table changed.");
 741
 742                         AssertEquals (result, eventWriter.ToString ().Replace ("\r\n", "\n"));
 743                 }
 744
 745                 public class ComplexEventSequence1View : DataView
 746                 {
 747                         TextWriter w;
 748
 749                         public ComplexEventSequence1View (DataTable dt,
 750                                 TextWriter w) : base ()
 751                         {
 752                                 this.w = w;
 753                                 w.WriteLine ("setting table...");
 754                                 Table = dt;
 755                                 w.WriteLine ("table was set.");
 756                         }
 757
 758                         protected override void OnListChanged (ListChangedEventArgs e)
 759                         {
 760                                 if (w != null)
 761                                         w.WriteLine ("---- OnListChanged " + e.ListChangedType + "," + e.NewIndex + "," + e.OldIndex);
 762                                 base.OnListChanged (e);
 763                         }
 764
 765                         protected override void UpdateIndex (bool force)
 766                         {
 767                                 if (w != null)
 768                                         w.WriteLine ("----- UpdateIndex : " + force);
 769                                 base.UpdateIndex (force);
 770                         }
 771                 }
 772         }
 773 }