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