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