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

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