mcs/class/Managed.Windows.Forms/Test/System.Windows.Forms/ListViewTest.cs

   1 //
   2 // ListViewTest.cs: Test cases for ListView.
   3 //
   4 // Author:
   5 //   Ritvik Mayank (mritvik@novell.com)
   6 //
   7 // (C) 2005 Novell, Inc. (http://www.novell.com)
   8 //
   9
  10 using System;
  11 using System.Collections;
  12 using System.Drawing;
  13 using System.Reflection;
  14 using System.Windows.Forms;
  15
  16 using NUnit.Framework;
  17
  18 namespace MonoTests.System.Windows.Forms
  19 {
  20         [TestFixture]
  21         public class ListViewTest
  22         {
  23                 [Test]
  24                 public void ListViewPropertyTest ()
  25                 {
  26                         ListView mylistview = new ListView ();
  27                         Assert.AreEqual (ItemActivation.Standard, mylistview.Activation, "#1");
  28                         Assert.AreEqual (ListViewAlignment.Top, mylistview.Alignment, "#2");
  29                         Assert.AreEqual (false, mylistview.AllowColumnReorder, "#3");
  30                         Assert.AreEqual (true, mylistview.AutoArrange, "#4");
  31                         Assert.AreEqual (BorderStyle.Fixed3D , mylistview.BorderStyle, "#5");
  32                         Assert.AreEqual (false, mylistview.CheckBoxes, "#6");
  33                         Assert.AreEqual (0, mylistview.CheckedIndices.Count, "#7");
  34                         Assert.AreEqual (0, mylistview.CheckedItems.Count, "#8");
  35                         Assert.AreEqual (0, mylistview.Columns.Count, "#9");
  36                         Assert.AreEqual (null, mylistview.FocusedItem, "#10");
  37                         Assert.AreEqual (false, mylistview.FullRowSelect, "#11");
  38                         Assert.AreEqual (false, mylistview.GridLines, "#12");
  39                         Assert.AreEqual (ColumnHeaderStyle.Clickable, mylistview.HeaderStyle, "#13");
  40                         Assert.AreEqual (true, mylistview.HideSelection, "#14");
  41                         Assert.AreEqual (false, mylistview.HoverSelection, "#15");
  42                         ListViewItem item1 = new ListViewItem ("A", -1);
  43                         mylistview.Items.Add (item1);
  44                         Assert.AreEqual (1, mylistview.Items.Count, "#16");
  45                         Assert.AreEqual (false, mylistview.LabelEdit, "#17");
  46                         Assert.AreEqual (true, mylistview.LabelWrap, "#18");
  47                         Assert.AreEqual (null, mylistview.LargeImageList, "#19");
  48                         Assert.AreEqual (null, mylistview.ListViewItemSorter, "#20");
  49                         Assert.AreEqual (true, mylistview.MultiSelect, "#21");
  50                         Assert.AreEqual (true, mylistview.Scrollable, "#22");
  51                         Assert.AreEqual (0, mylistview.SelectedIndices.Count, "#23");
  52                         Assert.AreEqual (0, mylistview.SelectedItems.Count, "#24");
  53                         Assert.AreEqual (null, mylistview.SmallImageList, "#25");
  54                         Assert.AreEqual (null, mylistview.LargeImageList, "#26");
  55                         Assert.AreEqual (SortOrder.None, mylistview.Sorting, "#27");
  56                         Assert.AreEqual (null, mylistview.StateImageList, "#28");
  57                         Assert.AreEqual (View.LargeIcon, mylistview.View, "#29");
  58                         mylistview.View = View.List;
  59                         Assert.AreEqual (false, mylistview.TopItem.Checked, "#30");
  60                 }
  61
  62                 [Test]
  63                 public void ArrangeIconsTest ()
  64                 {
  65                         Form myform = new Form ();
  66                         myform.ShowInTaskbar = false;
  67                         ListView mylistview = new ListView ();
  68                         myform.Controls.Add (mylistview);
  69                         mylistview.Items.Add ("Item 1");
  70                         mylistview.Items.Add ("Item 2");
  71                         mylistview.View = View.LargeIcon;
  72                         mylistview.ArrangeIcons ();
  73                         myform.Dispose ();
  74                 }
  75
  76                 [Test]
  77                 public void BeginEndUpdateTest ()
  78                 {
  79                         Form myform = new Form ();
  80                         myform.ShowInTaskbar = false;
  81                         myform.Visible = true;
  82                         ListView mylistview = new ListView();
  83                         mylistview.Items.Add ("A");
  84                         mylistview.Visible = true;
  85                         myform.Controls.Add (mylistview);
  86                         mylistview.BeginUpdate ();
  87                         for(int x = 1 ; x < 5000 ; x++){
  88                                 mylistview.Items.Add ("Item " + x.ToString());
  89                         }
  90                         mylistview.EndUpdate ();
  91                         myform.Dispose ();
  92                 }
  93
  94                 [Test]
  95                 public void CheckBoxes ()
  96                 {
  97                         Form form = new Form ();
  98                         form.ShowInTaskbar = false;
  99                         ListView lvw = new ListView ();
 100                         form.Controls.Add (lvw);
 101                         lvw.Items.Add ("A");
 102                         ListViewItem itemB = lvw.Items.Add ("B");
 103                         lvw.Items.Add ("C");
 104                         itemB.Checked = true;
 105
 106                         Assert.AreEqual (0, lvw.CheckedItems.Count, "#A1");
 107                         Assert.AreEqual (0, lvw.CheckedIndices.Count, "#A2");
 108
 109                         lvw.CheckBoxes = true;
 110
 111                         Assert.AreEqual (1, lvw.CheckedItems.Count, "#B1");
 112                         Assert.AreSame (itemB, lvw.CheckedItems [0], "#B2");
 113                         Assert.AreEqual (1, lvw.CheckedIndices.Count, "#B3");
 114                         Assert.AreEqual (1, lvw.CheckedIndices [0], "#B4");
 115
 116                         form.Show ();
 117
 118                         Assert.AreEqual (1, lvw.CheckedItems.Count, "#C1");
 119                         Assert.AreSame (itemB, lvw.CheckedItems [0], "#C2");
 120                         Assert.AreEqual (1, lvw.CheckedIndices.Count, "#C3");
 121                         Assert.AreEqual (1, lvw.CheckedIndices [0], "#C4");
 122
 123                         lvw.CheckBoxes = false;
 124
 125                         Assert.AreEqual (0, lvw.CheckedItems.Count, "#D1");
 126                         Assert.AreEqual (0, lvw.CheckedIndices.Count, "#D2");
 127
 128                         lvw.CheckBoxes = true;
 129
 130                         Assert.AreEqual (1, lvw.CheckedItems.Count, "#E1");
 131                         Assert.AreSame (itemB, lvw.CheckedItems [0], "#E2");
 132                         Assert.AreEqual (1, lvw.CheckedIndices.Count, "#E3");
 133                         Assert.AreEqual (1, lvw.CheckedIndices [0], "#E4");
 134                         form.Dispose ();
 135                 }
 136
 137                 [Test]
 138                 public void ClearTest ()
 139                 {
 140                         Form myform = new Form ();
 141                         myform.ShowInTaskbar = false;
 142                         myform.Visible = true;
 143                         ListView mylistview = new ListView ();
 144                         mylistview.Items.Add ("A");
 145                         mylistview.Columns.Add ("Item Column", -2, HorizontalAlignment.Left);
 146                         mylistview.Visible = true;
 147                         myform.Controls.Add (mylistview);
 148                         Assert.AreEqual (1, mylistview.Columns.Count, "#31");
 149                         Assert.AreEqual (1, mylistview.Items.Count, "#32");
 150                         mylistview.Clear ();
 151                         Assert.AreEqual (0, mylistview.Columns.Count, "#33");
 152                         Assert.AreEqual (0, mylistview.Items.Count, "#34");
 153                         myform.Dispose ();
 154                 }
 155
 156                 [Test]
 157                 public void EnsureVisibleTest ()
 158                 {
 159                         Form myform = new Form ();
 160                         myform.ShowInTaskbar = false;
 161                         myform.Visible = true;
 162                         ListView mylistview = new ListView ();
 163                         mylistview.Items.Add ("A");
 164                         myform.Controls.Add (mylistview);
 165                         mylistview.BeginUpdate ();
 166                         for(int x = 1 ; x < 5000 ; x++) {
 167                                 mylistview.Items.Add ("Item " + x.ToString());
 168                         }
 169                         mylistview.EndUpdate ();
 170                         mylistview.EnsureVisible (4999);
 171                         myform.Dispose ();
 172                 }
 173
 174                 [Test]
 175                 public void GetItemRectTest ()
 176                 {
 177                         ListView mylistview = new ListView ();
 178                         mylistview.Items.Add ("Item 1");
 179                         mylistview.Items.Add ("Item 2");
 180                         Rectangle r = mylistview.GetItemRect (1);
 181                         Assert.AreEqual (0, r.Top, "#35a");
 182                         Assert.IsTrue (r.Bottom > 0, "#35b");
 183                         Assert.IsTrue (r.Right > 0, "#35c");
 184                         Assert.IsTrue (r.Left > 0, "#35d");
 185                         Assert.IsTrue (r.Height > 0, "#35e");
 186                         Assert.IsTrue (r.Width > 0, "#35f");
 187                 }
 188
 189                 [Test]
 190                 public void bug79076 ()
 191                 {
 192                         ListView entryList = new ListView ();
 193                         entryList.Sorting = SortOrder.Descending;
 194
 195                         entryList.BeginUpdate ();
 196                         entryList.Columns.Add ("Type", 100, HorizontalAlignment.Left);
 197
 198                         ListViewItem item = new ListViewItem (new string [] { "A" });
 199                         entryList.Items.Add (item);
 200                         item = new ListViewItem (new string [] { "B" });
 201                         entryList.Items.Add (item);
 202                 }
 203
 204                 [Test] // bug #79416
 205                 public void MultiSelect ()
 206                 {
 207                         Form form = new Form ();
 208                         form.ShowInTaskbar = false;
 209                         ListView lvw = CreateListView (View.Details);
 210                         form.Controls.Add (lvw);
 211                         lvw.MultiSelect = true;
 212                         lvw.Items [0].Selected = true;
 213                         lvw.Items [2].Selected = true;
 214
 215                         Assert.AreEqual (0, lvw.SelectedItems.Count, "#A1");
 216                         Assert.AreEqual (0, lvw.SelectedIndices.Count, "#A2");
 217
 218                         lvw.Items [0].Selected = false;
 219
 220                         Assert.AreEqual (0, lvw.SelectedItems.Count, "#B1");
 221                         Assert.AreEqual (0, lvw.SelectedIndices.Count, "#B2");
 222
 223                         lvw.Items [0].Selected = true;
 224
 225                         Assert.AreEqual (0, lvw.SelectedItems.Count, "#C1");
 226                         Assert.AreEqual (0, lvw.SelectedIndices.Count, "#C2");
 227
 228                         form.Show ();
 229
 230                         Assert.AreEqual (2, lvw.SelectedItems.Count, "#D1");
 231                         Assert.AreEqual ("B", lvw.SelectedItems [0].Text, "#D2");
 232                         Assert.AreEqual ("C", lvw.SelectedItems [1].Text, "#D3");
 233                         Assert.AreEqual (2, lvw.SelectedIndices.Count, "#D4");
 234                         Assert.AreEqual (0, lvw.SelectedIndices [0], "#D5");
 235                         Assert.AreEqual (2, lvw.SelectedIndices [1], "#D6");
 236
 237                         // de-select an item
 238                         lvw.Items [2].Selected = false;
 239
 240                         Assert.AreEqual (1, lvw.SelectedItems.Count, "#E1");
 241                         Assert.AreEqual ("B", lvw.SelectedItems [0].Text, "#E2");
 242                         Assert.AreEqual (1, lvw.SelectedIndices.Count, "#E3");
 243                         Assert.AreEqual (0, lvw.SelectedIndices [0], "#E4");
 244
 245                         // re-select that item
 246                         lvw.Items [2].Selected = true;
 247
 248                         Assert.AreEqual (2, lvw.SelectedItems.Count, "#F1");
 249                         Assert.AreEqual ("B", lvw.SelectedItems [0].Text, "#F2");
 250                         Assert.AreEqual ("C", lvw.SelectedItems [1].Text, "#F3");
 251                         Assert.AreEqual (2, lvw.SelectedIndices.Count, "#F4");
 252                         Assert.AreEqual (0, lvw.SelectedIndices [0], "#F5");
 253                         Assert.AreEqual (2, lvw.SelectedIndices [1], "#F6");
 254
 255                         // dis-allow selection of multiple items
 256                         lvw.MultiSelect = false;
 257
 258                         // setting MultiSelect to false when multiple items have been
 259                         // selected does not deselect items
 260                         Assert.AreEqual (2, lvw.SelectedItems.Count, "#G1");
 261                         Assert.AreEqual ("B", lvw.SelectedItems [0].Text, "#G2");
 262                         Assert.AreEqual ("C", lvw.SelectedItems [1].Text, "#G3");
 263                         Assert.AreEqual (2, lvw.SelectedIndices.Count, "#G4");
 264                         Assert.AreEqual (0, lvw.SelectedIndices [0], "#G5");
 265                         Assert.AreEqual (2, lvw.SelectedIndices [1], "#G6");
 266
 267                         // de-select that item again
 268                         lvw.Items [2].Selected = false;
 269
 270                         Assert.AreEqual (1, lvw.SelectedItems.Count, "#H1");
 271                         Assert.AreEqual ("B", lvw.SelectedItems [0].Text, "#H2");
 272                         Assert.AreEqual (1, lvw.SelectedIndices.Count, "#H3");
 273                         Assert.AreEqual (0, lvw.SelectedIndices [0], "#H4");
 274
 275                         // re-select that item again
 276                         lvw.Items [2].Selected = true;
 277
 278                         // when MultiSelect is false, and you attempt to select more than
 279                         // one item, then all items will first be de-selected and then
 280                         // the item in question is selected
 281                         Assert.AreEqual (1, lvw.SelectedItems.Count, "#I1");
 282                         Assert.AreEqual ("C", lvw.SelectedItems [0].Text, "#I2");
 283                         Assert.AreEqual (1, lvw.SelectedIndices.Count, "#I3");
 284                         Assert.AreEqual (2, lvw.SelectedIndices [0], "#I4");
 285                         form.Dispose ();
 286                 }
 287
 288                 [Test]
 289                 public void Selected ()
 290                 {
 291                         Form form = new Form ();
 292                         form.ShowInTaskbar = false;
 293                         ListView lvw = CreateListView (View.Details);
 294                         form.Controls.Add (lvw);
 295                         lvw.MultiSelect = true;
 296                         lvw.Items [0].Selected = true;
 297                         lvw.Items [2].Selected = true;
 298
 299                         Assert.AreEqual (0, lvw.SelectedItems.Count, "#A1");
 300                         Assert.AreEqual (0, lvw.SelectedIndices.Count, "#A2");
 301
 302                         form.Show ();
 303
 304                         Assert.AreEqual (2, lvw.SelectedItems.Count, "#C1");
 305                         Assert.AreEqual ("B", lvw.SelectedItems [0].Text, "#C2");
 306                         Assert.AreEqual ("C", lvw.SelectedItems [1].Text, "#C3");
 307                         Assert.AreEqual (2, lvw.SelectedIndices.Count, "#C4");
 308                         Assert.AreEqual (0, lvw.SelectedIndices [0], "#C5");
 309                         Assert.AreEqual (2, lvw.SelectedIndices [1], "#C6");
 310                         form.Dispose ();
 311                 }
 312
 313                 [Test]
 314                 public void Sort_Details_Checked ()
 315                 {
 316                         AssertSort_Checked (View.Details);
 317                 }
 318
 319                 [Test]
 320                 public void Sort_Details_Created ()
 321                 {
 322                         AssertSortNoIcon_Created (View.Details);
 323                 }
 324
 325                 [Test]
 326                 public void Sort_Details_NotCreated ()
 327                 {
 328                         AssertSortNoIcon_NotCreated (View.Details);
 329                 }
 330
 331                 [Test]
 332                 public void Sort_Details_Selected ()
 333                 {
 334                         AssertSort_Selected (View.Details);
 335                 }
 336
 337                 [Test]
 338                 public void Sort_LargeIcon_Checked ()
 339                 {
 340                         AssertSort_Checked (View.LargeIcon);
 341                 }
 342
 343                 [Test]
 344                 public void Sort_LargeIcon_Created ()
 345                 {
 346                         AssertSortIcon_Created (View.LargeIcon);
 347                 }
 348
 349                 [Test]
 350                 public void Sort_LargeIcon_NotCreated ()
 351                 {
 352                         AssertSortIcon_NotCreated (View.LargeIcon);
 353                 }
 354
 355                 [Test]
 356                 public void Sort_LargeIcon_Selected ()
 357                 {
 358                         AssertSort_Selected (View.LargeIcon);
 359                 }
 360
 361                 [Test]
 362                 public void Sort_List_Checked ()
 363                 {
 364                         AssertSort_Checked (View.List);
 365                 }
 366
 367                 [Test]
 368                 public void Sort_List_Created ()
 369                 {
 370                         AssertSortNoIcon_Created (View.List);
 371                 }
 372
 373                 [Test]
 374                 public void Sort_List_NotCreated ()
 375                 {
 376                         AssertSortNoIcon_NotCreated (View.List);
 377                 }
 378
 379                 [Test]
 380                 public void Sort_List_Selection ()
 381                 {
 382                         AssertSort_Selected (View.List);
 383                 }
 384
 385                 [Test]
 386                 public void Sort_SmallIcon_Checked ()
 387                 {
 388                         AssertSort_Checked (View.SmallIcon);
 389                 }
 390
 391                 [Test]
 392                 public void Sort_SmallIcon_Created ()
 393                 {
 394                         AssertSortIcon_Created (View.SmallIcon);
 395                 }
 396
 397                 [Test]
 398                 public void Sort_SmallIcon_NotCreated ()
 399                 {
 400                         AssertSortIcon_NotCreated (View.SmallIcon);
 401                 }
 402
 403                 [Test]
 404                 public void Sort_SmallIcon_Selection ()
 405                 {
 406                         AssertSort_Selected (View.SmallIcon);
 407                 }
 408
 409 #if NET_2_0
 410                 [Test]
 411                 [ExpectedException (typeof (NotSupportedException))]
 412                 public void Sort_Tile_Checked ()
 413                 {
 414                         AssertSort_Checked (View.Tile);
 415                 }
 416
 417                 [Test]
 418                 public void Sort_Tile_Created ()
 419                 {
 420                         AssertSortNoIcon_Created (View.Tile);
 421                 }
 422
 423                 [Test]
 424                 public void Sort_Tile_NotCreated ()
 425                 {
 426                         AssertSortNoIcon_NotCreated (View.Tile);
 427                 }
 428
 429                 [Test]
 430                 public void Sort_Tile_Selection ()
 431                 {
 432                         AssertSort_Selected (View.Tile);
 433                 }
 434 #endif
 435
 436                 private void AssertSortIcon_Created (View view)
 437                 {
 438                         int compareCount = 0;
 439
 440                         Form form = new Form ();
 441                         form.ShowInTaskbar = false;
 442                         ListView lvw = CreateListView (view);
 443                         form.Controls.Add (lvw);
 444                         Assert.IsNull (lvw.ListViewItemSorter, "#A");
 445
 446                         form.Show ();
 447
 448                         Assert.IsNull (lvw.ListViewItemSorter, "#B1");
 449                         Assert.AreEqual ("B", lvw.Items [0].Text, "#B2");
 450                         Assert.AreEqual ("A", lvw.Items [1].Text, "#B3");
 451                         Assert.AreEqual ("C", lvw.Items [2].Text, "#B4");
 452
 453                         lvw.Sorting = SortOrder.None;
 454                         Assert.IsNull (lvw.ListViewItemSorter, "#C1");
 455                         Assert.AreEqual ("B", lvw.Items [0].Text, "#C2");
 456                         Assert.AreEqual ("A", lvw.Items [1].Text, "#C3");
 457                         Assert.AreEqual ("C", lvw.Items [2].Text, "#C4");
 458
 459                         lvw.Sorting = SortOrder.Descending;
 460                         Assert.IsNotNull (lvw.ListViewItemSorter, "#D1");
 461                         Assert.AreEqual ("C", lvw.Items [0].Text, "#D2");
 462                         Assert.AreEqual ("B", lvw.Items [1].Text, "#D3");
 463                         Assert.AreEqual ("A", lvw.Items [2].Text, "#D4");
 464
 465                         lvw.Sorting = SortOrder.Ascending;
 466                         Assert.IsNotNull (lvw.ListViewItemSorter, "#E1");
 467 #if NET_2_0
 468                         Assert.AreEqual ("A", lvw.Items [0].Text, "#E2");
 469                         Assert.AreEqual ("B", lvw.Items [1].Text, "#E3");
 470                         Assert.AreEqual ("C", lvw.Items [2].Text, "#E4");
 471 #else
 472                         // in .NET 1.1, changing Sorting does not have any effect for
 473                         // SmallIcon and LargeIcon view if no custom comparer is used
 474                         Assert.AreEqual ("C", lvw.Items [0].Text, "#E2");
 475                         Assert.AreEqual ("B", lvw.Items [1].Text, "#E3");
 476                         Assert.AreEqual ("A", lvw.Items [2].Text, "#E4");
 477 #endif
 478
 479                         lvw.Sorting = SortOrder.None;
 480                         Assert.IsNotNull (lvw.ListViewItemSorter, "#F1");
 481 #if NET_2_0
 482                         Assert.AreEqual ("A", lvw.Items [0].Text, "#F2");
 483                         Assert.AreEqual ("B", lvw.Items [1].Text, "#F3");
 484                         Assert.AreEqual ("C", lvw.Items [2].Text, "#F4");
 485 #else
 486                         // in .NET 1.1, changing Sorting does not have any effect for
 487                         // SmallIcon and LargeIcon view if no custom comparer is used
 488                         Assert.AreEqual ("C", lvw.Items [0].Text, "#E2");
 489                         Assert.AreEqual ("B", lvw.Items [1].Text, "#E3");
 490                         Assert.AreEqual ("A", lvw.Items [2].Text, "#E4");
 491 #endif
 492
 493                         lvw.Sorting = SortOrder.Ascending;
 494                         Assert.IsNotNull (lvw.ListViewItemSorter, "#G1");
 495 #if NET_2_0
 496                         Assert.AreEqual ("A", lvw.Items [0].Text, "#G2");
 497                         Assert.AreEqual ("B", lvw.Items [1].Text, "#G3");
 498                         Assert.AreEqual ("C", lvw.Items [2].Text, "#G4");
 499 #else
 500                         // in .NET 1.1, changing Sorting does not have any effect for
 501                         // SmallIcon and LargeIcon view if no custom comparer is used
 502                         Assert.AreEqual ("C", lvw.Items [0].Text, "#G2");
 503                         Assert.AreEqual ("B", lvw.Items [1].Text, "#G3");
 504                         Assert.AreEqual ("A", lvw.Items [2].Text, "#G4");
 505 #endif
 506
 507                         lvw.Sorting = SortOrder.Descending;
 508                         Assert.IsNotNull (lvw.ListViewItemSorter, "#G1");
 509                         Assert.AreEqual ("C", lvw.Items [0].Text, "#G2");
 510                         Assert.AreEqual ("B", lvw.Items [1].Text, "#G3");
 511                         Assert.AreEqual ("A", lvw.Items [2].Text, "#G4");
 512
 513                         lvw.Sorting = SortOrder.None;
 514                         Assert.IsNotNull (lvw.ListViewItemSorter, "#H1");
 515                         Assert.AreEqual ("C", lvw.Items [0].Text, "#H2");
 516                         Assert.AreEqual ("B", lvw.Items [1].Text, "#H3");
 517                         Assert.AreEqual ("A", lvw.Items [2].Text, "#H4");
 518
 519                         // when Sorting is None and a new item is added, the collection is
 520                         // sorted using the previous Sorting value
 521                         lvw.Items.Add ("BB");
 522                         Assert.IsNotNull (lvw.ListViewItemSorter, "#I1");
 523                         Assert.AreEqual ("C", lvw.Items [0].Text, "#I2");
 524                         Assert.AreEqual ("BB", lvw.Items [1].Text, "#I3");
 525                         Assert.AreEqual ("B", lvw.Items [2].Text, "#I4");
 526                         Assert.AreEqual ("A", lvw.Items [3].Text, "#I5");
 527
 528                         lvw.Sorting = SortOrder.Ascending;
 529                         Assert.IsNotNull (lvw.ListViewItemSorter, "#J1");
 530 #if NET_2_0
 531                         Assert.AreEqual ("A", lvw.Items [0].Text, "#J2");
 532                         Assert.AreEqual ("B", lvw.Items [1].Text, "#J3");
 533                         Assert.AreEqual ("BB", lvw.Items [2].Text, "#J4");
 534                         Assert.AreEqual ("C", lvw.Items [3].Text, "#J5");
 535 #else
 536                         // in .NET 1.1, changing Sorting does not have any effect for
 537                         // SmallIcon and LargeIcon view if no custom comparer is used
 538                         Assert.AreEqual ("C", lvw.Items [0].Text, "#J2");
 539                         Assert.AreEqual ("BB", lvw.Items [1].Text, "#J3");
 540                         Assert.AreEqual ("B", lvw.Items [2].Text, "#J4");
 541                         Assert.AreEqual ("A", lvw.Items [3].Text, "#J5");
 542 #endif
 543
 544                         // when Sorting is not None and a new item is added, the
 545                         // collection is re-sorted automatically
 546                         lvw.Items.Add ("BA");
 547                         Assert.IsNotNull (lvw.ListViewItemSorter, "#K1");
 548 #if NET_2_0
 549                         Assert.AreEqual ("A", lvw.Items [0].Text, "#K2");
 550                         Assert.AreEqual ("B", lvw.Items [1].Text, "#K3");
 551                         Assert.AreEqual ("BA", lvw.Items [2].Text, "#K4");
 552                         Assert.AreEqual ("BB", lvw.Items [3].Text, "#K5");
 553                         Assert.AreEqual ("C", lvw.Items [4].Text, "#K6");
 554 #else
 555                         // in .NET 1.1, changing Sorting does not have any effect for
 556                         // SmallIcon and LargeIcon view if no custom comparer is used
 557                         Assert.AreEqual ("C", lvw.Items [0].Text, "#K2");
 558                         Assert.AreEqual ("BB", lvw.Items [1].Text, "#K3");
 559                         Assert.AreEqual ("BA", lvw.Items [2].Text, "#K4");
 560                         Assert.AreEqual ("B", lvw.Items [3].Text, "#K5");
 561                         Assert.AreEqual ("A", lvw.Items [4].Text, "#K6");
 562 #endif
 563
 564                         // assign a custom comparer
 565                         MockComparer mc = new MockComparer (false);
 566                         lvw.ListViewItemSorter = mc;
 567
 568                         // when a custom IComparer is assigned, the collection is immediately
 569                         // re-sorted
 570                         Assert.IsTrue (mc.CompareCount > compareCount, "#L1");
 571                         Assert.IsNotNull (lvw.ListViewItemSorter, "#L2");
 572                         Assert.AreSame (mc, lvw.ListViewItemSorter, "#L3");
 573                         Assert.AreEqual ("C", lvw.Items [0].Text, "#L4");
 574                         Assert.AreEqual ("BB", lvw.Items [1].Text, "#L5");
 575                         Assert.AreEqual ("BA", lvw.Items [2].Text, "#L6");
 576                         Assert.AreEqual ("B", lvw.Items [3].Text, "#L7");
 577                         Assert.AreEqual ("A", lvw.Items [4].Text, "#L8");
 578
 579                         // record compare count
 580                         compareCount = mc.CompareCount;
 581
 582                         // modifying Sorting results in re-sort
 583                         lvw.Sorting = SortOrder.Descending;
 584                         Assert.IsTrue (mc.CompareCount > compareCount, "#M1");
 585                         Assert.IsNotNull (lvw.ListViewItemSorter, "#M2");
 586                         Assert.AreSame (mc, lvw.ListViewItemSorter, "#M3");
 587                         Assert.AreEqual ("A", lvw.Items [0].Text, "#M4");
 588                         Assert.AreEqual ("B", lvw.Items [1].Text, "#M5");
 589                         Assert.AreEqual ("BA", lvw.Items [2].Text, "#M6");
 590                         Assert.AreEqual ("BB", lvw.Items [3].Text, "#M7");
 591                         Assert.AreEqual ("C", lvw.Items [4].Text, "#M8");
 592
 593                         // record compare count
 594                         compareCount = mc.CompareCount;
 595
 596                         // setting Sorting to the same value does not result in a sort
 597                         // operation
 598                         lvw.Sorting = SortOrder.Descending;
 599                         Assert.AreEqual (compareCount, mc.CompareCount, "#N1");
 600                         Assert.IsNotNull (lvw.ListViewItemSorter, "#N2");
 601                         Assert.AreSame (mc, lvw.ListViewItemSorter, "#N3");
 602                         Assert.AreEqual ("A", lvw.Items [0].Text, "#N4");
 603                         Assert.AreEqual ("B", lvw.Items [1].Text, "#N5");
 604                         Assert.AreEqual ("BA", lvw.Items [2].Text, "#N6");
 605                         Assert.AreEqual ("BB", lvw.Items [3].Text, "#N7");
 606                         Assert.AreEqual ("C", lvw.Items [4].Text, "#N8");
 607
 608                         // modifying Sorting results in re-sort
 609                         lvw.Sorting = SortOrder.Ascending;
 610                         Assert.IsTrue (mc.CompareCount > compareCount, "#O1");
 611                         Assert.IsNotNull (lvw.ListViewItemSorter, "#O2");
 612                         Assert.AreSame (mc, lvw.ListViewItemSorter, "#O3");
 613                         Assert.AreEqual ("C", lvw.Items [0].Text, "#O4");
 614                         Assert.AreEqual ("BB", lvw.Items [1].Text, "#O5");
 615                         Assert.AreEqual ("BA", lvw.Items [2].Text, "#O6");
 616                         Assert.AreEqual ("B", lvw.Items [3].Text, "#O7");
 617                         Assert.AreEqual ("A", lvw.Items [4].Text, "#O8");
 618
 619                         // record compare count
 620                         compareCount = mc.CompareCount;
 621
 622                         // adding an item when Sorting is not None causes re-sort
 623                         lvw.Items.Add ("BC");
 624                         Assert.IsTrue (mc.CompareCount > compareCount, "#P1");
 625                         Assert.IsNotNull (lvw.ListViewItemSorter, "#P2");
 626                         Assert.AreSame (mc, lvw.ListViewItemSorter, "#P3");
 627                         Assert.AreEqual ("C", lvw.Items [0].Text, "#P4");
 628                         Assert.AreEqual ("BC", lvw.Items [1].Text, "#P5");
 629                         Assert.AreEqual ("BB", lvw.Items [2].Text, "#P6");
 630                         Assert.AreEqual ("BA", lvw.Items [3].Text, "#P7");
 631                         Assert.AreEqual ("B", lvw.Items [4].Text, "#P8");
 632                         Assert.AreEqual ("A", lvw.Items [5].Text, "#P9");
 633
 634                         // record compare count
 635                         compareCount = mc.CompareCount;
 636
 637                         // assigning the same custom IComparer again does not result in a
 638                         // re-sort
 639                         lvw.ListViewItemSorter = mc;
 640                         Assert.AreEqual (compareCount, mc.CompareCount, "#Q1");
 641                         Assert.IsNotNull (lvw.ListViewItemSorter, "#Q2");
 642                         Assert.AreSame (mc, lvw.ListViewItemSorter, "#Q3");
 643                         Assert.AreEqual ("C", lvw.Items [0].Text, "#Q4");
 644                         Assert.AreEqual ("BC", lvw.Items [1].Text, "#Q5");
 645                         Assert.AreEqual ("BB", lvw.Items [2].Text, "#Q6");
 646                         Assert.AreEqual ("BA", lvw.Items [3].Text, "#Q7");
 647                         Assert.AreEqual ("B", lvw.Items [4].Text, "#Q8");
 648                         Assert.AreEqual ("A", lvw.Items [5].Text, "#Q9");
 649
 650                         // setting Sorting to None does not perform a sort
 651                         lvw.Sorting = SortOrder.None;
 652                         Assert.AreEqual (compareCount, mc.CompareCount, "#R1");
 653                         Assert.IsNotNull (lvw.ListViewItemSorter, "#R2");
 654                         Assert.AreSame (mc, lvw.ListViewItemSorter, "#R3");
 655                         Assert.AreEqual ("C", lvw.Items [0].Text, "#R4");
 656                         Assert.AreEqual ("BC", lvw.Items [1].Text, "#R5");
 657                         Assert.AreEqual ("BB", lvw.Items [2].Text, "#R6");
 658                         Assert.AreEqual ("BA", lvw.Items [3].Text, "#R7");
 659                         Assert.AreEqual ("B", lvw.Items [4].Text, "#R8");
 660                         Assert.AreEqual ("A", lvw.Items [5].Text, "#R9");
 661
 662                         // assigning the custom IComparer again does not result in a
 663                         // re-sort
 664                         lvw.ListViewItemSorter = mc;
 665                         Assert.AreEqual (compareCount, mc.CompareCount, "#S1");
 666                         Assert.IsNotNull (lvw.ListViewItemSorter, "#S2");
 667                         Assert.AreSame (mc, lvw.ListViewItemSorter, "#S3");
 668                         Assert.AreEqual ("C", lvw.Items [0].Text, "#S4");
 669                         Assert.AreEqual ("BC", lvw.Items [1].Text, "#S5");
 670                         Assert.AreEqual ("BB", lvw.Items [2].Text, "#S6");
 671                         Assert.AreEqual ("BA", lvw.Items [3].Text, "#S7");
 672                         Assert.AreEqual ("B", lvw.Items [4].Text, "#S8");
 673                         Assert.AreEqual ("A", lvw.Items [5].Text, "#S9");
 674
 675                         // set Sorting to Ascending again
 676                         lvw.Sorting = SortOrder.Ascending;
 677                         Assert.IsTrue (mc.CompareCount > compareCount, "#T1");
 678                         Assert.IsNotNull (lvw.ListViewItemSorter, "#T2");
 679                         Assert.AreSame (mc, lvw.ListViewItemSorter, "#T3");
 680                         Assert.AreEqual ("C", lvw.Items [0].Text, "#T4");
 681                         Assert.AreEqual ("BC", lvw.Items [1].Text, "#T5");
 682                         Assert.AreEqual ("BB", lvw.Items [2].Text, "#T6");
 683                         Assert.AreEqual ("BA", lvw.Items [3].Text, "#T7");
 684                         Assert.AreEqual ("B", lvw.Items [4].Text, "#T8");
 685                         Assert.AreEqual ("A", lvw.Items [5].Text, "#T9");
 686
 687                         // record compare count
 688                         compareCount = mc.CompareCount;
 689
 690                         // explicitly calling Sort results in a sort operation
 691                         lvw.Sort ();
 692                         Assert.IsTrue (mc.CompareCount > compareCount, "#U1");
 693                         Assert.IsNotNull (lvw.ListViewItemSorter, "#U2");
 694                         Assert.AreSame (mc, lvw.ListViewItemSorter, "#U3");
 695                         Assert.AreEqual ("C", lvw.Items [0].Text, "#U4");
 696                         Assert.AreEqual ("BC", lvw.Items [1].Text, "#U5");
 697                         Assert.AreEqual ("BB", lvw.Items [2].Text, "#U6");
 698                         Assert.AreEqual ("BA", lvw.Items [3].Text, "#U7");
 699                         Assert.AreEqual ("B", lvw.Items [4].Text, "#U8");
 700                         Assert.AreEqual ("A", lvw.Items [5].Text, "#U9");
 701                         lvw.Sorting = SortOrder.None;
 702
 703                         // record compare count
 704                         compareCount = mc.CompareCount;
 705
 706                         // adding an item when Sorting is None causes re-sort
 707                         lvw.Items.Add ("BD");
 708                         Assert.IsTrue (mc.CompareCount > compareCount, "#V1");
 709                         Assert.IsNotNull (lvw.ListViewItemSorter, "#V2");
 710                         Assert.AreSame (mc, lvw.ListViewItemSorter, "#V3");
 711                         Assert.AreEqual ("A", lvw.Items [0].Text, "#V4");
 712                         Assert.AreEqual ("B", lvw.Items [1].Text, "#V5");
 713                         Assert.AreEqual ("BA", lvw.Items [2].Text, "#V6");
 714                         Assert.AreEqual ("BB", lvw.Items [3].Text, "#V7");
 715                         Assert.AreEqual ("BC", lvw.Items [4].Text, "#V8");
 716                         Assert.AreEqual ("BD", lvw.Items [5].Text, "#V9");
 717                         Assert.AreEqual ("C", lvw.Items [6].Text, "#V10");
 718
 719                         // record compare count
 720                         compareCount = mc.CompareCount;
 721
 722                         // explicitly calling Sort when Sorting is None causes a re-sort
 723                         lvw.Sort ();
 724                         Assert.IsTrue (mc.CompareCount > compareCount, "#W1");
 725                         Assert.IsNotNull (lvw.ListViewItemSorter, "#W2");
 726                         Assert.AreSame (mc, lvw.ListViewItemSorter, "#W3");
 727                         Assert.AreEqual ("A", lvw.Items [0].Text, "#W4");
 728                         Assert.AreEqual ("B", lvw.Items [1].Text, "#W5");
 729                         Assert.AreEqual ("BA", lvw.Items [2].Text, "#W6");
 730                         Assert.AreEqual ("BB", lvw.Items [3].Text, "#W7");
 731                         Assert.AreEqual ("BC", lvw.Items [4].Text, "#W8");
 732                         Assert.AreEqual ("BD", lvw.Items [5].Text, "#W9");
 733                         Assert.AreEqual ("C", lvw.Items [6].Text, "#W10");
 734
 735                         // record compare count
 736                         compareCount = mc.CompareCount;
 737                         form.Dispose ();
 738                 }
 739
 740                 private void AssertSortIcon_NotCreated (View view)
 741                 {
 742                         Form form = new Form ();
 743                         form.ShowInTaskbar = false;
 744                         ListView lvw = CreateListView (view);
 745                         form.Controls.Add (lvw);
 746
 747                         Assert.IsNull (lvw.ListViewItemSorter, "#A1");
 748                         Assert.AreEqual ("B", lvw.Items [0].Text, "#A2");
 749                         Assert.AreEqual ("A", lvw.Items [1].Text, "#A3");
 750                         Assert.AreEqual ("C", lvw.Items [2].Text, "#A4");
 751
 752                         lvw.Sorting = SortOrder.None;
 753                         Assert.IsNull (lvw.ListViewItemSorter, "#B1");
 754                         Assert.AreEqual ("B", lvw.Items [0].Text, "#B2");
 755                         Assert.AreEqual ("A", lvw.Items [1].Text, "#B3");
 756                         Assert.AreEqual ("C", lvw.Items [2].Text, "#B4");
 757
 758                         lvw.Sorting = SortOrder.Descending;
 759                         Assert.IsNotNull (lvw.ListViewItemSorter, "#C1");
 760                         Assert.AreEqual ("B", lvw.Items [0].Text, "#C2");
 761                         Assert.AreEqual ("A", lvw.Items [1].Text, "#C3");
 762                         Assert.AreEqual ("C", lvw.Items [2].Text, "#C4");
 763
 764                         lvw.Sorting = SortOrder.Ascending;
 765                         Assert.IsNotNull (lvw.ListViewItemSorter, "#D1");
 766                         Assert.AreEqual ("B", lvw.Items [0].Text, "#D2");
 767                         Assert.AreEqual ("A", lvw.Items [1].Text, "#D3");
 768                         Assert.AreEqual ("C", lvw.Items [2].Text, "#D4");
 769
 770                         // when the handle is not created and a new item is added, the new
 771                         // item is just appended to the collection
 772                         lvw.Items.Add ("BB");
 773                         Assert.IsNotNull (lvw.ListViewItemSorter, "#E1");
 774                         Assert.AreEqual ("B", lvw.Items [0].Text, "#E2");
 775                         Assert.AreEqual ("A", lvw.Items [1].Text, "#E3");
 776                         Assert.AreEqual ("C", lvw.Items [2].Text, "#E4");
 777                         Assert.AreEqual ("BB", lvw.Items [3].Text, "#E5");
 778
 779                         // assign a custom comparer
 780                         MockComparer mc = new MockComparer (false);
 781                         lvw.ListViewItemSorter = mc;
 782
 783                         // assigning a custom IComparer has no effect
 784                         Assert.AreEqual (0, mc.CompareCount, "#F1");
 785                         Assert.IsNotNull (lvw.ListViewItemSorter, "#F2");
 786                         Assert.AreSame (mc, lvw.ListViewItemSorter, "#F3");
 787                         Assert.AreEqual ("B", lvw.Items [0].Text, "#F4");
 788                         Assert.AreEqual ("A", lvw.Items [1].Text, "#F5");
 789                         Assert.AreEqual ("C", lvw.Items [2].Text, "#F6");
 790                         Assert.AreEqual ("BB", lvw.Items [3].Text, "#F7");
 791
 792                         // modifying Sorting does not result in sort operation
 793                         lvw.Sorting = SortOrder.Descending;
 794                         Assert.AreEqual (0, mc.CompareCount, "#G1");
 795                         Assert.IsNotNull (lvw.ListViewItemSorter, "#G2");
 796                         Assert.AreSame (mc, lvw.ListViewItemSorter, "#G3");
 797                         Assert.AreEqual ("B", lvw.Items [0].Text, "#G4");
 798                         Assert.AreEqual ("A", lvw.Items [1].Text, "#G5");
 799                         Assert.AreEqual ("C", lvw.Items [2].Text, "#G6");
 800                         Assert.AreEqual ("BB", lvw.Items [3].Text, "#G7");
 801
 802                         // setting Sorting to the same value does not result in a sort
 803                         // operation
 804                         lvw.Sorting = SortOrder.Descending;
 805                         Assert.AreEqual (0, mc.CompareCount, "#H1");
 806                         Assert.IsNotNull (lvw.ListViewItemSorter, "#H2");
 807                         Assert.AreSame (mc, lvw.ListViewItemSorter, "#H3");
 808                         Assert.AreEqual ("B", lvw.Items [0].Text, "#H4");
 809                         Assert.AreEqual ("A", lvw.Items [1].Text, "#H5");
 810                         Assert.AreEqual ("C", lvw.Items [2].Text, "#H6");
 811                         Assert.AreEqual ("BB", lvw.Items [3].Text, "#H7");
 812
 813                         // setting Sorting to None does not result in a sort operation
 814                         lvw.Sorting = SortOrder.None;
 815                         Assert.AreEqual (0, mc.CompareCount, "#I1");
 816                         Assert.IsNotNull (lvw.ListViewItemSorter, "#I2");
 817                         Assert.AreSame (mc, lvw.ListViewItemSorter, "#I3");
 818                         Assert.AreEqual ("B", lvw.Items [0].Text, "#I4");
 819                         Assert.AreEqual ("A", lvw.Items [1].Text, "#I5");
 820                         Assert.AreEqual ("C", lvw.Items [2].Text, "#I6");
 821                         Assert.AreEqual ("BB", lvw.Items [3].Text, "#I7");
 822
 823                         // explicitly calling Sort when Sorting is None does not result
 824                         // in a sort operation
 825                         lvw.Sort ();
 826                         Assert.AreEqual (0, mc.CompareCount, "#J1");
 827                         Assert.IsNotNull (lvw.ListViewItemSorter, "#J2");
 828                         Assert.AreSame (mc, lvw.ListViewItemSorter, "#J3");
 829                         Assert.AreEqual ("B", lvw.Items [0].Text, "#J4");
 830                         Assert.AreEqual ("A", lvw.Items [1].Text, "#J5");
 831                         Assert.AreEqual ("C", lvw.Items [2].Text, "#J6");
 832                         Assert.AreEqual ("BB", lvw.Items [3].Text, "#J7");
 833
 834                         // setting Sorting again does not result in a sort operation
 835                         lvw.Sorting = SortOrder.Ascending;
 836                         Assert.AreEqual (0, mc.CompareCount, "#K1");
 837                         Assert.IsNotNull (lvw.ListViewItemSorter, "#K2");
 838                         Assert.AreSame (mc, lvw.ListViewItemSorter, "#K3");
 839                         Assert.AreEqual ("B", lvw.Items [0].Text, "#K4");
 840                         Assert.AreEqual ("A", lvw.Items [1].Text, "#K5");
 841                         Assert.AreEqual ("C", lvw.Items [2].Text, "#K6");
 842                         Assert.AreEqual ("BB", lvw.Items [3].Text, "#K7");
 843
 844                         // explicitly calling Sort when Sorting is Ascending does not
 845                         // result in a sort operation
 846                         lvw.Sort ();
 847                         Assert.AreEqual (0, mc.CompareCount, "#L1");
 848                         Assert.IsNotNull (lvw.ListViewItemSorter, "#L2");
 849                         Assert.AreSame (mc, lvw.ListViewItemSorter, "#L3");
 850                         Assert.AreEqual ("B", lvw.Items [0].Text, "#L4");
 851                         Assert.AreEqual ("A", lvw.Items [1].Text, "#L5");
 852                         Assert.AreEqual ("C", lvw.Items [2].Text, "#L6");
 853                         Assert.AreEqual ("BB", lvw.Items [3].Text, "#L7");
 854
 855                         // show the form to create the handle
 856                         form.Show ();
 857
 858                         // when the handle is created, the items are immediately sorted
 859                         Assert.IsTrue (mc.CompareCount > 0, "#L1");
 860                         Assert.IsNotNull (lvw.ListViewItemSorter, "#M2");
 861                         Assert.AreSame (mc, lvw.ListViewItemSorter, "#M3");
 862                         Assert.AreEqual ("C", lvw.Items [0].Text, "#M4");
 863                         Assert.AreEqual ("BB", lvw.Items [1].Text, "#M5");
 864                         Assert.AreEqual ("B", lvw.Items [2].Text, "#M6");
 865                         Assert.AreEqual ("A", lvw.Items [3].Text, "#M7");
 866
 867                         // setting ListViewItemSorter to null does not result in sort
 868                         // operation
 869                         lvw.ListViewItemSorter = null;
 870                         Assert.IsNull (lvw.ListViewItemSorter, "#N1");
 871                         Assert.AreEqual ("C", lvw.Items [0].Text, "#N2");
 872                         Assert.AreEqual ("BB", lvw.Items [1].Text, "#N3");
 873                         Assert.AreEqual ("B", lvw.Items [2].Text, "#N4");
 874                         Assert.AreEqual ("A", lvw.Items [3].Text, "#N5");
 875
 876                         // explicitly calling sort does not result in sort operation
 877                         lvw.Sort ();
 878                         Assert.IsNull (lvw.ListViewItemSorter, "#O1");
 879                         Assert.AreEqual ("C", lvw.Items [0].Text, "#O2");
 880                         Assert.AreEqual ("BB", lvw.Items [1].Text, "#O3");
 881                         Assert.AreEqual ("B", lvw.Items [2].Text, "#O4");
 882                         Assert.AreEqual ("A", lvw.Items [3].Text, "#O5");
 883
 884                         form.Dispose ();
 885                 }
 886
 887                 private void AssertSortNoIcon_Created (View view)
 888                 {
 889                         int compareCount = 0;
 890
 891                         Form form = new Form ();
 892                         form.ShowInTaskbar = false;
 893                         ListView lvw = CreateListView (view);
 894                         form.Controls.Add (lvw);
 895                         Assert.IsNull (lvw.ListViewItemSorter, "#A");
 896
 897                         form.Show ();
 898
 899                         Assert.IsNull (lvw.ListViewItemSorter, "#B1");
 900                         Assert.AreEqual ("B", lvw.Items [0].Text, "#B2");
 901                         Assert.AreEqual ("A", lvw.Items [1].Text, "#B3");
 902                         Assert.AreEqual ("C", lvw.Items [2].Text, "#B4");
 903
 904                         lvw.Sorting = SortOrder.None;
 905                         Assert.IsNull (lvw.ListViewItemSorter, "#C1");
 906                         Assert.AreEqual ("B", lvw.Items [0].Text, "#C2");
 907                         Assert.AreEqual ("A", lvw.Items [1].Text, "#C3");
 908                         Assert.AreEqual ("C", lvw.Items [2].Text, "#C4");
 909
 910                         lvw.Sorting = SortOrder.Ascending;
 911                         Assert.IsNull (lvw.ListViewItemSorter, "#D1");
 912                         Assert.AreEqual ("A", lvw.Items [0].Text, "#D2");
 913                         Assert.AreEqual ("B", lvw.Items [1].Text, "#D3");
 914                         Assert.AreEqual ("C", lvw.Items [2].Text, "#D4");
 915
 916                         lvw.Sorting = SortOrder.Descending;
 917                         Assert.IsNull (lvw.ListViewItemSorter, "#E1");
 918                         Assert.AreEqual ("C", lvw.Items [0].Text, "#E2");
 919                         Assert.AreEqual ("B", lvw.Items [1].Text, "#E3");
 920                         Assert.AreEqual ("A", lvw.Items [2].Text, "#E4");
 921
 922                         lvw.Sorting = SortOrder.None;
 923                         Assert.IsNull (lvw.ListViewItemSorter, "#F1");
 924                         Assert.AreEqual ("C", lvw.Items [0].Text, "#F2");
 925                         Assert.AreEqual ("B", lvw.Items [1].Text, "#F3");
 926                         Assert.AreEqual ("A", lvw.Items [2].Text, "#F4");
 927
 928                         // when Sorting is None and a new item is added, the item is
 929                         // appended to the collection
 930                         lvw.Items.Add ("BB");
 931                         Assert.IsNull (lvw.ListViewItemSorter, "#G1");
 932                         Assert.AreEqual ("C", lvw.Items [0].Text, "#G2");
 933                         Assert.AreEqual ("B", lvw.Items [1].Text, "#G3");
 934                         Assert.AreEqual ("A", lvw.Items [2].Text, "#G4");
 935                         Assert.AreEqual ("BB", lvw.Items [3].Text, "#G5");
 936
 937                         lvw.Sorting = SortOrder.Ascending;
 938                         Assert.IsNull (lvw.ListViewItemSorter, "#H1");
 939                         Assert.AreEqual ("A", lvw.Items [0].Text, "#H2");
 940                         Assert.AreEqual ("B", lvw.Items [1].Text, "#H3");
 941                         Assert.AreEqual ("BB", lvw.Items [2].Text, "#H4");
 942                         Assert.AreEqual ("C", lvw.Items [3].Text, "#H5");
 943
 944                         // when Sorting is not None and a new item is added, the
 945                         // collection is re-sorted automatically
 946                         lvw.Items.Add ("BA");
 947                         Assert.IsNull (lvw.ListViewItemSorter, "#I1");
 948                         Assert.AreEqual ("A", lvw.Items [0].Text, "#I2");
 949                         Assert.AreEqual ("B", lvw.Items [1].Text, "#I3");
 950                         Assert.AreEqual ("BA", lvw.Items [2].Text, "#I4");
 951                         Assert.AreEqual ("BB", lvw.Items [3].Text, "#I5");
 952                         Assert.AreEqual ("C", lvw.Items [4].Text, "#I6");
 953
 954                         // assign a custom comparer
 955                         MockComparer mc = new MockComparer (false);
 956                         lvw.ListViewItemSorter = mc;
 957
 958                         // when a custom IComparer is assigned, the collection is immediately
 959                         // re-sorted
 960                         Assert.IsTrue (mc.CompareCount > compareCount, "#J1");
 961                         Assert.IsNotNull (lvw.ListViewItemSorter, "#J2");
 962                         Assert.AreSame (mc, lvw.ListViewItemSorter, "#J3");
 963                         Assert.AreEqual ("C", lvw.Items [0].Text, "#J4");
 964                         Assert.AreEqual ("BB", lvw.Items [1].Text, "#J5");
 965                         Assert.AreEqual ("BA", lvw.Items [2].Text, "#J6");
 966                         Assert.AreEqual ("B", lvw.Items [3].Text, "#J7");
 967                         Assert.AreEqual ("A", lvw.Items [4].Text, "#J8");
 968
 969                         // record compare count
 970                         compareCount = mc.CompareCount;
 971
 972                         // modifying the sort order results in a sort
 973                         lvw.Sorting = SortOrder.Descending;
 974                         Assert.IsTrue (mc.CompareCount > compareCount, "#L1");
 975                         Assert.IsNotNull (lvw.ListViewItemSorter, "#K2");
 976                         Assert.AreSame (mc, lvw.ListViewItemSorter, "#K3");
 977                         Assert.AreEqual ("A", lvw.Items [0].Text, "#K4");
 978                         Assert.AreEqual ("B", lvw.Items [1].Text, "#K5");
 979                         Assert.AreEqual ("BA", lvw.Items [2].Text, "#K6");
 980                         Assert.AreEqual ("BB", lvw.Items [3].Text, "#K7");
 981                         Assert.AreEqual ("C", lvw.Items [4].Text, "#K8");
 982
 983                         // record compare count
 984                         compareCount = mc.CompareCount;
 985
 986                         // set the sort order to the same value does not result in a sort
 987                         // operation
 988                         lvw.Sorting = SortOrder.Descending;
 989                         Assert.AreEqual (compareCount, mc.CompareCount, "#L1");
 990                         Assert.IsNotNull (lvw.ListViewItemSorter, "#L2");
 991                         Assert.AreSame (mc, lvw.ListViewItemSorter, "#L3");
 992                         Assert.AreEqual ("A", lvw.Items [0].Text, "#L4");
 993                         Assert.AreEqual ("B", lvw.Items [1].Text, "#L5");
 994                         Assert.AreEqual ("BA", lvw.Items [2].Text, "#L6");
 995                         Assert.AreEqual ("BB", lvw.Items [3].Text, "#L7");
 996                         Assert.AreEqual ("C", lvw.Items [4].Text, "#L8");
 997
 998                         // modifying the sort order results in a sort
 999                         lvw.Sorting = SortOrder.Ascending;
1000                         Assert.IsTrue (mc.CompareCount > compareCount, "#M1");
1001                         Assert.IsNotNull (lvw.ListViewItemSorter, "#M2");
1002                         Assert.AreSame (mc, lvw.ListViewItemSorter, "#M3");
1003                         Assert.AreEqual ("C", lvw.Items [0].Text, "#M4");
1004                         Assert.AreEqual ("BB", lvw.Items [1].Text, "#M5");
1005                         Assert.AreEqual ("BA", lvw.Items [2].Text, "#M6");
1006                         Assert.AreEqual ("B", lvw.Items [3].Text, "#M7");
1007                         Assert.AreEqual ("A", lvw.Items [4].Text, "#M8");
1008
1009                         // record compare count
1010                         compareCount = mc.CompareCount;
1011
1012                         // adding an item when Sorting is not None caused a re-sort
1013                         lvw.Items.Add ("BC");
1014                         Assert.IsTrue (mc.CompareCount > compareCount, "#N1");
1015                         Assert.IsNotNull (lvw.ListViewItemSorter, "#N2");
1016                         Assert.AreSame (mc, lvw.ListViewItemSorter, "#N3");
1017                         Assert.AreEqual ("C", lvw.Items [0].Text, "#N4");
1018                         Assert.AreEqual ("BC", lvw.Items [1].Text, "#N5");
1019                         Assert.AreEqual ("BB", lvw.Items [2].Text, "#N6");
1020                         Assert.AreEqual ("BA", lvw.Items [3].Text, "#N7");
1021                         Assert.AreEqual ("B", lvw.Items [4].Text, "#N8");
1022                         Assert.AreEqual ("A", lvw.Items [5].Text, "#N9");
1023
1024                         // record compare count
1025                         compareCount = mc.CompareCount;
1026
1027                         // assigning the same custom IComparer again does not result in a
1028                         // re-sort
1029                         lvw.ListViewItemSorter = mc;
1030                         Assert.AreEqual (compareCount, mc.CompareCount, "#O1");
1031                         Assert.IsNotNull (lvw.ListViewItemSorter, "#O2");
1032                         Assert.AreSame (mc, lvw.ListViewItemSorter, "#O3");
1033                         Assert.AreEqual ("C", lvw.Items [0].Text, "#O4");
1034                         Assert.AreEqual ("BC", lvw.Items [1].Text, "#O5");
1035                         Assert.AreEqual ("BB", lvw.Items [2].Text, "#O6");
1036                         Assert.AreEqual ("BA", lvw.Items [3].Text, "#O7");
1037                         Assert.AreEqual ("B", lvw.Items [4].Text, "#O8");
1038                         Assert.AreEqual ("A", lvw.Items [5].Text, "#O9");
1039
1040                         // setting sort order to None does not perform a sort and resets
1041                         // the ListViewItemSorter
1042                         lvw.Sorting = SortOrder.None;
1043                         Assert.AreEqual (compareCount, mc.CompareCount, "#P1");
1044 #if NET_2_0
1045                         Assert.IsNull (lvw.ListViewItemSorter, "#P2");
1046 #else
1047                         Assert.IsNotNull (lvw.ListViewItemSorter, "#P2a");
1048                         Assert.AreSame (mc, lvw.ListViewItemSorter, "#P2b");
1049 #endif
1050                         Assert.AreEqual ("C", lvw.Items [0].Text, "#P3");
1051                         Assert.AreEqual ("BC", lvw.Items [1].Text, "#P4");
1052                         Assert.AreEqual ("BB", lvw.Items [2].Text, "#P5");
1053                         Assert.AreEqual ("BA", lvw.Items [3].Text, "#P6");
1054                         Assert.AreEqual ("B", lvw.Items [4].Text, "#P7");
1055                         Assert.AreEqual ("A", lvw.Items [5].Text, "#P8");
1056
1057
1058                         lvw.ListViewItemSorter = mc;
1059 #if NET_2_0
1060                         // assigning the previous custom IComparer again results in a
1061                         // re-sort
1062                         Assert.IsTrue (mc.CompareCount > compareCount, "#Q1");
1063                         Assert.IsNotNull (lvw.ListViewItemSorter, "#Q2");
1064                         Assert.AreSame (mc, lvw.ListViewItemSorter, "#Q3");
1065                         Assert.AreEqual ("A", lvw.Items [0].Text, "#Q4");
1066                         Assert.AreEqual ("B", lvw.Items [1].Text, "#Q5");
1067                         Assert.AreEqual ("BA", lvw.Items [2].Text, "#Q6");
1068                         Assert.AreEqual ("BB", lvw.Items [3].Text, "#Q7");
1069                         Assert.AreEqual ("BC", lvw.Items [4].Text, "#Q8");
1070                         Assert.AreEqual ("C", lvw.Items [5].Text, "#Q9");
1071 #else
1072                         Assert.AreEqual (compareCount, mc.CompareCount, "#Q1");
1073                         Assert.IsNotNull (lvw.ListViewItemSorter, "#Q2");
1074                         Assert.AreSame (mc, lvw.ListViewItemSorter, "#Q3");
1075                         Assert.AreEqual ("C", lvw.Items [0].Text, "#Q4");
1076                         Assert.AreEqual ("BC", lvw.Items [1].Text, "#Q5");
1077                         Assert.AreEqual ("BB", lvw.Items [2].Text, "#Q6");
1078                         Assert.AreEqual ("BA", lvw.Items [3].Text, "#Q7");
1079                         Assert.AreEqual ("B", lvw.Items [4].Text, "#Q8");
1080                         Assert.AreEqual ("A", lvw.Items [5].Text, "#Q9");
1081 #endif
1082
1083                         // record compare count
1084                         compareCount = mc.CompareCount;
1085
1086                         // set Sorting to Ascending again to verify that the internal
1087                         // IComparer is not used when we reset Sorting to None
1088                         // (as the items would then be sorted alfabetically)
1089                         lvw.Sorting = SortOrder.Ascending;
1090                         Assert.IsTrue (mc.CompareCount > compareCount, "#R1");
1091                         Assert.IsNotNull (lvw.ListViewItemSorter, "#R2");
1092                         Assert.AreSame (mc, lvw.ListViewItemSorter, "#R3");
1093                         Assert.AreEqual ("C", lvw.Items [0].Text, "#R4");
1094                         Assert.AreEqual ("BC", lvw.Items [1].Text, "#R5");
1095                         Assert.AreEqual ("BB", lvw.Items [2].Text, "#R6");
1096                         Assert.AreEqual ("BA", lvw.Items [3].Text, "#R7");
1097                         Assert.AreEqual ("B", lvw.Items [4].Text, "#R8");
1098                         Assert.AreEqual ("A", lvw.Items [5].Text, "#R9");
1099
1100                         // record compare count
1101                         compareCount = mc.CompareCount;
1102
1103                         lvw.Sorting = SortOrder.None;
1104                         Assert.AreEqual (compareCount, mc.CompareCount, "#S1");
1105 #if NET_2_0
1106                         Assert.IsNull (lvw.ListViewItemSorter, "#S2");
1107 #else
1108                         Assert.IsNotNull (lvw.ListViewItemSorter, "#S2a");
1109                         Assert.AreSame (mc, lvw.ListViewItemSorter, "#S2b");
1110 #endif
1111                         Assert.AreEqual ("C", lvw.Items [0].Text, "#S3");
1112                         Assert.AreEqual ("BC", lvw.Items [1].Text, "#S4");
1113                         Assert.AreEqual ("BB", lvw.Items [2].Text, "#S5");
1114                         Assert.AreEqual ("BA", lvw.Items [3].Text, "#S6");
1115                         Assert.AreEqual ("B", lvw.Items [4].Text, "#S7");
1116                         Assert.AreEqual ("A", lvw.Items [5].Text, "#S8");
1117
1118                         // record compare count
1119                         compareCount = mc.CompareCount;
1120
1121                         lvw.Items.Add ("BD");
1122 #if NET_2_0
1123                         // adding an item when Sorting is None does not cause a re-sort
1124                         Assert.AreEqual (compareCount, mc.CompareCount, "#T1");
1125                         Assert.IsNull (lvw.ListViewItemSorter, "#T2");
1126                         Assert.AreEqual ("C", lvw.Items [0].Text, "#T3");
1127                         Assert.AreEqual ("BC", lvw.Items [1].Text, "#T4");
1128                         Assert.AreEqual ("BB", lvw.Items [2].Text, "#T5");
1129                         Assert.AreEqual ("BA", lvw.Items [3].Text, "#T6");
1130                         Assert.AreEqual ("B", lvw.Items [4].Text, "#T7");
1131                         Assert.AreEqual ("A", lvw.Items [5].Text, "#T8");
1132                         Assert.AreEqual ("BD", lvw.Items [6].Text, "#T9");
1133 #else
1134                         // adding an item when Sorting is None results in a re-sort
1135                         Assert.IsTrue (mc.CompareCount > compareCount, "#T1");
1136                         Assert.IsNotNull (lvw.ListViewItemSorter, "#T2");
1137                         Assert.AreSame (mc, lvw.ListViewItemSorter, "#T3");
1138                         Assert.AreEqual ("A", lvw.Items [0].Text, "#T4");
1139                         Assert.AreEqual ("B", lvw.Items [1].Text, "#T5");
1140                         Assert.AreEqual ("BA", lvw.Items [2].Text, "#T6");
1141                         Assert.AreEqual ("BB", lvw.Items [3].Text, "#T7");
1142                         Assert.AreEqual ("BC", lvw.Items [4].Text, "#T8");
1143                         Assert.AreEqual ("BD", lvw.Items [5].Text, "#T9");
1144                         Assert.AreEqual ("C", lvw.Items [6].Text, "#T10");
1145 #endif
1146
1147                         // record compare count
1148                         compareCount = mc.CompareCount;
1149
1150                         lvw.Sort ();
1151 #if NET_2_0
1152                         // explicitly calling Sort when Sorting is None does nothing
1153                         Assert.AreEqual (compareCount, mc.CompareCount, "#U1");
1154                         Assert.IsNull (lvw.ListViewItemSorter, "#U2");
1155                         Assert.AreEqual ("C", lvw.Items [0].Text, "#U3");
1156                         Assert.AreEqual ("BC", lvw.Items [1].Text, "#U4");
1157                         Assert.AreEqual ("BB", lvw.Items [2].Text, "#U5");
1158                         Assert.AreEqual ("BA", lvw.Items [3].Text, "#U6");
1159                         Assert.AreEqual ("B", lvw.Items [4].Text, "#U7");
1160                         Assert.AreEqual ("A", lvw.Items [5].Text, "#U8");
1161                         Assert.AreEqual ("BD", lvw.Items [6].Text, "#U9");
1162 #else
1163                         // explicitly calling Sort when Sorting is None results in a re-sort
1164                         Assert.IsTrue (mc.CompareCount > compareCount, "#U1");
1165                         Assert.IsNotNull (lvw.ListViewItemSorter, "#U2");
1166                         Assert.AreSame (mc, lvw.ListViewItemSorter, "#U3");
1167                         Assert.AreEqual ("A", lvw.Items [0].Text, "#U4");
1168                         Assert.AreEqual ("B", lvw.Items [1].Text, "#U5");
1169                         Assert.AreEqual ("BA", lvw.Items [2].Text, "#U6");
1170                         Assert.AreEqual ("BB", lvw.Items [3].Text, "#U7");
1171                         Assert.AreEqual ("BC", lvw.Items [4].Text, "#U8");
1172                         Assert.AreEqual ("BD", lvw.Items [5].Text, "#U9");
1173                         Assert.AreEqual ("C", lvw.Items [6].Text, "#U10");
1174 #endif
1175
1176                         // record compare count
1177                         compareCount = mc.CompareCount;
1178
1179                         lvw.Sorting = SortOrder.Ascending;
1180 #if NET_2_0
1181                         // setting Sorting again, does not reinstate the custom IComparer
1182                         // but sorting is actually performed using an internal non-visible
1183                         // comparer
1184                         Assert.AreEqual (compareCount, mc.CompareCount, "#V1");
1185                         Assert.IsNull (lvw.ListViewItemSorter, "#V2");
1186                         Assert.AreEqual ("A", lvw.Items [0].Text, "#V3");
1187                         Assert.AreEqual ("B", lvw.Items [1].Text, "#V4");
1188                         Assert.AreEqual ("BA", lvw.Items [2].Text, "#V5");
1189                         Assert.AreEqual ("BB", lvw.Items [3].Text, "#V6");
1190                         Assert.AreEqual ("BC", lvw.Items [4].Text, "#V7");
1191                         Assert.AreEqual ("BD", lvw.Items [5].Text, "#V8");
1192                         Assert.AreEqual ("C", lvw.Items [6].Text, "#V9");
1193 #else
1194                         // setting Sorting again, uses the custom IComparer to sort the items
1195                         Assert.IsTrue (mc.CompareCount > compareCount, "#V1");
1196                         Assert.IsNotNull (lvw.ListViewItemSorter, "#V2");
1197                         Assert.AreSame (mc, lvw.ListViewItemSorter, "#V3");
1198                         Assert.AreEqual ("C", lvw.Items [0].Text, "#V4");
1199                         Assert.AreEqual ("BD", lvw.Items [1].Text, "#V5");
1200                         Assert.AreEqual ("BC", lvw.Items [2].Text, "#V6");
1201                         Assert.AreEqual ("BB", lvw.Items [3].Text, "#V7");
1202                         Assert.AreEqual ("BA", lvw.Items [4].Text, "#V8");
1203                         Assert.AreEqual ("B", lvw.Items [5].Text, "#V9");
1204                         Assert.AreEqual ("A", lvw.Items [6].Text, "#V10");
1205 #endif
1206
1207                         // record compare count
1208                         compareCount = mc.CompareCount;
1209
1210                         lvw.Sort ();
1211 #if NET_2_0
1212                         // explicitly calling Sort, does not reinstate the custom IComparer
1213                         // but sorting is actually performed using an internal non-visible
1214                         // comparer
1215                         Assert.AreEqual (compareCount, mc.CompareCount, "#W1");
1216                         Assert.IsNull (lvw.ListViewItemSorter, "#W2");
1217                         Assert.AreEqual ("A", lvw.Items [0].Text, "#W3");
1218                         Assert.AreEqual ("B", lvw.Items [1].Text, "#W4");
1219                         Assert.AreEqual ("BA", lvw.Items [2].Text, "#W5");
1220                         Assert.AreEqual ("BB", lvw.Items [3].Text, "#W6");
1221                         Assert.AreEqual ("BC", lvw.Items [4].Text, "#W7");
1222                         Assert.AreEqual ("BD", lvw.Items [5].Text, "#W8");
1223                         Assert.AreEqual ("C", lvw.Items [6].Text, "#W9");
1224 #else
1225                         // setting Sorting again, uses the custom IComparer to sort the items
1226                         Assert.IsTrue (mc.CompareCount > compareCount, "#W1");
1227                         Assert.IsNotNull (lvw.ListViewItemSorter, "#W2");
1228                         Assert.AreSame (mc, lvw.ListViewItemSorter, "#W3");
1229                         Assert.AreEqual ("C", lvw.Items [0].Text, "#W4");
1230                         Assert.AreEqual ("BD", lvw.Items [1].Text, "#W5");
1231                         Assert.AreEqual ("BC", lvw.Items [2].Text, "#W6");
1232                         Assert.AreEqual ("BB", lvw.Items [3].Text, "#W7");
1233                         Assert.AreEqual ("BA", lvw.Items [4].Text, "#W8");
1234                         Assert.AreEqual ("B", lvw.Items [5].Text, "#W9");
1235                         Assert.AreEqual ("A", lvw.Items [6].Text, "#W10");
1236 #endif
1237
1238                         // record compare count
1239                         compareCount = mc.CompareCount;
1240
1241                         form.Dispose ();
1242                 }
1243
1244                 private void AssertSortNoIcon_NotCreated (View view)
1245                 {
1246                         Form form = new Form ();
1247                         form.ShowInTaskbar = false;
1248                         ListView lvw = CreateListView (view);
1249                         form.Controls.Add (lvw);
1250
1251                         Assert.IsNull (lvw.ListViewItemSorter, "#A1");
1252                         Assert.AreEqual ("B", lvw.Items [0].Text, "#A2");
1253                         Assert.AreEqual ("A", lvw.Items [1].Text, "#A3");
1254                         Assert.AreEqual ("C", lvw.Items [2].Text, "#A4");
1255
1256                         lvw.Sorting = SortOrder.None;
1257                         Assert.IsNull (lvw.ListViewItemSorter, "#B1");
1258                         Assert.AreEqual ("B", lvw.Items [0].Text, "#B2");
1259                         Assert.AreEqual ("A", lvw.Items [1].Text, "#B3");
1260                         Assert.AreEqual ("C", lvw.Items [2].Text, "#B4");
1261
1262                         lvw.Sorting = SortOrder.Ascending;
1263                         Assert.IsNull (lvw.ListViewItemSorter, "#C1");
1264                         Assert.AreEqual ("B", lvw.Items [0].Text, "#C2");
1265                         Assert.AreEqual ("A", lvw.Items [1].Text, "#C3");
1266                         Assert.AreEqual ("C", lvw.Items [2].Text, "#C4");
1267
1268                         lvw.Sorting = SortOrder.Descending;
1269                         Assert.IsNull (lvw.ListViewItemSorter, "#D1");
1270                         Assert.AreEqual ("B", lvw.Items [0].Text, "#D2");
1271                         Assert.AreEqual ("A", lvw.Items [1].Text, "#D3");
1272                         Assert.AreEqual ("C", lvw.Items [2].Text, "#D4");
1273
1274                         lvw.Sorting = SortOrder.None;
1275                         Assert.IsNull (lvw.ListViewItemSorter, "#E1");
1276                         Assert.AreEqual ("B", lvw.Items [0].Text, "#E2");
1277                         Assert.AreEqual ("A", lvw.Items [1].Text, "#E3");
1278                         Assert.AreEqual ("C", lvw.Items [2].Text, "#E4");
1279
1280                         lvw.Sorting = SortOrder.Ascending;
1281                         Assert.IsNull (lvw.ListViewItemSorter, "#F1");
1282                         Assert.AreEqual ("B", lvw.Items [0].Text, "#F2");
1283                         Assert.AreEqual ("A", lvw.Items [1].Text, "#F3");
1284                         Assert.AreEqual ("C", lvw.Items [2].Text, "#F4");
1285
1286                         // when the handle is not created and a new item is added, the new
1287                         // item is just appended to the collection
1288                         lvw.Items.Add ("BB");
1289                         Assert.IsNull (lvw.ListViewItemSorter, "#G1");
1290                         Assert.AreEqual ("B", lvw.Items [0].Text, "#G2");
1291                         Assert.AreEqual ("A", lvw.Items [1].Text, "#G3");
1292                         Assert.AreEqual ("C", lvw.Items [2].Text, "#G4");
1293                         Assert.AreEqual ("BB", lvw.Items [3].Text, "#G5");
1294
1295                         // assign a custom comparer
1296                         MockComparer mc = new MockComparer (false);
1297                         lvw.ListViewItemSorter = mc;
1298
1299                         // assigning a custom IComparer has no effect
1300                         Assert.AreEqual (0, mc.CompareCount, "#H1");
1301                         Assert.IsNotNull (lvw.ListViewItemSorter, "#H2");
1302                         Assert.AreSame (mc, lvw.ListViewItemSorter, "#H3");
1303                         Assert.AreEqual ("B", lvw.Items [0].Text, "#H4");
1304                         Assert.AreEqual ("A", lvw.Items [1].Text, "#H5");
1305                         Assert.AreEqual ("C", lvw.Items [2].Text, "#H6");
1306                         Assert.AreEqual ("BB", lvw.Items [3].Text, "#H7");
1307
1308                         // modifying Sorting has no effect
1309                         lvw.Sorting = SortOrder.Descending;
1310                         Assert.AreEqual (0, mc.CompareCount, "#I1");
1311                         Assert.IsNotNull (lvw.ListViewItemSorter, "#I2");
1312                         Assert.AreSame (mc, lvw.ListViewItemSorter, "#I3");
1313                         Assert.AreEqual ("B", lvw.Items [0].Text, "#I4");
1314                         Assert.AreEqual ("A", lvw.Items [1].Text, "#I5");
1315                         Assert.AreEqual ("C", lvw.Items [2].Text, "#I6");
1316                         Assert.AreEqual ("BB", lvw.Items [3].Text, "#I7");
1317
1318                         // setting Sorting to the same value does not result in a sort
1319                         // operation
1320                         lvw.Sorting = SortOrder.Descending;
1321                         Assert.AreEqual (0, mc.CompareCount, "#J1");
1322                         Assert.IsNotNull (lvw.ListViewItemSorter, "#J2");
1323                         Assert.AreSame (mc, lvw.ListViewItemSorter, "#J3");
1324                         Assert.AreEqual ("B", lvw.Items [0].Text, "#J4");
1325                         Assert.AreEqual ("A", lvw.Items [1].Text, "#J5");
1326                         Assert.AreEqual ("C", lvw.Items [2].Text, "#J6");
1327                         Assert.AreEqual ("BB", lvw.Items [3].Text, "#J7");
1328
1329                         // setting Sorting to another value does not result in a sort
1330                         // operation
1331                         lvw.Sorting = SortOrder.Ascending;
1332                         Assert.AreEqual (0, mc.CompareCount, "#K1");
1333                         Assert.IsNotNull (lvw.ListViewItemSorter, "#K2");
1334                         Assert.AreSame (mc, lvw.ListViewItemSorter, "#K3");
1335                         Assert.AreEqual ("B", lvw.Items [0].Text, "#K4");
1336                         Assert.AreEqual ("A", lvw.Items [1].Text, "#K5");
1337                         Assert.AreEqual ("C", lvw.Items [2].Text, "#K6");
1338                         Assert.AreEqual ("BB", lvw.Items [3].Text, "#K7");
1339
1340                         lvw.Sorting = SortOrder.None;
1341                         Assert.AreEqual (0, mc.CompareCount, "#L1");
1342 #if NET_2_0
1343                         // setting Sorting to None does not perform a sort and resets the
1344                         // ListViewItemSorter
1345                         Assert.IsNull (lvw.ListViewItemSorter, "#L2");
1346 #else
1347                         // setting Sorting to None does not perform a sort
1348                         Assert.IsNotNull (lvw.ListViewItemSorter, "#L2a");
1349                         Assert.AreSame (mc, lvw.ListViewItemSorter, "#L2b");
1350 #endif
1351                         Assert.AreEqual ("B", lvw.Items [0].Text, "#L3");
1352                         Assert.AreEqual ("A", lvw.Items [1].Text, "#L4");
1353                         Assert.AreEqual ("C", lvw.Items [2].Text, "#L5");
1354                         Assert.AreEqual ("BB", lvw.Items [3].Text, "#L6");
1355
1356                         // explicitly calling Sort when Sorting is None does nothing
1357                         lvw.Sort ();
1358                         Assert.AreEqual (0, mc.CompareCount, "#M1");
1359 #if NET_2_0
1360                         Assert.IsNull (lvw.ListViewItemSorter, "#M2");
1361 #else
1362                         Assert.IsNotNull (lvw.ListViewItemSorter, "#M2a");
1363                         Assert.AreSame (mc, lvw.ListViewItemSorter, "#M2b");
1364 #endif
1365                         Assert.AreEqual ("B", lvw.Items [0].Text, "#M3");
1366                         Assert.AreEqual ("A", lvw.Items [1].Text, "#M4");
1367                         Assert.AreEqual ("C", lvw.Items [2].Text, "#M5");
1368                         Assert.AreEqual ("BB", lvw.Items [3].Text, "#M6");
1369
1370                         lvw.Sorting = SortOrder.Ascending;
1371                         Assert.AreEqual (0, mc.CompareCount, "#N1");
1372 #if NET_2_0
1373                         Assert.IsNull (lvw.ListViewItemSorter, "#N2");
1374 #else
1375                         Assert.IsNotNull (lvw.ListViewItemSorter, "#N2a");
1376                         Assert.AreSame (mc, lvw.ListViewItemSorter, "#N2b");
1377 #endif
1378                         Assert.AreEqual ("B", lvw.Items [0].Text, "#N3");
1379                         Assert.AreEqual ("A", lvw.Items [1].Text, "#N4");
1380                         Assert.AreEqual ("C", lvw.Items [2].Text, "#N5");
1381                         Assert.AreEqual ("BB", lvw.Items [3].Text, "#N6");
1382
1383                         // explicitly set the custom IComparer again
1384                         lvw.ListViewItemSorter = mc;
1385                         Assert.AreEqual (0, mc.CompareCount, "#O1");
1386                         Assert.IsNotNull (lvw.ListViewItemSorter, "#O2");
1387                         Assert.AreSame (mc, lvw.ListViewItemSorter, "#O3");
1388                         Assert.AreEqual ("B", lvw.Items [0].Text, "#O4");
1389                         Assert.AreEqual ("A", lvw.Items [1].Text, "#O5");
1390                         Assert.AreEqual ("C", lvw.Items [2].Text, "#O6");
1391                         Assert.AreEqual ("BB", lvw.Items [3].Text, "#O7");
1392
1393                         // explicitly calling Sort when handle is not created does not
1394                         // result in sort operation
1395                         Assert.AreEqual (0, mc.CompareCount, "#P1");
1396                         Assert.IsNotNull (lvw.ListViewItemSorter, "#P2");
1397                         Assert.AreSame (mc, lvw.ListViewItemSorter, "#P3");
1398                         Assert.AreEqual ("B", lvw.Items [0].Text, "#P4");
1399                         Assert.AreEqual ("A", lvw.Items [1].Text, "#P5");
1400                         Assert.AreEqual ("C", lvw.Items [2].Text, "#P6");
1401                         Assert.AreEqual ("BB", lvw.Items [3].Text, "#P7");
1402
1403                         // show the form to create the handle
1404                         form.Show ();
1405
1406                         // when the handle is created, the items are immediately sorted
1407                         Assert.IsTrue (mc.CompareCount > 0, "#Q1");
1408                         Assert.IsNotNull (lvw.ListViewItemSorter, "#Q2");
1409                         Assert.AreSame (mc, lvw.ListViewItemSorter, "#Q3");
1410                         Assert.AreEqual ("C", lvw.Items [0].Text, "#Q4");
1411                         Assert.AreEqual ("BB", lvw.Items [1].Text, "#Q5");
1412                         Assert.AreEqual ("B", lvw.Items [2].Text, "#Q6");
1413                         Assert.AreEqual ("A", lvw.Items [3].Text, "#Q7");
1414
1415                         // setting ListViewItemSorter to null does not result in sort
1416                         // operation
1417                         lvw.ListViewItemSorter = null;
1418                         Assert.IsNull (lvw.ListViewItemSorter, "#R1");
1419                         Assert.AreEqual ("C", lvw.Items [0].Text, "#R2");
1420                         Assert.AreEqual ("BB", lvw.Items [1].Text, "#R3");
1421                         Assert.AreEqual ("B", lvw.Items [2].Text, "#R4");
1422                         Assert.AreEqual ("A", lvw.Items [3].Text, "#R5");
1423
1424                         // explicitly calling sort does not result in sort operation
1425                         lvw.Sort ();
1426                         Assert.IsNull (lvw.ListViewItemSorter, "#S1");
1427                         Assert.AreEqual ("C", lvw.Items [0].Text, "#S2");
1428                         Assert.AreEqual ("BB", lvw.Items [1].Text, "#S3");
1429                         Assert.AreEqual ("B", lvw.Items [2].Text, "#S4");
1430                         Assert.AreEqual ("A", lvw.Items [3].Text, "#S5");
1431
1432                         // modifying Sorting does not result in sort operation
1433                         lvw.Sorting = SortOrder.Ascending;
1434                         Assert.IsNull (lvw.ListViewItemSorter, "#T1");
1435                         Assert.AreEqual ("C", lvw.Items [0].Text, "#T2");
1436                         Assert.AreEqual ("BB", lvw.Items [1].Text, "#T3");
1437                         Assert.AreEqual ("B", lvw.Items [2].Text, "#T4");
1438                         Assert.AreEqual ("A", lvw.Items [3].Text, "#T5");
1439
1440                         form.Dispose ();
1441                 }
1442
1443                 private void AssertSort_Checked (View view)
1444                 {
1445                         Form form = new Form ();
1446                         form.ShowInTaskbar = false;
1447                         ListView lvw = CreateListView (view);
1448                         lvw.CheckBoxes = true;
1449                         form.Controls.Add (lvw);
1450
1451                         form.Show ();
1452
1453                         Assert.AreEqual (0, lvw.CheckedItems.Count, "#A1");
1454                         Assert.AreEqual (0, lvw.CheckedIndices.Count, "#A2");
1455
1456                         // select an item
1457                         lvw.Items [2].Checked = true;
1458                         Assert.AreEqual (1, lvw.CheckedItems.Count, "#B1");
1459                         Assert.AreEqual (1, lvw.CheckedIndices.Count, "#B2");
1460                         Assert.AreEqual ("C", lvw.CheckedItems [0].Text, "#B3");
1461                         Assert.AreEqual (2, lvw.CheckedIndices [0], "#B4");
1462
1463                         // sort the items descending
1464                         lvw.Sorting = SortOrder.Descending;
1465                         Assert.AreEqual (1, lvw.CheckedItems.Count, "#C1");
1466                         Assert.AreEqual (1, lvw.CheckedIndices.Count, "#C2");
1467                         Assert.AreEqual ("C", lvw.CheckedItems [0].Text, "#C3");
1468                         Assert.AreEqual (0, lvw.CheckedIndices [0], "#C4");
1469
1470                         // add an item, which ends up before the selected item after the
1471                         // sort operation
1472                         ListViewItem item = lvw.Items.Add ("D");
1473                         Assert.AreEqual (1, lvw.CheckedItems.Count, "#D1");
1474                         Assert.AreEqual (1, lvw.CheckedIndices.Count, "#D2");
1475                         Assert.AreEqual ("C", lvw.CheckedItems [0].Text, "#D3");
1476                         Assert.AreEqual (1, lvw.CheckedIndices [0], "#D4");
1477
1478                         // remove an item before the selected item
1479                         lvw.Items.Remove (item);
1480                         Assert.AreEqual (1, lvw.CheckedItems.Count, "#E1");
1481                         Assert.AreEqual (1, lvw.CheckedIndices.Count, "#E2");
1482                         Assert.AreEqual ("C", lvw.CheckedItems [0].Text, "#E3");
1483                         Assert.AreEqual (0, lvw.CheckedIndices [0], "#E4");
1484
1485                         // insert an item before the selected item
1486                         lvw.Items.Insert (0, "D");
1487                         Assert.AreEqual (1, lvw.CheckedItems.Count, "#F1");
1488                         Assert.AreEqual (1, lvw.CheckedIndices.Count, "#F2");
1489                         Assert.AreEqual ("C", lvw.CheckedItems [0].Text, "#F3");
1490                         Assert.AreEqual (1, lvw.CheckedIndices [0], "#F4");
1491
1492                         // assign a custom comparer
1493                         MockComparer mc = new MockComparer (false);
1494                         lvw.ListViewItemSorter = mc;
1495
1496                         // items are re-sorted automatically
1497                         Assert.AreEqual (1, lvw.CheckedItems.Count, "#G1");
1498                         Assert.AreEqual (1, lvw.CheckedIndices.Count, "#G2");
1499                         Assert.AreEqual ("C", lvw.CheckedItems [0].Text, "#G3");
1500                         Assert.AreEqual (2, lvw.CheckedIndices [0], "#G4");
1501
1502                         // modify sort order
1503                         lvw.Sorting = SortOrder.Ascending;
1504                         Assert.AreEqual (1, lvw.CheckedItems.Count, "#H1");
1505                         Assert.AreEqual (1, lvw.CheckedIndices.Count, "#H2");
1506                         Assert.AreEqual ("C", lvw.CheckedItems [0].Text, "#H3");
1507                         Assert.AreEqual (1, lvw.CheckedIndices [0], "#H4");
1508
1509                         form.Dispose ();
1510                 }
1511
1512                 private void AssertSort_Selected (View view)
1513                 {
1514                         Form form = new Form ();
1515                         form.ShowInTaskbar = false;
1516                         ListView lvw = CreateListView (view);
1517                         form.Controls.Add (lvw);
1518
1519                         form.Show ();
1520
1521                         Assert.AreEqual (0, lvw.SelectedItems.Count, "#A1");
1522                         Assert.AreEqual (0, lvw.SelectedIndices.Count, "#A2");
1523
1524                         // select an item
1525                         lvw.Items [2].Selected = true;
1526                         Assert.AreEqual (1, lvw.SelectedItems.Count, "#B1");
1527                         Assert.AreEqual (1, lvw.SelectedIndices.Count, "#B2");
1528                         Assert.AreEqual ("C", lvw.SelectedItems [0].Text, "#B3");
1529                         Assert.AreEqual (2, lvw.SelectedIndices [0], "#B4");
1530
1531                         // sort the items descending
1532                         lvw.Sorting = SortOrder.Descending;
1533                         Assert.AreEqual (1, lvw.SelectedItems.Count, "#C1");
1534                         Assert.AreEqual (1, lvw.SelectedIndices.Count, "#C2");
1535                         Assert.AreEqual ("C", lvw.SelectedItems [0].Text, "#C3");
1536                         Assert.AreEqual (0, lvw.SelectedIndices [0], "#C4");
1537
1538                         // add an item, which ends up before the selected item after the
1539                         // sort operation
1540                         ListViewItem item = lvw.Items.Add ("D");
1541                         Assert.AreEqual (1, lvw.SelectedItems.Count, "#D1");
1542                         Assert.AreEqual (1, lvw.SelectedIndices.Count, "#D2");
1543                         Assert.AreEqual ("C", lvw.SelectedItems [0].Text, "#D3");
1544                         Assert.AreEqual (1, lvw.SelectedIndices [0], "#D4");
1545
1546                         // remove an item before the selected item
1547                         lvw.Items.Remove (item);
1548                         Assert.AreEqual (1, lvw.SelectedItems.Count, "#E1");
1549                         Assert.AreEqual (1, lvw.SelectedIndices.Count, "#E2");
1550                         Assert.AreEqual ("C", lvw.SelectedItems [0].Text, "#E3");
1551                         Assert.AreEqual (0, lvw.SelectedIndices [0], "#E4");
1552
1553                         // insert an item before the selected item
1554                         lvw.Items.Insert (0, "D");
1555                         Assert.AreEqual (1, lvw.SelectedItems.Count, "#F1");
1556                         Assert.AreEqual (1, lvw.SelectedIndices.Count, "#F2");
1557                         Assert.AreEqual ("C", lvw.SelectedItems [0].Text, "#F3");
1558                         Assert.AreEqual (1, lvw.SelectedIndices [0], "#F4");
1559
1560                         // assign a custom comparer
1561                         MockComparer mc = new MockComparer (false);
1562                         lvw.ListViewItemSorter = mc;
1563
1564                         // items are re-sorted automatically
1565                         Assert.AreEqual (1, lvw.SelectedItems.Count, "#G1");
1566                         Assert.AreEqual (1, lvw.SelectedIndices.Count, "#G2");
1567                         Assert.AreEqual ("C", lvw.SelectedItems [0].Text, "#G3");
1568                         Assert.AreEqual (2, lvw.SelectedIndices [0], "#G4");
1569
1570                         // modify sort order
1571                         lvw.Sorting = SortOrder.Ascending;
1572                         Assert.AreEqual (1, lvw.SelectedItems.Count, "#H1");
1573                         Assert.AreEqual (1, lvw.SelectedIndices.Count, "#H2");
1574                         Assert.AreEqual ("C", lvw.SelectedItems [0].Text, "#H3");
1575                         Assert.AreEqual (1, lvw.SelectedIndices [0], "#H4");
1576
1577                         form.Dispose ();
1578                 }
1579
1580                 private ListView CreateListView (View view)
1581                 {
1582                         ListView lvw = new ListView ();
1583                         lvw.View = view;
1584                         lvw.Items.Add ("B");
1585                         lvw.Items.Add ("A");
1586                         lvw.Items.Add ("C");
1587                         return lvw;
1588                 }
1589
1590                 private class MockComparer : IComparer
1591                 {
1592                         int _compareCount;
1593                         bool _throwException;
1594
1595                         public MockComparer (bool throwException)
1596                         {
1597                                 _throwException = throwException;
1598                         }
1599
1600                         public int CompareCount {
1601                                 get { return _compareCount; }
1602                         }
1603
1604                         public int Compare (object x, object y)
1605                         {
1606                                 _compareCount++;
1607                                 if (_throwException)
1608                                         throw new InvalidOperationException ();
1609
1610                                 ListViewItem item_x = x as ListViewItem;
1611                                 ListViewItem item_y = y as ListViewItem;
1612                                 SortOrder sortOrder = item_x.ListView.Sorting;
1613
1614                                 // we'll actually perform a reverse-sort
1615                                 if (sortOrder == SortOrder.Ascending)
1616                                         return String.Compare (item_y.Text, item_x.Text);
1617                                 else
1618                                         return String.Compare (item_x.Text, item_y.Text);
1619                         }
1620                 }
1621         }
1622 }