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

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