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

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