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