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

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