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                 public void BeginInit ()
 360                 {
 361                         DataTable table = new DataTable ("table");
 362                         DataView dv = new DataView ();
 363                         DataColumn col1 = new DataColumn ("col1");
 364                         DataColumn col2 = new DataColumn ("col2");
 365
 366                         dv.BeginInit ();
 367                         table.BeginInit ();
 368                         table.Columns.AddRange (new DataColumn[] {col1,col2});
 369
 370                         dv.Table = table;
 371                         AssertNull ("#1", dv.Table);
 372                         dv.EndInit ();
 373
 374                         AssertEquals ("#2", table, dv.Table);
 375                         AssertEquals ("#3", 0, table.Columns.Count);
 376
 377                         table.EndInit ();
 378                         AssertEquals ("#4", 2, table.Columns.Count);
 379                 }
 380
 381                 [Test]
 382                 [ExpectedException(typeof(ArgumentException))]
 383                 public void Find_1 ()
 384                 {
 385                         /* since the sort key is not specified. Must raise a ArgumentException */
 386                         int sIndex = dataView.Find ("abc");
 387                 }
 388
 389                 [Test]
 390                 public void Find_2 ()
 391                 {
 392                         int randInt;
 393                         DataRowView drv;
 394                         randInt = rndm.Next () % rowCount;
 395                         dataView.Sort = "itemId";
 396                         drv = dataView [randInt];
 397                         AssertEquals ("test#01",randInt,dataView.Find (drv ["itemId"]));
 398
 399                         dataView.Sort = "itemId DESC";
 400                         drv = dataView [randInt];
 401                         AssertEquals ("test#02",randInt,dataView.Find (drv ["itemId"]));
 402
 403                         dataView.Sort = "itemId, itemName";
 404                         drv = dataView [randInt];
 405                         object [] keys = new object [2];
 406                         keys [0] = drv ["itemId"];
 407                         keys [1] = drv ["itemName"];
 408                         AssertEquals ("test#03",randInt,dataView.Find (keys));
 409
 410                         dataView.Sort = "itemId";
 411                         AssertEquals ("test#04",-1,dataView.Find("no item"));
 412
 413                 }
 414
 415                 [Test]
 416                 [ExpectedException (typeof (ArgumentException))]
 417 #if TARGET_JVM
 418                 [Category("NotWorking")] // defect 5446
 419 #endif
 420                 public void Find_3 ()
 421                 {
 422                         dataView.Sort = "itemID, itemName";
 423                         /* expecting order key count mismatch */
 424                         dataView.Find ("itemValue");
 425                 }
 426
 427                 [Test]
 428                 [Ignore("Test code not implemented")]
 429                 public void GetEnumerator ()
 430                 {
 431                         //TODO
 432                 }
 433
 434                 [Test]
 435                 public void ToStringTest ()
 436                 {
 437                         AssertEquals ("test#01","System.Data.DataView",dataView.ToString());
 438                 }
 439
 440                 [Test]
 441                 public void TestingEventHandling ()
 442                 {
 443                         dataView.Sort = "itemId";
 444                         DataRow dr;
 445                         dr = dataTable.NewRow ();
 446                         dr ["itemId"] = "item 0";
 447                         dr ["itemName"] = "name " + rndm.Next ();
 448                         dr ["itemPrice"] = "Rs. " + (rndm.Next () % 1000);
 449                         dr ["itemCategory"] = "Cat " + ((rndm.Next () % 10) + 1);
 450                         dataTable.Rows.Add(dr);
 451
 452                         //PrintTableOrView(dataView, "ItemAdded");
 453                         AssertEquals ("test#01",ListChangedType.ItemAdded,listChangedArgs.ListChangedType);
 454                         listChangedArgs = null;
 455
 456                         dr ["itemId"] = "aitem 0";
 457                         // PrintTableOrView(dataView, "ItemChanged");
 458                         AssertEquals ("test#02",ListChangedType.ItemChanged,listChangedArgs.ListChangedType);
 459                         listChangedArgs = null;
 460
 461                         dr ["itemId"] = "zitem 0";
 462                         // PrintTableOrView(dataView, "ItemMoved");
 463                         AssertEquals ("test#03",ListChangedType.ItemMoved,listChangedArgs.ListChangedType);
 464                         listChangedArgs = null;
 465
 466                         dataTable.Rows.Remove (dr);
 467                         // PrintTableOrView(dataView, "ItemDeleted");
 468                         AssertEquals ("test#04",ListChangedType.ItemDeleted,listChangedArgs.ListChangedType);
 469
 470                         listChangedArgs = null;
 471                         DataColumn dc5 = new DataColumn ("itemDesc");
 472                         dataTable.Columns.Add (dc5);
 473                         // PrintTableOrView(dataView, "PropertyDescriptorAdded");
 474                         AssertEquals ("test#05",ListChangedType.PropertyDescriptorAdded,listChangedArgs.ListChangedType);
 475
 476                         listChangedArgs = null;
 477                         dc5.ColumnName = "itemDescription";
 478                         // PrintTableOrView(dataView, "PropertyDescriptorChanged");
 479                         // AssertEquals ("test#06",ListChangedType.PropertyDescriptorChanged,listChangedArgs.ListChangedType);
 480
 481                         listChangedArgs = null;
 482                         dataTable.Columns.Remove (dc5);
 483                         // PrintTableOrView(dataView, "PropertyDescriptorDeleted");
 484                         AssertEquals ("test#07",ListChangedType.PropertyDescriptorDeleted,listChangedArgs.ListChangedType);
 485                 }
 486
 487                 [Test]
 488                 public void TestFindRows ()
 489                 {
 490                         DataView TestView = new DataView (dataTable);
 491                         TestView.Sort = "itemId";
 492                         DataRowView[] Result = TestView.FindRows ("item 3");
 493                         Assertion.AssertEquals ("Dv #1", 1, Result.Length);
 494                         Assertion.AssertEquals ("Dv #2", "item 3", Result [0]["itemId"]);
 495                 }
 496
 497                 [Test]
 498                 [ExpectedException (typeof (ArgumentException))]
 499                 public void FindRowsWithoutSort ()
 500                 {
 501                         DataTable dt = new DataTable ("table");
 502                         dt.Columns.Add ("col1");
 503                         dt.Columns.Add ("col2");
 504                         dt.Columns.Add ("col3");
 505                         dt.Rows.Add (new object [] {1,2,3});
 506                         dt.Rows.Add (new object [] {4,5,6});
 507                         dt.Rows.Add (new object [] {4,7,8});
 508                         dt.Rows.Add (new object [] {5,7,8});
 509                         dt.Rows.Add (new object [] {4,8,9});
 510                         DataView dv = new DataView (dt);
 511                         dv.Find (1);
 512                 }
 513
 514                 [Test]
 515                 [ExpectedException (typeof (ArgumentException))]
 516                 public void FindRowsInconsistentKeyLength ()
 517                 {
 518                         DataTable dt = new DataTable ("table");
 519                         dt.Columns.Add ("col1");
 520                         dt.Columns.Add ("col2");
 521                         dt.Columns.Add ("col3");
 522                         dt.Rows.Add (new object [] {1,2,3});
 523                         dt.Rows.Add (new object [] {4,5,6});
 524                         dt.Rows.Add (new object [] {4,7,8});
 525                         dt.Rows.Add (new object [] {5,7,8});
 526                         dt.Rows.Add (new object [] {4,8,9});
 527                         DataView dv = new DataView (dt, null, "col1",
 528                                 DataViewRowState.CurrentRows);
 529                         dv.FindRows (new object [] {1, 2, 3});
 530                 }
 531
 532                 [Test]
 533                 [ExpectedException (typeof (DeletedRowInaccessibleException))]
 534                 public void TestDelete ()
 535                 {
 536                         DataView TestView = new DataView (dataTable);
 537                         TestView.Delete (0);
 538                         DataRow r = TestView.Table.Rows [0];
 539                         Assertion.Assert ("Dv #1", !(r ["itemId"] == "item 1"));
 540                 }
 541
 542                 [Test]
 543                 [ExpectedException (typeof (IndexOutOfRangeException))]
 544                 public void TestDeleteOutOfBounds ()
 545                 {
 546                         DataView TestView = new DataView (dataTable);
 547                         TestView.Delete (100);
 548                 }
 549
 550                 [Test]
 551                 [ExpectedException (typeof (DataException))]
 552                 public void TestDeleteNotAllowed ()
 553                  {
 554                         DataView TestView = new DataView (dataTable);
 555                         TestView.AllowDelete = false;
 556                         TestView.Delete (0);
 557                 }
 558
 559                 [Test]
 560                 [ExpectedException (typeof (DataException))]
 561                 public void TestDeleteClosed ()
 562                 {
 563                         DataView TestView = new DataView (dataTable);
 564                         TestView.Dispose (); // Close the table
 565                         TestView.Delete (0);
 566                 }
 567
 568                 [Test] // based on bug #74631
 569                 public void TestDeleteAndCount ()
 570                 {
 571                         DataSet dataset = new DataSet ("new");
 572                         DataTable dt = new DataTable ("table1");
 573                         dataset.Tables.Add (dt);
 574                         dt.Columns.Add ("col1");
 575                         dt.Columns.Add ("col2");
 576                         dt.Rows.Add (new object []{1,1});
 577                         dt.Rows.Add (new object []{1,2});
 578                         dt.Rows.Add (new object []{1,3});
 579
 580                         DataView dataView = new DataView (dataset.Tables[0]);
 581
 582                         AssertEquals ("before delete", 3, dataView.Count);
 583                         dataView.AllowDelete = true;
 584
 585                         // Deleting the first row
 586                         dataView.Delete (0);
 587
 588                         AssertEquals ("before delete", 2, dataView.Count);
 589                 }
 590
 591                 [Test]
 592                 public void ListChangeOnSetItem ()
 593                 {
 594                         DataTable dt = new DataTable ("table");
 595                         dt.Columns.Add ("col1");
 596                         dt.Columns.Add ("col2");
 597                         dt.Columns.Add ("col3");
 598                         dt.Rows.Add (new object [] {1, 2, 3});
 599                         dt.AcceptChanges ();
 600                         DataView dv = new DataView (dt);
 601                         dv.ListChanged += new ListChangedEventHandler (OnChange);
 602                         dv [0] ["col1"] = 4;
 603                 }
 604
 605                 ListChangedEventArgs ListChangeArgOnSetItem;
 606
 607                 void OnChange (object o, ListChangedEventArgs e)
 608                 {
 609                         if (ListChangeArgOnSetItem != null)
 610                                 throw new Exception ("The event is already fired.");
 611                         ListChangeArgOnSetItem = e;
 612                 }
 613
 614                 [Test]
 615                 public void CancelEditAndEvents ()
 616                 {
 617                         string reference = " =====ItemAdded:3 ------4 =====ItemAdded:3 =====ItemAdded:4 ------5 =====ItemAdded:4 =====ItemAdded:5 ------6 =====ItemDeleted:5 ------5 =====ItemAdded:5";
 618
 619                         eventWriter = new StringWriter ();
 620
 621                         DataTable dt = new DataTable ();
 622                         dt.Columns.Add ("col1");
 623                         dt.Columns.Add ("col2");
 624                         dt.Columns.Add ("col3");
 625                         dt.Rows.Add (new object [] {1,2,3});
 626                         dt.Rows.Add (new object [] {1,2,3});
 627                         dt.Rows.Add (new object [] {1,2,3});
 628
 629                         DataView dv = new DataView (dt);
 630                         dv.ListChanged += new ListChangedEventHandler (ListChanged);
 631                         DataRowView a1 = dv.AddNew ();
 632                         eventWriter.Write (" ------" + dv.Count);
 633                         // I wonder why but MS fires another event here.
 634                         a1 = dv.AddNew ();
 635                         eventWriter.Write (" ------" + dv.Count);
 636                         // I wonder why but MS fires another event here.
 637                         DataRowView a2 = dv.AddNew ();
 638                         eventWriter.Write (" ------" + dv.Count);
 639                         a2.CancelEdit ();
 640                         eventWriter.Write (" ------" + dv.Count);
 641                         DataRowView a3 = dv.AddNew ();
 642
 643                         AssertEquals (reference, eventWriter.ToString ());
 644                 }
 645
 646                 private void ListChanged (object o, ListChangedEventArgs e)
 647                 {
 648                         eventWriter.Write (" =====" + e.ListChangedType + ":" + e.NewIndex);
 649                 }
 650
 651                 [Test]
 652                 [NUnit.Framework.Category ("NotWorking")]
 653                 public void ComplexEventSequence1 ()
 654                 {
 655                         string result = @"setting table...
 656 ---- OnListChanged PropertyDescriptorChanged,0,0
 657 ----- UpdateIndex : True
 658 ---- OnListChanged Reset,-1,-1
 659 table was set.
 660 ---- OnListChanged PropertyDescriptorAdded,0,0
 661  col1 added.
 662 ---- OnListChanged PropertyDescriptorAdded,0,0
 663  col2 added.
 664 ---- OnListChanged PropertyDescriptorAdded,0,0
 665  col3 added.
 666  uniq added.
 667 ----- UpdateIndex : True
 668 ---- OnListChanged Reset,-1,-1
 669  sort changed.
 670 ---- OnListChanged PropertyDescriptorDeleted,0,0
 671  col3 removed.
 672 ----- UpdateIndex : True
 673 ---- OnListChanged Reset,-1,-1
 674  rowfilter changed.
 675 ----- UpdateIndex : True
 676 ---- OnListChanged Reset,-1,-1
 677  rowstatefilter changed.
 678 ----- UpdateIndex : True
 679 ---- OnListChanged Reset,-1,-1
 680  rowstatefilter changed.
 681 ---- OnListChanged ItemAdded,0,-1
 682  added row to Rows.
 683 ---- OnListChanged ItemAdded,0,-1
 684  added row to Rows.
 685 ---- OnListChanged ItemAdded,0,-1
 686  added row to Rows.
 687 ---- OnListChanged ItemAdded,3,-1
 688  AddNew() invoked.
 689 4
 690 ---- OnListChanged ItemDeleted,3,-1
 691 ---- OnListChanged ItemMoved,-2147483648,3
 692  EndEdit() invoked.
 693 3
 694 ---- OnListChanged ItemMoved,0,-2147483648
 695  value changed to appear.
 696 4
 697 ---- OnListChanged ItemMoved,3,0
 698  value moved.
 699 4
 700 ---- OnListChanged ItemMoved,1,3
 701  value moved again.
 702 4
 703 ---- OnListChanged PropertyDescriptorChanged,0,0
 704 ----- UpdateIndex : True
 705 ---- OnListChanged Reset,-1,-1
 706 table changed.
 707 ";
 708
 709                         eventWriter = new StringWriter ();
 710
 711                         DataTable dt = new DataTable ("table");
 712                         ComplexEventSequence1View dv =
 713                                 new ComplexEventSequence1View (dt, eventWriter);
 714                         dt.Columns.Add ("col1");
 715                         eventWriter.WriteLine (" col1 added.");
 716                         dt.Columns.Add ("col2");
 717                         eventWriter.WriteLine (" col2 added.");
 718                         dt.Columns.Add ("col3");
 719                         eventWriter.WriteLine (" col3 added.");
 720                         dt.Constraints.Add (new UniqueConstraint (dt.Columns [0]));
 721                         eventWriter.WriteLine (" uniq added.");
 722                         dv.Sort = "col2";
 723                         eventWriter.WriteLine (" sort changed.");
 724                         dt.Columns.Remove ("col3");
 725                         eventWriter.WriteLine (" col3 removed.");
 726                         dv.RowFilter = "col1 <> 0";
 727                         eventWriter.WriteLine (" rowfilter changed.");
 728                         dv.RowStateFilter = DataViewRowState.Deleted;
 729                         eventWriter.WriteLine (" rowstatefilter changed.");
 730                         // FIXME: should be also tested.
 731 //                      dv.ApplyDefaultSort = true;
 732 //                      eventWriter.WriteLine (" apply default sort changed.");
 733                         dv.RowStateFilter = DataViewRowState.CurrentRows;
 734                         eventWriter.WriteLine (" rowstatefilter changed.");
 735                         dt.Rows.Add (new object [] {1, 3});
 736                         eventWriter.WriteLine (" added row to Rows.");
 737                         dt.Rows.Add (new object [] {2, 2});
 738                         eventWriter.WriteLine (" added row to Rows.");
 739                         dt.Rows.Add (new object [] {3, 1});
 740                         eventWriter.WriteLine (" added row to Rows.");
 741                         DataRowView drv = dv.AddNew ();
 742                         eventWriter.WriteLine (" AddNew() invoked.");
 743                         eventWriter.WriteLine (dv.Count);
 744                         drv [0] = 0;
 745                         drv.EndEdit ();
 746                         eventWriter.WriteLine (" EndEdit() invoked.");
 747                         eventWriter.WriteLine (dv.Count);
 748                         dt.Rows [dt.Rows.Count - 1] [0] = 4;
 749                         eventWriter.WriteLine (" value changed to appear.");
 750                         eventWriter.WriteLine (dv.Count);
 751                         dt.Rows [dt.Rows.Count - 1] [1] = 4;
 752                         eventWriter.WriteLine (" value moved.");
 753                         eventWriter.WriteLine (dv.Count);
 754                         dt.Rows [dt.Rows.Count - 1] [1] = 1.5;
 755                         eventWriter.WriteLine (" value moved again.");
 756                         eventWriter.WriteLine (dv.Count);
 757                         dv.Table = new DataTable ("table2");
 758                         eventWriter.WriteLine ("table changed.");
 759
 760                         AssertEquals (result, eventWriter.ToString ().Replace ("\r\n", "\n"));
 761                 }
 762
 763                 public class ComplexEventSequence1View : DataView
 764                 {
 765                         TextWriter w;
 766
 767                         public ComplexEventSequence1View (DataTable dt,
 768                                 TextWriter w) : base ()
 769                         {
 770                                 this.w = w;
 771                                 w.WriteLine ("setting table...");
 772                                 Table = dt;
 773                                 w.WriteLine ("table was set.");
 774                         }
 775
 776                         protected override void OnListChanged (ListChangedEventArgs e)
 777                         {
 778                                 if (w != null)
 779                                         w.WriteLine ("---- OnListChanged " + e.ListChangedType + "," + e.NewIndex + "," + e.OldIndex);
 780                                 base.OnListChanged (e);
 781                         }
 782
 783                         protected override void UpdateIndex (bool force)
 784                         {
 785                                 if (w != null)
 786                                         w.WriteLine ("----- UpdateIndex : " + force);
 787                                 base.UpdateIndex (force);
 788                         }
 789                 }
 790         }
 791 }