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