mcs/class/System/Test/System.ComponentModel/BindingListTest.cs

   1 #if NET_2_0
   2
   3 using System;
   4 using System.ComponentModel;
   5 using System.ComponentModel.Design.Serialization;
   6 using System.Collections.Generic;
   7
   8 using NUnit.Framework;
   9
  10 namespace MonoTests.System.ComponentModel
  11 {
  12         [TestFixture]
  13         public class BindingListTest
  14         {
  15                 [Test]
  16                 public void BindingListDefaults ()
  17                 {
  18                         BindingList<string> l = new BindingList<string> ();
  19                         IBindingList ibl = (IBindingList)l;
  20
  21                         Assert.IsTrue (l.AllowEdit, "1");
  22                         Assert.IsFalse (l.AllowNew, "2");
  23                         Assert.IsTrue (l.AllowRemove, "3");
  24                         Assert.IsTrue (l.RaiseListChangedEvents, "4");
  25
  26                         Assert.IsFalse (ibl.IsSorted, "5");
  27                         Assert.AreEqual (ibl.SortDirection, ListSortDirection.Ascending, "6");
  28                         Assert.IsTrue (ibl.SupportsChangeNotification, "7");
  29                         Assert.IsFalse (ibl.SupportsSearching, "8");
  30                         Assert.IsFalse (ibl.SupportsSorting, "9");
  31                         Assert.IsFalse (((IRaiseItemChangedEvents)l).RaisesItemChangedEvents, "10");
  32                 }
  33
  34                 [Test]
  35                 public void BindingListDefaults_FixedSizeList ()
  36                 {
  37                         string[] arr = new string[10];
  38                         BindingList<string> l = new BindingList<string> (arr);
  39                         IBindingList ibl = (IBindingList)l;
  40
  41                         Assert.IsTrue (l.AllowEdit, "1");
  42                         Assert.IsFalse (l.AllowNew, "2");
  43                         Assert.IsTrue (l.AllowRemove, "3");
  44                         Assert.IsTrue (l.RaiseListChangedEvents, "4");
  45
  46                         Assert.IsFalse (ibl.IsSorted, "5");
  47                         Assert.AreEqual (ibl.SortDirection, ListSortDirection.Ascending, "6");
  48                         Assert.IsTrue (ibl.SupportsChangeNotification, "7");
  49                         Assert.IsFalse (ibl.SupportsSearching, "8");
  50                         Assert.IsFalse (ibl.SupportsSorting, "9");
  51                         Assert.IsFalse (((IRaiseItemChangedEvents)l).RaisesItemChangedEvents, "10");
  52                 }
  53
  54                 [Test]
  55                 public void BindingListDefaults_NonFixedSizeList ()
  56                 {
  57                         List<string> list = new List<string> ();
  58                         BindingList<string> l = new BindingList<string> (list);
  59                         IBindingList ibl = (IBindingList)l;
  60
  61                         Assert.IsTrue (l.AllowEdit, "1");
  62                         Assert.IsFalse (l.AllowNew, "2");
  63                         Assert.IsTrue (l.AllowRemove, "3");
  64                         Assert.IsTrue (l.RaiseListChangedEvents, "4");
  65
  66                         Assert.IsFalse (ibl.IsSorted, "5");
  67                         Assert.AreEqual (ibl.SortDirection, ListSortDirection.Ascending, "6");
  68                         Assert.IsTrue (ibl.SupportsChangeNotification, "7");
  69                         Assert.IsFalse (ibl.SupportsSearching, "8");
  70                         Assert.IsFalse (ibl.SupportsSorting, "9");
  71                         Assert.IsFalse (((IRaiseItemChangedEvents)l).RaisesItemChangedEvents, "10");
  72                 }
  73
  74                 [Test]
  75                 public void BindingListDefaults_ReadOnlyList ()
  76                 {
  77                         List<string> list = new List<string> ();
  78                         BindingList<string> l = new BindingList<string> (list);
  79                         IBindingList ibl = (IBindingList)l;
  80
  81                         Assert.IsTrue (l.AllowEdit, "1");
  82                         Assert.IsFalse (l.AllowNew, "2");
  83                         Assert.IsTrue (l.AllowRemove, "3");
  84                         Assert.IsTrue (l.RaiseListChangedEvents, "4");
  85
  86                         Assert.IsFalse (ibl.IsSorted, "5");
  87                         Assert.AreEqual (ibl.SortDirection, ListSortDirection.Ascending, "6");
  88                         Assert.IsTrue (ibl.SupportsChangeNotification, "7");
  89                         Assert.IsFalse (ibl.SupportsSearching, "8");
  90                         Assert.IsFalse (ibl.SupportsSorting, "9");
  91                         Assert.IsFalse (((IRaiseItemChangedEvents)l).RaisesItemChangedEvents, "10");
  92                 }
  93
  94                 [Test]
  95                 public void TestAllowNew ()
  96                 {
  97                         /* Object has a default ctor */
  98                         BindingList<object> l1 = new BindingList<object> ();
  99                         Assert.IsTrue (l1.AllowNew, "1");
 100
 101                         /* string has no default ctor */
 102                         BindingList<string> l2 = new BindingList<string> ();
 103                         Assert.IsFalse (l2.AllowNew, "2");
 104
 105                         /* adding a delegate to AddingNew fixes that */
 106                         l2.AddingNew += delegate (object sender, AddingNewEventArgs e) { };
 107                         Assert.IsTrue (l2.AllowNew, "3");
 108
 109                         l1 = new BindingList<object> ();
 110
 111                         bool list_changed = false;
 112                         bool expected = false;
 113
 114                         l1.ListChanged += delegate (object sender, ListChangedEventArgs e) {
 115                                 list_changed = true;
 116                                 Assert.AreEqual (-1, e.NewIndex, "4");
 117                                 Assert.AreEqual (ListChangedType.Reset, e.ListChangedType, "5");
 118                                 Assert.AreEqual (expected, l1.AllowNew, "6");
 119                         };
 120
 121                         expected = false;
 122                         l1.AllowNew = false;
 123
 124                         Assert.IsTrue (list_changed, "7");
 125
 126                         /* the default for T=object is true, so check
 127                            if we enter the block for raising the event
 128                            if we explicitly set it to the value it
 129                            currently has. */
 130                         l1 = new BindingList<object> ();
 131
 132                         list_changed = false;
 133
 134                         l1.ListChanged += delegate (object sender, ListChangedEventArgs e) {
 135                                 list_changed = true;
 136                                 Assert.AreEqual (-1, e.NewIndex, "8");
 137                                 Assert.AreEqual (ListChangedType.Reset, e.ListChangedType, "9");
 138                                 Assert.AreEqual (expected, l1.AllowNew, "10");
 139                         };
 140
 141                         expected = true;
 142                         l1.AllowNew = true;
 143
 144                         /* turns out it doesn't raise the event, so the check must only be for "allow_new == value" */
 145                         Assert.IsFalse (list_changed, "11");
 146                 }
 147
 148                 [Test]
 149                 public void TestResetBindings ()
 150                 {
 151                         BindingList<object> l = new BindingList<object> ();
 152
 153                         bool list_changed = false;
 154
 155                         l.ListChanged += delegate (object sender, ListChangedEventArgs e) {
 156                                 list_changed = true;
 157                                 Assert.AreEqual (-1, e.NewIndex, "1");
 158                                 Assert.AreEqual (ListChangedType.Reset, e.ListChangedType, "2");
 159                         };
 160
 161                         l.ResetBindings ();
 162
 163                         Assert.IsTrue (list_changed, "3");
 164                 }
 165
 166                 [Test]
 167                 public void TestResetItem ()
 168                 {
 169                         List<object> list = new List<object>();
 170                         list.Add (new object());
 171
 172                         BindingList<object> l = new BindingList<object> (list);
 173
 174                         bool item_changed = false;
 175
 176                         l.ListChanged += delegate (object sender, ListChangedEventArgs e) {
 177                                 item_changed = true;
 178                                 Assert.AreEqual (0, e.NewIndex, "1");
 179                                 Assert.AreEqual (ListChangedType.ItemChanged, e.ListChangedType, "2");
 180                         };
 181
 182                         l.ResetItem (0);
 183
 184                         Assert.IsTrue (item_changed, "3");
 185                 }
 186
 187                 [Test]
 188                 public void TestRemoveItem ()
 189                 {
 190                         List<object> list = new List<object>();
 191                         list.Add (new object());
 192
 193                         BindingList<object> l = new BindingList<object> (list);
 194
 195                         bool item_deleted = false;
 196
 197                         l.ListChanged += delegate (object sender, ListChangedEventArgs e) {
 198                                 item_deleted = true;
 199                                 Assert.AreEqual (0, e.NewIndex, "1");
 200                                 Assert.AreEqual (ListChangedType.ItemDeleted, e.ListChangedType, "2");
 201                                 Assert.AreEqual (0, l.Count, "3"); // to show the event is raised after the removal
 202                         };
 203
 204                         l.RemoveAt (0);
 205
 206                         Assert.IsTrue (item_deleted, "4");
 207                 }
 208
 209                 [Test]
 210                 [ExpectedException (typeof (NotSupportedException))]
 211                 public void TestRemoveItem_AllowRemoveFalse ()
 212                 {
 213                         List<object> list = new List<object>();
 214                         list.Add (new object());
 215
 216                         BindingList<object> l = new BindingList<object> (list);
 217
 218                         l.AllowRemove = false;
 219
 220                         l.RemoveAt (0);
 221                 }
 222
 223                 [Test]
 224                 public void TestAllowEditEvent ()
 225                 {
 226                         BindingList<object> l = new BindingList<object>();
 227
 228                         bool event_raised = false;
 229                         bool expected = false;
 230
 231                         l.ListChanged += delegate (object sender, ListChangedEventArgs e) {
 232                                 event_raised = true;
 233                                 Assert.AreEqual (-1, e.NewIndex, "1");
 234                                 Assert.AreEqual (ListChangedType.Reset, e.ListChangedType, "2");
 235                                 Assert.AreEqual (expected, l.AllowEdit, "3");
 236                         };
 237
 238                         expected = false;
 239                         l.AllowEdit = false;
 240
 241                         Assert.IsTrue (event_raised, "4");
 242
 243                         // check to see if RaiseListChangedEvents affects AllowEdit's event.
 244                         l.RaiseListChangedEvents = false;
 245
 246                         event_raised = false;
 247                         expected = true;
 248                         l.AllowEdit = true;
 249
 250                         Assert.IsFalse (event_raised, "5");
 251                 }
 252
 253                 [Test]
 254                 public void TestAllowRemove ()
 255                 {
 256                         BindingList<object> l = new BindingList<object>();
 257
 258                         bool event_raised = false;
 259                         bool expected = false;
 260
 261                         l.ListChanged += delegate (object sender, ListChangedEventArgs e) {
 262                                 event_raised = true;
 263                                 Assert.AreEqual (-1, e.NewIndex, "1");
 264                                 Assert.AreEqual (ListChangedType.Reset, e.ListChangedType, "2");
 265                                 Assert.AreEqual (expected, l.AllowRemove, "3");
 266                         };
 267
 268                         expected = false;
 269                         l.AllowRemove = false;
 270
 271                         Assert.IsTrue (event_raised, "4");
 272
 273                         // check to see if RaiseListChangedEvents affects AllowRemove's event.
 274                         l.RaiseListChangedEvents = false;
 275
 276                         event_raised = false;
 277                         expected = true;
 278                         l.AllowRemove = true;
 279
 280                         Assert.IsFalse (event_raised, "5");
 281                 }
 282
 283                 [Test]
 284                 public void TestAddNew_SettingArgsNewObject ()
 285                 {
 286                         BindingList<object> l = new BindingList<object>();
 287
 288                         bool adding_event_raised = false;
 289                         object o = new object ();
 290
 291                         l.AddingNew += delegate (object sender, AddingNewEventArgs e) {
 292                                 adding_event_raised = true;
 293                                 Assert.IsNull (e.NewObject, "1");
 294                                 e.NewObject = o;
 295                         };
 296
 297                         object rv = l.AddNew ();
 298                         Assert.IsTrue (adding_event_raised, "2");
 299                         Assert.AreSame (o, rv, "3");
 300                 }
 301
 302                 [Test]
 303                 public void TestAddNew ()
 304                 {
 305                         BindingList<object> l = new BindingList<object>();
 306
 307                         bool adding_event_raised = false;
 308                         object o = new object ();
 309
 310                         l.AddingNew += delegate (object sender, AddingNewEventArgs e) {
 311                                 adding_event_raised = true;
 312                                 Assert.IsNull (e.NewObject, "1");
 313                         };
 314
 315                         object rv = l.AddNew ();
 316                         Assert.IsTrue (adding_event_raised, "2");
 317                         Assert.IsNotNull (rv, "3");
 318                 }
 319
 320                 [Test]
 321                 public void TestAddNew_Cancel ()
 322                 {
 323                         BindingList<object> l = new BindingList<object>();
 324
 325                         bool adding_event_raised = false;
 326                         object o = new object ();
 327
 328                         bool list_changed = false;
 329                         ListChangedType change_type = ListChangedType.Reset;
 330                         int list_changed_index = -1;
 331
 332                         l.AddingNew += delegate (object sender, AddingNewEventArgs e) {
 333                                 adding_event_raised = true;
 334                                 Assert.IsNull (e.NewObject, "1");
 335                         };
 336
 337                         l.ListChanged += delegate (object sender, ListChangedEventArgs e) {
 338                                 list_changed = true;
 339                                 change_type = e.ListChangedType;
 340                                 list_changed_index = e.NewIndex;
 341                         };
 342
 343                         object rv = l.AddNew ();
 344                         Assert.IsTrue (adding_event_raised, "2");
 345                         Assert.IsNotNull (rv, "3");
 346
 347                         Assert.AreEqual (1, l.Count, "4");
 348                         Assert.AreEqual (0, l.IndexOf (rv), "5");
 349                         Assert.IsTrue (list_changed, "6");
 350                         Assert.AreEqual (ListChangedType.ItemAdded, change_type, "7");
 351                         Assert.AreEqual (0, list_changed_index, "8");
 352
 353                         list_changed = false;
 354
 355                         l.CancelNew (0);
 356
 357                         Assert.AreEqual (0, l.Count, "9");
 358                         Assert.IsTrue (list_changed, "10");
 359                         Assert.AreEqual (ListChangedType.ItemDeleted, change_type, "11");
 360                         Assert.AreEqual (0, list_changed_index, "12");
 361                 }
 362
 363                 [Test]
 364                 public void TestAddNew_CancelDifferentIndex ()
 365                 {
 366                         List<object> list = new List<object>();
 367
 368                         list.Add (new object ());
 369                         list.Add (new object ());
 370
 371                         BindingList<object> l = new BindingList<object>(list);
 372
 373                         bool adding_event_raised = false;
 374                         object o = new object ();
 375
 376                         bool list_changed = false;
 377                         ListChangedType change_type = ListChangedType.Reset;
 378                         int list_changed_index = -1;
 379
 380                         l.AddingNew += delegate (object sender, AddingNewEventArgs e) {
 381                                 adding_event_raised = true;
 382                                 Assert.IsNull (e.NewObject, "1");
 383                         };
 384
 385                         l.ListChanged += delegate (object sender, ListChangedEventArgs e) {
 386                                 list_changed = true;
 387                                 change_type = e.ListChangedType;
 388                                 list_changed_index = e.NewIndex;
 389                         };
 390
 391                         object rv = l.AddNew ();
 392                         Assert.IsTrue (adding_event_raised, "2");
 393                         Assert.IsNotNull (rv, "3");
 394
 395                         Assert.AreEqual (3, l.Count, "4");
 396                         Assert.AreEqual (2, l.IndexOf (rv), "5");
 397                         Assert.IsTrue (list_changed, "6");
 398                         Assert.AreEqual (ListChangedType.ItemAdded, change_type, "7");
 399                         Assert.AreEqual (2, list_changed_index, "8");
 400
 401                         list_changed = false;
 402
 403                         l.CancelNew (0);
 404
 405                         Assert.IsFalse (list_changed, "9");
 406                         Assert.AreEqual (3, l.Count, "10");
 407
 408                         l.CancelNew (2);
 409
 410                         Assert.IsTrue (list_changed, "11");
 411                         Assert.AreEqual (ListChangedType.ItemDeleted, change_type, "12");
 412                         Assert.AreEqual (2, list_changed_index, "13");
 413                         Assert.AreEqual (2, l.Count, "14");
 414                 }
 415
 416                 [Test]
 417                 public void TestAddNew_End ()
 418                 {
 419                         BindingList<object> l = new BindingList<object>();
 420
 421                         bool adding_event_raised = false;
 422                         object o = new object ();
 423
 424                         bool list_changed = false;
 425                         ListChangedType change_type = ListChangedType.Reset;
 426                         int list_changed_index = -1;
 427
 428                         l.AddingNew += delegate (object sender, AddingNewEventArgs e) {
 429                                 adding_event_raised = true;
 430                                 Assert.IsNull (e.NewObject, "1");
 431                         };
 432
 433                         l.ListChanged += delegate (object sender, ListChangedEventArgs e) {
 434                                 list_changed = true;
 435                                 change_type = e.ListChangedType;
 436                                 list_changed_index = e.NewIndex;
 437                         };
 438
 439                         object rv = l.AddNew ();
 440                         Assert.IsTrue (adding_event_raised, "2");
 441                         Assert.IsNotNull (rv, "3");
 442
 443                         Assert.AreEqual (1, l.Count, "4");
 444                         Assert.AreEqual (0, l.IndexOf (rv), "5");
 445                         Assert.IsTrue (list_changed, "6");
 446                         Assert.AreEqual (ListChangedType.ItemAdded, change_type, "7");
 447                         Assert.AreEqual (0, list_changed_index, "8");
 448
 449                         list_changed = false;
 450
 451                         l.EndNew (0);
 452
 453                         Assert.AreEqual (1, l.Count, "9");
 454                         Assert.IsFalse (list_changed, "10");
 455                 }
 456
 457                 [Test]
 458                 public void TestAddNew_CancelDifferentIndexThenEnd ()
 459                 {
 460                         BindingList<object> l = new BindingList<object>();
 461
 462                         bool adding_event_raised = false;
 463                         object o = new object ();
 464
 465                         bool list_changed = false;
 466                         ListChangedType change_type = ListChangedType.Reset;
 467                         int list_changed_index = -1;
 468
 469                         l.AddingNew += delegate (object sender, AddingNewEventArgs e) {
 470                                 adding_event_raised = true;
 471                                 Assert.IsNull (e.NewObject, "1");
 472                         };
 473
 474                         l.ListChanged += delegate (object sender, ListChangedEventArgs e) {
 475                                 list_changed = true;
 476                                 change_type = e.ListChangedType;
 477                                 list_changed_index = e.NewIndex;
 478                         };
 479
 480                         object rv = l.AddNew ();
 481                         Assert.IsTrue (adding_event_raised, "2");
 482                         Assert.IsNotNull (rv, "3");
 483
 484                         Assert.AreEqual (1, l.Count, "4");
 485                         Assert.AreEqual (0, l.IndexOf (rv), "5");
 486                         Assert.IsTrue (list_changed, "6");
 487                         Assert.AreEqual (ListChangedType.ItemAdded, change_type, "7");
 488                         Assert.AreEqual (0, list_changed_index, "8");
 489
 490                         list_changed = false;
 491
 492                         l.CancelNew (2);
 493
 494                         Assert.AreEqual (1, l.Count, "9");
 495                         Assert.IsFalse (list_changed, "10");
 496
 497                         l.EndNew (0);
 498
 499                         Assert.AreEqual (1, l.Count, "11");
 500                         Assert.IsFalse (list_changed, "12");
 501                 }
 502
 503                 [Test]
 504                 public void TestAddNew_EndDifferentIndexThenCancel ()
 505                 {
 506                         BindingList<object> l = new BindingList<object>();
 507
 508                         bool adding_event_raised = false;
 509                         object o = new object ();
 510
 511                         bool list_changed = false;
 512                         ListChangedType change_type = ListChangedType.Reset;
 513                         int list_changed_index = -1;
 514
 515                         l.AddingNew += delegate (object sender, AddingNewEventArgs e) {
 516                                 adding_event_raised = true;
 517                                 Assert.IsNull (e.NewObject, "1");
 518                         };
 519
 520                         l.ListChanged += delegate (object sender, ListChangedEventArgs e) {
 521                                 list_changed = true;
 522                                 change_type = e.ListChangedType;
 523                                 list_changed_index = e.NewIndex;
 524                         };
 525
 526                         object rv = l.AddNew ();
 527                         Assert.IsTrue (adding_event_raised, "2");
 528                         Assert.IsNotNull (rv, "3");
 529
 530                         Assert.AreEqual (1, l.Count, "4");
 531                         Assert.AreEqual (0, l.IndexOf (rv), "5");
 532                         Assert.IsTrue (list_changed, "6");
 533                         Assert.AreEqual (ListChangedType.ItemAdded, change_type, "7");
 534                         Assert.AreEqual (0, list_changed_index, "8");
 535
 536                         list_changed = false;
 537
 538                         l.EndNew (2);
 539
 540                         Assert.AreEqual (1, l.Count, "9");
 541                         Assert.IsFalse (list_changed, "10");
 542
 543                         l.CancelNew (0);
 544
 545                         Assert.IsTrue (list_changed, "11");
 546                         Assert.AreEqual (ListChangedType.ItemDeleted, change_type, "12");
 547                         Assert.AreEqual (0, list_changed_index, "13");
 548                 }
 549
 550                 class BindingListPoker : BindingList<object>
 551                 {
 552                         public object DoAddNewCore()
 553                         {
 554                                 return base.AddNewCore ();
 555                         }
 556                 }
 557
 558                 // test to make sure that the events are raised in AddNewCore and not in AddNew
 559                 [Test]
 560                 public void TestAddNewCore_Insert ()
 561                 {
 562                         BindingListPoker poker = new BindingListPoker ();
 563
 564                         bool adding_event_raised = false;
 565
 566                         bool list_changed = false;
 567                         ListChangedType change_type = ListChangedType.Reset;
 568                         int list_changed_index = -1;
 569
 570                         poker.AddingNew += delegate (object sender, AddingNewEventArgs e) {
 571                                 adding_event_raised = true;
 572                         };
 573
 574                         poker.ListChanged += delegate (object sender, ListChangedEventArgs e) {
 575                                 list_changed = true;
 576                                 change_type = e.ListChangedType;
 577                                 list_changed_index = e.NewIndex;
 578                         };
 579
 580                         object o = poker.DoAddNewCore ();
 581
 582                         Assert.IsTrue (adding_event_raised, "1");
 583                         Assert.IsTrue (list_changed, "2");
 584                         Assert.AreEqual (ListChangedType.ItemAdded, change_type, "3");
 585                         Assert.AreEqual (0, list_changed_index, "4");
 586                         Assert.AreEqual (1, poker.Count, "5");
 587                 }
 588         }
 589 }
 590
 591 #endif