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