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