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

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