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