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 //
   9 // (C) 2003 Patrick Kalkman
  10 //
  11 // Copyright (C) 2004-2005 Novell, Inc (http://www.novell.com)
  12 //
  13 // Permission is hereby granted, free of charge, to any person obtaining
  14 // a copy of this software and associated documentation files (the
  15 // "Software"), to deal in the Software without restriction, including
  16 // without limitation the rights to use, copy, modify, merge, publish,
  17 // distribute, sublicense, and/or sell copies of the Software, and to
  18 // permit persons to whom the Software is furnished to do so, subject to
  19 // the following conditions:
  20 //
  21 // The above copyright notice and this permission notice shall be
  22 // included in all copies or substantial portions of the Software.
  23 //
  24 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  25 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  26 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  27 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  28 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  29 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  30 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  31 //
  32
  33
  34
  35 using NUnit.Framework;
  36 using System;
  37 using System.Data;
  38 using System.ComponentModel;
  39 using System.IO;
  40
  41 namespace MonoTests.System.Data
  42 {
  43         [TestFixture]
  44         public class DataViewTest : Assertion
  45         {
  46                 DataTable dataTable;
  47                 DataView  dataView;
  48                 Random rndm;
  49                 int seed, rowCount;
  50                 ListChangedEventArgs listChangedArgs;
  51                 TextWriter eventWriter;
  52
  53                 [SetUp]
  54                 public void GetReady ()
  55                 {
  56                         dataTable = new DataTable ("itemTable");
  57                         DataColumn dc1 = new DataColumn ("itemId");
  58                         DataColumn dc2 = new DataColumn ("itemName");
  59                         DataColumn dc3 = new DataColumn ("itemPrice");
  60                         DataColumn dc4 = new DataColumn ("itemCategory");
  61
  62                         dataTable.Columns.Add (dc1);
  63                         dataTable.Columns.Add (dc2);
  64                         dataTable.Columns.Add (dc3);
  65                         dataTable.Columns.Add (dc4);
  66                         DataRow dr;
  67                         seed = 123;
  68                         rowCount = 5;
  69                         rndm = new Random (seed);
  70                         for (int i = 1; i <= rowCount; i++) {
  71                                 dr = dataTable.NewRow ();
  72                                 dr["itemId"] = "item " + i;
  73                                 dr["itemName"] = "name " + rndm.Next ();
  74                                 dr["itemPrice"] = "Rs. " + (rndm.Next () % 1000);
  75                                 dr["itemCategory"] = "Cat " + ((rndm.Next () % 10) + 1);
  76                                 dataTable.Rows.Add (dr);
  77                         }
  78                         dataTable.AcceptChanges ();
  79                         dataView = new DataView (dataTable);
  80                         dataView.ListChanged += new ListChangedEventHandler (OnListChanged);
  81                         listChangedArgs = null;
  82                 }
  83
  84                 protected void OnListChanged (object sender, ListChangedEventArgs args)
  85                 {
  86                         listChangedArgs = args;
  87                         // for debugging
  88                         /*Console.WriteLine("EventType :: " + listChangedArgs.ListChangedType +
  89                                                           "  oldIndex  :: " + listChangedArgs.OldIndex +
  90                                                           "  NewIndex  :: " + listChangedArgs.NewIndex);*/
  91
  92                 }
  93
  94                 private void PrintTableOrView (DataTable t, string label)
  95                 {
  96                         Console.WriteLine ("\n" + label);
  97                         for (int i = 0; i<t.Rows.Count; i++){
  98                                 foreach (DataColumn dc in t.Columns)
  99                                         Console.Write (t.Rows [i][dc] + "\t");
 100                                 Console.WriteLine ("");
 101                         }
 102                         Console.WriteLine ();
 103                 }
 104
 105                 private void PrintTableOrView (DataView dv, string label)
 106                 {
 107                         Console.WriteLine ("\n" + label);
 108                         Console.WriteLine ("Sort Key :: " + dv.Sort);
 109                         for (int i = 0; i < dv.Count; i++) {
 110                                 foreach (DataColumn dc in dv.Table.Columns)
 111                                         Console.Write (dv [i].Row [dc] + "\t");
 112                                 Console.WriteLine ("");
 113                         }
 114                         Console.WriteLine ();
 115                 }
 116
 117                 [TearDown]
 118                 public void Clean ()
 119                 {
 120                         dataTable = null;
 121                         dataView = null;
 122                 }
 123
 124                 [Test]
 125                 public void DataView ()
 126                 {
 127                         DataView dv1,dv2,dv3;
 128                         dv1 = new DataView ();
 129                         // AssertEquals ("test#01",null,dv1.Table);
 130                         AssertEquals ("test#02",true,dv1.AllowNew);
 131                         AssertEquals ("test#03",true,dv1.AllowEdit);
 132                         AssertEquals ("test#04",true,dv1.AllowDelete);
 133                         AssertEquals ("test#05",false,dv1.ApplyDefaultSort);
 134                         AssertEquals ("test#06",string.Empty,dv1.RowFilter);
 135                         AssertEquals ("test#07",DataViewRowState.CurrentRows,dv1.RowStateFilter);
 136                         AssertEquals ("test#08",string.Empty,dv1.Sort);
 137
 138                         dv2 = new DataView (dataTable);
 139                         AssertEquals ("test#09","itemTable",dv2.Table.TableName);
 140                         AssertEquals ("test#10",string.Empty,dv2.Sort);
 141                         AssertEquals ("test#11",false,dv2.ApplyDefaultSort);
 142                         AssertEquals ("test#12",dataTable.Rows[0],dv2[0].Row);
 143
 144                         dv3 = new DataView (dataTable,"","itemId DESC",DataViewRowState.CurrentRows);
 145                         AssertEquals ("test#13","",dv3.RowFilter);
 146                         AssertEquals ("test#14","itemId DESC",dv3.Sort);
 147                         AssertEquals ("test#15",DataViewRowState.CurrentRows,dv3.RowStateFilter);
 148                         //AssertEquals ("test#16",dataTable.Rows.[(dataTable.Rows.Count-1)],dv3[0]);
 149                 }
 150
 151                  [Test]
 152                  public void TestValue ()
 153                  {
 154                         DataView TestView = new DataView (dataTable);
 155                         Assertion.AssertEquals ("Dv #1", "item 1", TestView [0]["itemId"]);
 156                  }
 157
 158                  [Test]
 159                  public void TestCount ()
 160                  {
 161                         DataView TestView = new DataView (dataTable);
 162                         Assertion.AssertEquals ("Dv #3", 5, TestView.Count);
 163                  }
 164
 165                 [Test]
 166                 public void AllowNew ()
 167                 {
 168                         AssertEquals ("test#01",true,dataView.AllowNew);
 169                 }
 170
 171                 [Test]
 172                 public void ApplyDefaultSort ()
 173                 {
 174                         UniqueConstraint uc = new UniqueConstraint (dataTable.Columns["itemId"]);
 175                         dataTable.Constraints.Add (uc);
 176                         dataView.ApplyDefaultSort = true;
 177                         // dataView.Sort = "itemName";
 178                         // AssertEquals ("test#01","item 1",dataView[0]["itemId"]);
 179                         AssertEquals ("test#02",ListChangedType.Reset,listChangedArgs.ListChangedType);
 180                         // UnComment the line below to see if dataView is sorted
 181                         //   PrintTableOrView (dataView,"* OnApplyDefaultSort");
 182                 }
 183
 184                 [Test]
 185                 public void RowStateFilter ()
 186                 {
 187                         dataView.RowStateFilter = DataViewRowState.Deleted;
 188                         AssertEquals ("test#01",ListChangedType.Reset,listChangedArgs.ListChangedType);
 189                 }
 190
 191                 [Test]
 192                 public void RowStateFilter_2 ()
 193                 {
 194                         DataSet dataset = new DataSet ("new");
 195                         DataTable dt = new DataTable ("table1");
 196                         dataset.Tables.Add (dt);
 197                         dt.Columns.Add ("col1");
 198                         dt.Columns.Add ("col2");
 199                         dt.Rows.Add (new object [] {1,1});
 200                         dt.Rows.Add (new object [] {1,2});
 201                         dt.Rows.Add (new object [] {1,3});
 202                         dataset.AcceptChanges ();
 203
 204                         DataView dataView = new DataView (dataset.Tables [0]);
 205
 206                         // 'new'  table in this sample contains 6 records
 207                         dataView.AllowEdit = true;
 208                         dataView.AllowDelete = true;
 209                         string v;
 210
 211                         // Editing the row
 212                         dataView [0] ["col1"] = -1;
 213                         dataView.RowStateFilter = DataViewRowState.ModifiedOriginal;
 214                         v = dataView [0] [0].ToString ();
 215                         AssertEquals ("ModifiedOriginal.Count", 1, dataView.Count);
 216                         AssertEquals ("ModifiedOriginal.Value", "1", v);
 217
 218                         // Deleting the row
 219                         dataView.Delete (0);
 220                         dataView.RowStateFilter = DataViewRowState.Deleted;
 221
 222                         v = dataView [0] [0].ToString ();
 223                         AssertEquals ("Deleted.Count", 1, dataView.Count);
 224                         AssertEquals ("Deleted.Value", "1", v);
 225                 }
 226
 227                 [Test]
 228                 public void Sort ()
 229                 {
 230                         dataView.Sort = "itemName DESC";
 231                         AssertEquals ("test#01",ListChangedType.Reset,listChangedArgs.ListChangedType);
 232                         // UnComment the line below to see if dataView is sorted
 233                         // PrintTableOrView (dataView);
 234                 }
 235
 236                 [Test]
 237                 [ExpectedException(typeof(DataException))]
 238                 public void AddNew_1 ()
 239                 {
 240                         dataView.AllowNew = false;
 241                         DataRowView drv = dataView.AddNew ();
 242                 }
 243
 244                 [Test]
 245                 public void AddNew_2 ()
 246                 {
 247                         dataView.AllowNew = true;
 248                         DataRowView drv = dataView.AddNew ();
 249                         AssertEquals ("test#01",ListChangedType.ItemAdded,listChangedArgs.ListChangedType);
 250                         AssertEquals ("test#02",drv["itemName"],dataView [dataView.Count - 1]["itemName"]);
 251                         listChangedArgs = null;
 252                         drv["itemId"] = "item " + 1001;
 253                         drv["itemName"] = "name " + rndm.Next();
 254                         drv["itemPrice"] = "Rs. " + (rndm.Next() % 1000);
 255                         drv["itemCategory"] = "Cat " + ((rndm.Next() % 10) + 1);
 256                         // Actually no events are arisen when items are set.
 257                         AssertNull ("test#03", listChangedArgs);
 258                 }
 259
 260                 [Test]
 261                 [Ignore("Test code not implemented")]
 262                 public void BeginInit ()
 263                 {
 264                         //TODO
 265                 }
 266
 267                 [Test]
 268                 [ExpectedException(typeof(ArgumentException))]
 269                 public void Find_1 ()
 270                 {
 271                         /* since the sort key is not specified. Must raise a ArgumentException */
 272                         int sIndex = dataView.Find ("abc");
 273                 }
 274
 275                 [Test]
 276                 public void Find_2 ()
 277                 {
 278                         int randInt;
 279                         DataRowView drv;
 280                         randInt = rndm.Next () % rowCount;
 281                         dataView.Sort = "itemId";
 282                         drv = dataView [randInt];
 283                         AssertEquals ("test#01",randInt,dataView.Find (drv ["itemId"]));
 284
 285                         dataView.Sort = "itemId DESC";
 286                         drv = dataView [randInt];
 287                         AssertEquals ("test#02",randInt,dataView.Find (drv ["itemId"]));
 288
 289                         dataView.Sort = "itemId, itemName";
 290                         drv = dataView [randInt];
 291                         object [] keys = new object [2];
 292                         keys [0] = drv ["itemId"];
 293                         keys [1] = drv ["itemName"];
 294                         AssertEquals ("test#03",randInt,dataView.Find (keys));
 295
 296                         dataView.Sort = "itemId";
 297                         AssertEquals ("test#04",-1,dataView.Find("no item"));
 298
 299                 }
 300
 301                 [Test]
 302                 [ExpectedException (typeof (ArgumentException))]
 303                 public void Find_3 ()
 304                 {
 305                         dataView.Sort = "itemID, itemName";
 306                         /* expecting order key count mismatch */
 307                         dataView.Find ("itemValue");
 308                 }
 309
 310                 [Test]
 311                 [Ignore("Test code not implemented")]
 312                 public void GetEnumerator ()
 313                 {
 314                         //TODO
 315                 }
 316
 317                 [Test]
 318                 public void ToStringTest ()
 319                 {
 320                         AssertEquals ("test#01","System.Data.DataView",dataView.ToString());
 321                 }
 322
 323                 [Test]
 324                 public void TestingEventHandling ()
 325                 {
 326                         dataView.Sort = "itemId";
 327                         DataRow dr;
 328                         dr = dataTable.NewRow ();
 329                         dr ["itemId"] = "item 0";
 330                         dr ["itemName"] = "name " + rndm.Next ();
 331                         dr ["itemPrice"] = "Rs. " + (rndm.Next () % 1000);
 332                         dr ["itemCategory"] = "Cat " + ((rndm.Next () % 10) + 1);
 333                         dataTable.Rows.Add(dr);
 334
 335                         //PrintTableOrView(dataView, "ItemAdded");
 336                         AssertEquals ("test#01",ListChangedType.ItemAdded,listChangedArgs.ListChangedType);
 337                         listChangedArgs = null;
 338
 339                         dr ["itemId"] = "aitem 0";
 340                         // PrintTableOrView(dataView, "ItemChanged");
 341                         AssertEquals ("test#02",ListChangedType.ItemChanged,listChangedArgs.ListChangedType);
 342                         listChangedArgs = null;
 343
 344                         dr ["itemId"] = "zitem 0";
 345                         // PrintTableOrView(dataView, "ItemMoved");
 346                         AssertEquals ("test#03",ListChangedType.ItemMoved,listChangedArgs.ListChangedType);
 347                         listChangedArgs = null;
 348
 349                         dataTable.Rows.Remove (dr);
 350                         // PrintTableOrView(dataView, "ItemDeleted");
 351                         AssertEquals ("test#04",ListChangedType.ItemDeleted,listChangedArgs.ListChangedType);
 352
 353                         listChangedArgs = null;
 354                         DataColumn dc5 = new DataColumn ("itemDesc");
 355                         dataTable.Columns.Add (dc5);
 356                         // PrintTableOrView(dataView, "PropertyDescriptorAdded");
 357                         AssertEquals ("test#05",ListChangedType.PropertyDescriptorAdded,listChangedArgs.ListChangedType);
 358
 359                         listChangedArgs = null;
 360                         dc5.ColumnName = "itemDescription";
 361                         // PrintTableOrView(dataView, "PropertyDescriptorChanged");
 362                         // AssertEquals ("test#06",ListChangedType.PropertyDescriptorChanged,listChangedArgs.ListChangedType);
 363
 364                         listChangedArgs = null;
 365                         dataTable.Columns.Remove (dc5);
 366                         // PrintTableOrView(dataView, "PropertyDescriptorDeleted");
 367                         AssertEquals ("test#07",ListChangedType.PropertyDescriptorDeleted,listChangedArgs.ListChangedType);
 368                 }
 369
 370                 [Test]
 371                 public void TestFindRows ()
 372                 {
 373                         DataView TestView = new DataView (dataTable);
 374                         TestView.Sort = "itemId";
 375                         DataRowView[] Result = TestView.FindRows ("item 3");
 376                         Assertion.AssertEquals ("Dv #1", 1, Result.Length);
 377                         Assertion.AssertEquals ("Dv #2", "item 3", Result [0]["itemId"]);
 378                 }
 379
 380                 [Test]
 381                 [ExpectedException (typeof (ArgumentException))]
 382                 public void FindRowsWithoutSort ()
 383                 {
 384                         DataTable dt = new DataTable ("table");
 385                         dt.Columns.Add ("col1");
 386                         dt.Columns.Add ("col2");
 387                         dt.Columns.Add ("col3");
 388                         dt.Rows.Add (new object [] {1,2,3});
 389                         dt.Rows.Add (new object [] {4,5,6});
 390                         dt.Rows.Add (new object [] {4,7,8});
 391                         dt.Rows.Add (new object [] {5,7,8});
 392                         dt.Rows.Add (new object [] {4,8,9});
 393                         DataView dv = new DataView (dt);
 394                         dv.Find (1);
 395                 }
 396
 397                 [Test]
 398                 [ExpectedException (typeof (ArgumentException))]
 399                 public void FindRowsInconsistentKeyLength ()
 400                 {
 401                         DataTable dt = new DataTable ("table");
 402                         dt.Columns.Add ("col1");
 403                         dt.Columns.Add ("col2");
 404                         dt.Columns.Add ("col3");
 405                         dt.Rows.Add (new object [] {1,2,3});
 406                         dt.Rows.Add (new object [] {4,5,6});
 407                         dt.Rows.Add (new object [] {4,7,8});
 408                         dt.Rows.Add (new object [] {5,7,8});
 409                         dt.Rows.Add (new object [] {4,8,9});
 410                         DataView dv = new DataView (dt, null, "col1",
 411                                 DataViewRowState.CurrentRows);
 412                         dv.FindRows (new object [] {1, 2, 3});
 413                 }
 414
 415                 [Test]
 416                 [ExpectedException (typeof (DeletedRowInaccessibleException))]
 417                 public void TestDelete ()
 418                 {
 419                         DataView TestView = new DataView (dataTable);
 420                         TestView.Delete (0);
 421                         DataRow r = TestView.Table.Rows [0];
 422                         Assertion.Assert ("Dv #1", !(r ["itemId"] == "item 1"));
 423                 }
 424
 425                 [Test]
 426                 [ExpectedException (typeof (IndexOutOfRangeException))]
 427                 public void TestDeleteOutOfBounds ()
 428                 {
 429                         DataView TestView = new DataView (dataTable);
 430                         TestView.Delete (100);
 431                 }
 432
 433                 [Test]
 434                 [ExpectedException (typeof (DataException))]
 435                 public void TestDeleteNotAllowed ()
 436                  {
 437                         DataView TestView = new DataView (dataTable);
 438                         TestView.AllowDelete = false;
 439                         TestView.Delete (0);
 440                 }
 441
 442                 [Test]
 443                 [ExpectedException (typeof (DataException))]
 444                 public void TestDeleteClosed ()
 445                 {
 446                         DataView TestView = new DataView (dataTable);
 447                         TestView.Dispose (); // Close the table
 448                         TestView.Delete (0);
 449                 }
 450
 451                 [Test] // based on bug #74631
 452                 public void TestDeleteAndCount ()
 453                 {
 454                         DataSet dataset = new DataSet ("new");
 455                         DataTable dt = new DataTable ("table1");
 456                         dataset.Tables.Add (dt);
 457                         dt.Columns.Add ("col1");
 458                         dt.Columns.Add ("col2");
 459                         dt.Rows.Add (new object []{1,1});
 460                         dt.Rows.Add (new object []{1,2});
 461                         dt.Rows.Add (new object []{1,3});
 462
 463                         DataView dataView = new DataView (dataset.Tables[0]);
 464
 465                         AssertEquals ("before delete", 3, dataView.Count);
 466                         dataView.AllowDelete = true;
 467
 468                         // Deleting the first row
 469                         dataView.Delete (0);
 470
 471                         AssertEquals ("before delete", 2, dataView.Count);
 472                 }
 473
 474                 [Test]
 475                 public void ListChangeOnSetItem ()
 476                 {
 477                         DataTable dt = new DataTable ("table");
 478                         dt.Columns.Add ("col1");
 479                         dt.Columns.Add ("col2");
 480                         dt.Columns.Add ("col3");
 481                         dt.Rows.Add (new object [] {1, 2, 3});
 482                         dt.AcceptChanges ();
 483                         DataView dv = new DataView (dt);
 484                         dv.ListChanged += new ListChangedEventHandler (OnChange);
 485                         dv [0] ["col1"] = 4;
 486                 }
 487
 488                 ListChangedEventArgs ListChangeArgOnSetItem;
 489
 490                 void OnChange (object o, ListChangedEventArgs e)
 491                 {
 492                         if (ListChangeArgOnSetItem != null)
 493                                 throw new Exception ("The event is already fired.");
 494                         ListChangeArgOnSetItem = e;
 495                 }
 496
 497                 [Test]
 498                 [NUnit.Framework.Category ("NotWorking")]
 499                 public void CancelEditAndEvents ()
 500                 {
 501                         string reference = " =====ItemAdded:3 ------4 =====ItemAdded:3 =====ItemAdded:4 ------5 =====ItemAdded:4 =====ItemAdded:5 ------6 =====ItemDeleted:5 ------5 =====ItemAdded:5";
 502
 503                         eventWriter = new StringWriter ();
 504
 505                         DataTable dt = new DataTable ();
 506                         dt.Columns.Add ("col1");
 507                         dt.Columns.Add ("col2");
 508                         dt.Columns.Add ("col3");
 509                         dt.Rows.Add (new object [] {1,2,3});
 510                         dt.Rows.Add (new object [] {1,2,3});
 511                         dt.Rows.Add (new object [] {1,2,3});
 512
 513                         DataView dv = new DataView (dt);
 514                         dv.ListChanged += new ListChangedEventHandler (ListChanged);
 515                         DataRowView a1 = dv.AddNew ();
 516                         eventWriter.Write (" ------" + dv.Count);
 517                         // I wonder why but MS fires another event here.
 518                         a1 = dv.AddNew ();
 519                         eventWriter.Write (" ------" + dv.Count);
 520                         // I wonder why but MS fires another event here.
 521                         DataRowView a2 = dv.AddNew ();
 522                         eventWriter.Write (" ------" + dv.Count);
 523                         a2.CancelEdit ();
 524                         eventWriter.Write (" ------" + dv.Count);
 525                         DataRowView a3 = dv.AddNew ();
 526
 527                         AssertEquals (reference, eventWriter.ToString ());
 528                 }
 529
 530                 private void ListChanged (object o, ListChangedEventArgs e)
 531                 {
 532                         eventWriter.Write (" =====" + e.ListChangedType + ":" + e.NewIndex);
 533                 }
 534
 535                 [Test]
 536                 [NUnit.Framework.Category ("NotWorking")]
 537                 public void ComplexEventSequence1 ()
 538                 {
 539                         string result = @"setting table...
 540 ---- OnListChanged PropertyDescriptorChanged,0,0
 541 ----- UpdateIndex : True
 542 ---- OnListChanged Reset,-1,-1
 543 table was set.
 544 ---- OnListChanged PropertyDescriptorAdded,0,0
 545  col1 added.
 546 ---- OnListChanged PropertyDescriptorAdded,0,0
 547  col2 added.
 548 ---- OnListChanged PropertyDescriptorAdded,0,0
 549  col3 added.
 550  uniq added.
 551 ----- UpdateIndex : True
 552 ---- OnListChanged Reset,-1,-1
 553  sort changed.
 554 ---- OnListChanged PropertyDescriptorDeleted,0,0
 555  col3 removed.
 556 ----- UpdateIndex : True
 557 ---- OnListChanged Reset,-1,-1
 558  rowfilter changed.
 559 ----- UpdateIndex : True
 560 ---- OnListChanged Reset,-1,-1
 561  rowstatefilter changed.
 562 ----- UpdateIndex : True
 563 ---- OnListChanged Reset,-1,-1
 564  rowstatefilter changed.
 565 ---- OnListChanged ItemAdded,0,-1
 566  added row to Rows.
 567 ---- OnListChanged ItemAdded,0,-1
 568  added row to Rows.
 569 ---- OnListChanged ItemAdded,0,-1
 570  added row to Rows.
 571 ---- OnListChanged ItemAdded,3,-1
 572  AddNew() invoked.
 573 4
 574 ---- OnListChanged ItemDeleted,3,-1
 575 ---- OnListChanged ItemMoved,-2147483648,3
 576  EndEdit() invoked.
 577 3
 578 ---- OnListChanged ItemMoved,0,-2147483648
 579  value changed to appear.
 580 4
 581 ---- OnListChanged ItemMoved,3,0
 582  value moved.
 583 4
 584 ---- OnListChanged ItemMoved,1,3
 585  value moved again.
 586 4
 587 ---- OnListChanged PropertyDescriptorChanged,0,0
 588 ----- UpdateIndex : True
 589 ---- OnListChanged Reset,-1,-1
 590 table changed.
 591 ";
 592
 593                         eventWriter = new StringWriter ();
 594
 595                         DataTable dt = new DataTable ("table");
 596                         ComplexEventSequence1View dv =
 597                                 new ComplexEventSequence1View (dt, eventWriter);
 598                         dt.Columns.Add ("col1");
 599                         eventWriter.WriteLine (" col1 added.");
 600                         dt.Columns.Add ("col2");
 601                         eventWriter.WriteLine (" col2 added.");
 602                         dt.Columns.Add ("col3");
 603                         eventWriter.WriteLine (" col3 added.");
 604                         dt.Constraints.Add (new UniqueConstraint (dt.Columns [0]));
 605                         eventWriter.WriteLine (" uniq added.");
 606                         dv.Sort = "col2";
 607                         eventWriter.WriteLine (" sort changed.");
 608                         dt.Columns.Remove ("col3");
 609                         eventWriter.WriteLine (" col3 removed.");
 610                         dv.RowFilter = "col1 <> 0";
 611                         eventWriter.WriteLine (" rowfilter changed.");
 612                         dv.RowStateFilter = DataViewRowState.Deleted;
 613                         eventWriter.WriteLine (" rowstatefilter changed.");
 614                         // FIXME: should be also tested.
 615 //                      dv.ApplyDefaultSort = true;
 616 //                      eventWriter.WriteLine (" apply default sort changed.");
 617                         dv.RowStateFilter = DataViewRowState.CurrentRows;
 618                         eventWriter.WriteLine (" rowstatefilter changed.");
 619                         dt.Rows.Add (new object [] {1, 3});
 620                         eventWriter.WriteLine (" added row to Rows.");
 621                         dt.Rows.Add (new object [] {2, 2});
 622                         eventWriter.WriteLine (" added row to Rows.");
 623                         dt.Rows.Add (new object [] {3, 1});
 624                         eventWriter.WriteLine (" added row to Rows.");
 625                         DataRowView drv = dv.AddNew ();
 626                         eventWriter.WriteLine (" AddNew() invoked.");
 627                         eventWriter.WriteLine (dv.Count);
 628                         drv [0] = 0;
 629                         drv.EndEdit ();
 630                         eventWriter.WriteLine (" EndEdit() invoked.");
 631                         eventWriter.WriteLine (dv.Count);
 632                         dt.Rows [dt.Rows.Count - 1] [0] = 4;
 633                         eventWriter.WriteLine (" value changed to appear.");
 634                         eventWriter.WriteLine (dv.Count);
 635                         dt.Rows [dt.Rows.Count - 1] [1] = 4;
 636                         eventWriter.WriteLine (" value moved.");
 637                         eventWriter.WriteLine (dv.Count);
 638                         dt.Rows [dt.Rows.Count - 1] [1] = 1.5;
 639                         eventWriter.WriteLine (" value moved again.");
 640                         eventWriter.WriteLine (dv.Count);
 641                         dv.Table = new DataTable ("table2");
 642                         eventWriter.WriteLine ("table changed.");
 643
 644                         AssertEquals (result, eventWriter.ToString ().Replace ("\r\n", "\n"));
 645                 }
 646
 647                 public class ComplexEventSequence1View : DataView
 648                 {
 649                         TextWriter w;
 650
 651                         public ComplexEventSequence1View (DataTable dt,
 652                                 TextWriter w) : base ()
 653                         {
 654                                 this.w = w;
 655                                 w.WriteLine ("setting table...");
 656                                 Table = dt;
 657                                 w.WriteLine ("table was set.");
 658                         }
 659
 660                         protected override void OnListChanged (ListChangedEventArgs e)
 661                         {
 662                                 if (w != null)
 663                                         w.WriteLine ("---- OnListChanged " + e.ListChangedType + "," + e.NewIndex + "," + e.OldIndex);
 664                                 base.OnListChanged (e);
 665                         }
 666
 667                         protected override void UpdateIndex (bool force)
 668                         {
 669                                 if (w != null)
 670                                         w.WriteLine ("----- UpdateIndex : " + force);
 671                                 base.UpdateIndex (force);
 672                         }
 673                 }
 674         }
 675 }