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