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

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