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