public void Test_Comparer()
{
PriorityQueue <Object> queue = new PriorityQueue <Object>();
assertNull(queue.Comparer);
MockComparer <Object> comparator = new MockComparer <Object>();
queue = new PriorityQueue <Object>(100, comparator);
assertEquals(comparator, queue.Comparer);
}
public void Test_ConstructorILComparer()
{
PriorityQueue <Object> queue = new PriorityQueue <Object>(100,
(IComparer <object>)null);
assertNotNull(queue);
assertEquals(0, queue.Count);
assertNull(queue.Comparer);
MockComparer <Object> comparator = new MockComparer <Object>();
queue = new PriorityQueue <Object>(100, comparator);
assertNotNull(queue);
assertEquals(0, queue.Count);
assertEquals(comparator, queue.Comparer);
}
public void Test_Remove_LObject_not_Compatible()
{
// J2N: Cannot remove a float from an integer queue - won't compile
//int[] array = { 2, 45, 7, -12, 9, 23, 17, 1118, 10, 16, 39 };
//List<Integer> list = CreateIntegerList(array);
//PriorityQueue<Integer> integerQueue = new PriorityQueue<Integer>(list);
//assertFalse(integerQueue.Remove(new float?(1.3F)));
// although argument element type is not compatible with those in queue,
// but comparator supports it.
MockComparer <Object> comparator = new MockComparer <Object>();
PriorityQueue <object> integerQueue1 = new PriorityQueue <object>(100,
comparator);
integerQueue1.Enqueue(1);
assertFalse(integerQueue1.Remove(new float?(1.3F)));
PriorityQueue <Object> queue = new PriorityQueue <Object>();
Object o = new Object();
queue.Enqueue(o);
assertTrue(queue.Remove(o));
}
private void AssertSortIcon_Created (View view)
{
int compareCount = 0;
Form form = new Form ();
form.ShowInTaskbar = false;
ListView lvw = CreateListView (view);
form.Controls.Add (lvw);
Assert.IsNull (lvw.ListViewItemSorter, "#A");
form.Show ();
Assert.IsNull (lvw.ListViewItemSorter, "#B1");
Assert.AreEqual ("B", lvw.Items [0].Text, "#B2");
Assert.AreEqual ("A", lvw.Items [1].Text, "#B3");
Assert.AreEqual ("C", lvw.Items [2].Text, "#B4");
lvw.Sorting = SortOrder.None;
Assert.IsNull (lvw.ListViewItemSorter, "#C1");
Assert.AreEqual ("B", lvw.Items [0].Text, "#C2");
Assert.AreEqual ("A", lvw.Items [1].Text, "#C3");
Assert.AreEqual ("C", lvw.Items [2].Text, "#C4");
lvw.Sorting = SortOrder.Descending;
Assert.IsNotNull (lvw.ListViewItemSorter, "#D1");
Assert.AreEqual ("C", lvw.Items [0].Text, "#D2");
Assert.AreEqual ("B", lvw.Items [1].Text, "#D3");
Assert.AreEqual ("A", lvw.Items [2].Text, "#D4");
lvw.Sorting = SortOrder.Ascending;
Assert.IsNotNull (lvw.ListViewItemSorter, "#E1");
Assert.AreEqual ("A", lvw.Items [0].Text, "#E2");
Assert.AreEqual ("B", lvw.Items [1].Text, "#E3");
Assert.AreEqual ("C", lvw.Items [2].Text, "#E4");
lvw.Sorting = SortOrder.None;
Assert.IsNotNull (lvw.ListViewItemSorter, "#F1");
Assert.AreEqual ("A", lvw.Items [0].Text, "#F2");
Assert.AreEqual ("B", lvw.Items [1].Text, "#F3");
Assert.AreEqual ("C", lvw.Items [2].Text, "#F4");
lvw.Sorting = SortOrder.Ascending;
Assert.IsNotNull (lvw.ListViewItemSorter, "#G1");
Assert.AreEqual ("A", lvw.Items [0].Text, "#G2");
Assert.AreEqual ("B", lvw.Items [1].Text, "#G3");
Assert.AreEqual ("C", lvw.Items [2].Text, "#G4");
lvw.Sorting = SortOrder.Descending;
Assert.IsNotNull (lvw.ListViewItemSorter, "#G1");
Assert.AreEqual ("C", lvw.Items [0].Text, "#G2");
Assert.AreEqual ("B", lvw.Items [1].Text, "#G3");
Assert.AreEqual ("A", lvw.Items [2].Text, "#G4");
lvw.Sorting = SortOrder.None;
Assert.IsNotNull (lvw.ListViewItemSorter, "#H1");
Assert.AreEqual ("C", lvw.Items [0].Text, "#H2");
Assert.AreEqual ("B", lvw.Items [1].Text, "#H3");
Assert.AreEqual ("A", lvw.Items [2].Text, "#H4");
// when Sorting is None and a new item is added, the collection is
// sorted using the previous Sorting value
lvw.Items.Add ("BB");
Assert.IsNotNull (lvw.ListViewItemSorter, "#I1");
Assert.AreEqual ("C", lvw.Items [0].Text, "#I2");
Assert.AreEqual ("BB", lvw.Items [1].Text, "#I3");
Assert.AreEqual ("B", lvw.Items [2].Text, "#I4");
Assert.AreEqual ("A", lvw.Items [3].Text, "#I5");
lvw.Sorting = SortOrder.Ascending;
Assert.IsNotNull (lvw.ListViewItemSorter, "#J1");
Assert.AreEqual ("A", lvw.Items [0].Text, "#J2");
Assert.AreEqual ("B", lvw.Items [1].Text, "#J3");
Assert.AreEqual ("BB", lvw.Items [2].Text, "#J4");
Assert.AreEqual ("C", lvw.Items [3].Text, "#J5");
// when Sorting is not None and a new item is added, the
// collection is re-sorted automatically
lvw.Items.Add ("BA");
Assert.IsNotNull (lvw.ListViewItemSorter, "#K1");
Assert.AreEqual ("A", lvw.Items [0].Text, "#K2");
Assert.AreEqual ("B", lvw.Items [1].Text, "#K3");
Assert.AreEqual ("BA", lvw.Items [2].Text, "#K4");
Assert.AreEqual ("BB", lvw.Items [3].Text, "#K5");
Assert.AreEqual ("C", lvw.Items [4].Text, "#K6");
// assign a custom comparer
MockComparer mc = new MockComparer (false);
lvw.ListViewItemSorter = mc;
// when a custom IComparer is assigned, the collection is immediately
// re-sorted
Assert.IsTrue (mc.CompareCount > compareCount, "#L1");
Assert.IsNotNull (lvw.ListViewItemSorter, "#L2");
Assert.AreSame (mc, lvw.ListViewItemSorter, "#L3");
Assert.AreEqual ("C", lvw.Items [0].Text, "#L4");
Assert.AreEqual ("BB", lvw.Items [1].Text, "#L5");
Assert.AreEqual ("BA", lvw.Items [2].Text, "#L6");
Assert.AreEqual ("B", lvw.Items [3].Text, "#L7");
Assert.AreEqual ("A", lvw.Items [4].Text, "#L8");
// record compare count
compareCount = mc.CompareCount;
// modifying Sorting results in re-sort
lvw.Sorting = SortOrder.Descending;
Assert.IsTrue (mc.CompareCount > compareCount, "#M1");
Assert.IsNotNull (lvw.ListViewItemSorter, "#M2");
Assert.AreSame (mc, lvw.ListViewItemSorter, "#M3");
Assert.AreEqual ("A", lvw.Items [0].Text, "#M4");
Assert.AreEqual ("B", lvw.Items [1].Text, "#M5");
Assert.AreEqual ("BA", lvw.Items [2].Text, "#M6");
Assert.AreEqual ("BB", lvw.Items [3].Text, "#M7");
Assert.AreEqual ("C", lvw.Items [4].Text, "#M8");
// record compare count
compareCount = mc.CompareCount;
// setting Sorting to the same value does not result in a sort
// operation
lvw.Sorting = SortOrder.Descending;
Assert.AreEqual (compareCount, mc.CompareCount, "#N1");
Assert.IsNotNull (lvw.ListViewItemSorter, "#N2");
Assert.AreSame (mc, lvw.ListViewItemSorter, "#N3");
Assert.AreEqual ("A", lvw.Items [0].Text, "#N4");
Assert.AreEqual ("B", lvw.Items [1].Text, "#N5");
Assert.AreEqual ("BA", lvw.Items [2].Text, "#N6");
Assert.AreEqual ("BB", lvw.Items [3].Text, "#N7");
Assert.AreEqual ("C", lvw.Items [4].Text, "#N8");
// modifying Sorting results in re-sort
lvw.Sorting = SortOrder.Ascending;
Assert.IsTrue (mc.CompareCount > compareCount, "#O1");
Assert.IsNotNull (lvw.ListViewItemSorter, "#O2");
Assert.AreSame (mc, lvw.ListViewItemSorter, "#O3");
Assert.AreEqual ("C", lvw.Items [0].Text, "#O4");
Assert.AreEqual ("BB", lvw.Items [1].Text, "#O5");
Assert.AreEqual ("BA", lvw.Items [2].Text, "#O6");
Assert.AreEqual ("B", lvw.Items [3].Text, "#O7");
Assert.AreEqual ("A", lvw.Items [4].Text, "#O8");
// record compare count
compareCount = mc.CompareCount;
// adding an item when Sorting is not None causes re-sort
lvw.Items.Add ("BC");
Assert.IsTrue (mc.CompareCount > compareCount, "#P1");
Assert.IsNotNull (lvw.ListViewItemSorter, "#P2");
Assert.AreSame (mc, lvw.ListViewItemSorter, "#P3");
Assert.AreEqual ("C", lvw.Items [0].Text, "#P4");
Assert.AreEqual ("BC", lvw.Items [1].Text, "#P5");
Assert.AreEqual ("BB", lvw.Items [2].Text, "#P6");
Assert.AreEqual ("BA", lvw.Items [3].Text, "#P7");
Assert.AreEqual ("B", lvw.Items [4].Text, "#P8");
Assert.AreEqual ("A", lvw.Items [5].Text, "#P9");
// record compare count
compareCount = mc.CompareCount;
// assigning the same custom IComparer again does not result in a
// re-sort
lvw.ListViewItemSorter = mc;
Assert.AreEqual (compareCount, mc.CompareCount, "#Q1");
Assert.IsNotNull (lvw.ListViewItemSorter, "#Q2");
Assert.AreSame (mc, lvw.ListViewItemSorter, "#Q3");
Assert.AreEqual ("C", lvw.Items [0].Text, "#Q4");
Assert.AreEqual ("BC", lvw.Items [1].Text, "#Q5");
Assert.AreEqual ("BB", lvw.Items [2].Text, "#Q6");
Assert.AreEqual ("BA", lvw.Items [3].Text, "#Q7");
Assert.AreEqual ("B", lvw.Items [4].Text, "#Q8");
Assert.AreEqual ("A", lvw.Items [5].Text, "#Q9");
// setting Sorting to None does not perform a sort
lvw.Sorting = SortOrder.None;
Assert.AreEqual (compareCount, mc.CompareCount, "#R1");
Assert.IsNotNull (lvw.ListViewItemSorter, "#R2");
Assert.AreSame (mc, lvw.ListViewItemSorter, "#R3");
Assert.AreEqual ("C", lvw.Items [0].Text, "#R4");
Assert.AreEqual ("BC", lvw.Items [1].Text, "#R5");
Assert.AreEqual ("BB", lvw.Items [2].Text, "#R6");
Assert.AreEqual ("BA", lvw.Items [3].Text, "#R7");
Assert.AreEqual ("B", lvw.Items [4].Text, "#R8");
Assert.AreEqual ("A", lvw.Items [5].Text, "#R9");
// assigning the custom IComparer again does not result in a
// re-sort
lvw.ListViewItemSorter = mc;
Assert.AreEqual (compareCount, mc.CompareCount, "#S1");
Assert.IsNotNull (lvw.ListViewItemSorter, "#S2");
Assert.AreSame (mc, lvw.ListViewItemSorter, "#S3");
Assert.AreEqual ("C", lvw.Items [0].Text, "#S4");
Assert.AreEqual ("BC", lvw.Items [1].Text, "#S5");
Assert.AreEqual ("BB", lvw.Items [2].Text, "#S6");
Assert.AreEqual ("BA", lvw.Items [3].Text, "#S7");
Assert.AreEqual ("B", lvw.Items [4].Text, "#S8");
Assert.AreEqual ("A", lvw.Items [5].Text, "#S9");
// set Sorting to Ascending again
lvw.Sorting = SortOrder.Ascending;
Assert.IsTrue (mc.CompareCount > compareCount, "#T1");
Assert.IsNotNull (lvw.ListViewItemSorter, "#T2");
Assert.AreSame (mc, lvw.ListViewItemSorter, "#T3");
Assert.AreEqual ("C", lvw.Items [0].Text, "#T4");
Assert.AreEqual ("BC", lvw.Items [1].Text, "#T5");
Assert.AreEqual ("BB", lvw.Items [2].Text, "#T6");
Assert.AreEqual ("BA", lvw.Items [3].Text, "#T7");
Assert.AreEqual ("B", lvw.Items [4].Text, "#T8");
Assert.AreEqual ("A", lvw.Items [5].Text, "#T9");
// record compare count
compareCount = mc.CompareCount;
// explicitly calling Sort results in a sort operation
lvw.Sort ();
Assert.IsTrue (mc.CompareCount > compareCount, "#U1");
Assert.IsNotNull (lvw.ListViewItemSorter, "#U2");
Assert.AreSame (mc, lvw.ListViewItemSorter, "#U3");
Assert.AreEqual ("C", lvw.Items [0].Text, "#U4");
Assert.AreEqual ("BC", lvw.Items [1].Text, "#U5");
Assert.AreEqual ("BB", lvw.Items [2].Text, "#U6");
Assert.AreEqual ("BA", lvw.Items [3].Text, "#U7");
Assert.AreEqual ("B", lvw.Items [4].Text, "#U8");
Assert.AreEqual ("A", lvw.Items [5].Text, "#U9");
lvw.Sorting = SortOrder.None;
// record compare count
compareCount = mc.CompareCount;
// adding an item when Sorting is None causes re-sort
lvw.Items.Add ("BD");
Assert.IsTrue (mc.CompareCount > compareCount, "#V1");
Assert.IsNotNull (lvw.ListViewItemSorter, "#V2");
Assert.AreSame (mc, lvw.ListViewItemSorter, "#V3");
Assert.AreEqual ("A", lvw.Items [0].Text, "#V4");
Assert.AreEqual ("B", lvw.Items [1].Text, "#V5");
Assert.AreEqual ("BA", lvw.Items [2].Text, "#V6");
Assert.AreEqual ("BB", lvw.Items [3].Text, "#V7");
Assert.AreEqual ("BC", lvw.Items [4].Text, "#V8");
Assert.AreEqual ("BD", lvw.Items [5].Text, "#V9");
Assert.AreEqual ("C", lvw.Items [6].Text, "#V10");
// record compare count
compareCount = mc.CompareCount;
// explicitly calling Sort when Sorting is None causes a re-sort
lvw.Sort ();
Assert.IsTrue (mc.CompareCount > compareCount, "#W1");
Assert.IsNotNull (lvw.ListViewItemSorter, "#W2");
Assert.AreSame (mc, lvw.ListViewItemSorter, "#W3");
Assert.AreEqual ("A", lvw.Items [0].Text, "#W4");
Assert.AreEqual ("B", lvw.Items [1].Text, "#W5");
Assert.AreEqual ("BA", lvw.Items [2].Text, "#W6");
Assert.AreEqual ("BB", lvw.Items [3].Text, "#W7");
Assert.AreEqual ("BC", lvw.Items [4].Text, "#W8");
Assert.AreEqual ("BD", lvw.Items [5].Text, "#W9");
Assert.AreEqual ("C", lvw.Items [6].Text, "#W10");
// record compare count
compareCount = mc.CompareCount;
form.Dispose ();
}
private void AssertSort_Selected (View view)
{
Form form = new Form ();
form.ShowInTaskbar = false;
ListView lvw = CreateListView (view);
form.Controls.Add (lvw);
form.Show ();
Assert.AreEqual (0, lvw.SelectedItems.Count, "#A1");
Assert.AreEqual (0, lvw.SelectedIndices.Count, "#A2");
// select an item
lvw.Items [2].Selected = true;
Assert.AreEqual (1, lvw.SelectedItems.Count, "#B1");
Assert.AreEqual (1, lvw.SelectedIndices.Count, "#B2");
Assert.AreEqual ("C", lvw.SelectedItems [0].Text, "#B3");
Assert.AreEqual (2, lvw.SelectedIndices [0], "#B4");
// sort the items descending
lvw.Sorting = SortOrder.Descending;
Assert.AreEqual (1, lvw.SelectedItems.Count, "#C1");
Assert.AreEqual (1, lvw.SelectedIndices.Count, "#C2");
Assert.AreEqual ("C", lvw.SelectedItems [0].Text, "#C3");
Assert.AreEqual (0, lvw.SelectedIndices [0], "#C4");
// add an item, which ends up before the selected item after the
// sort operation
ListViewItem item = lvw.Items.Add ("D");
Assert.AreEqual (1, lvw.SelectedItems.Count, "#D1");
Assert.AreEqual (1, lvw.SelectedIndices.Count, "#D2");
Assert.AreEqual ("C", lvw.SelectedItems [0].Text, "#D3");
Assert.AreEqual (1, lvw.SelectedIndices [0], "#D4");
// remove an item before the selected item
lvw.Items.Remove (item);
Assert.AreEqual (1, lvw.SelectedItems.Count, "#E1");
Assert.AreEqual (1, lvw.SelectedIndices.Count, "#E2");
Assert.AreEqual ("C", lvw.SelectedItems [0].Text, "#E3");
Assert.AreEqual (0, lvw.SelectedIndices [0], "#E4");
// insert an item before the selected item
lvw.Items.Insert (0, "D");
Assert.AreEqual (1, lvw.SelectedItems.Count, "#F1");
Assert.AreEqual (1, lvw.SelectedIndices.Count, "#F2");
Assert.AreEqual ("C", lvw.SelectedItems [0].Text, "#F3");
Assert.AreEqual (1, lvw.SelectedIndices [0], "#F4");
// assign a custom comparer
MockComparer mc = new MockComparer (false);
lvw.ListViewItemSorter = mc;
// items are re-sorted automatically
Assert.AreEqual (1, lvw.SelectedItems.Count, "#G1");
Assert.AreEqual (1, lvw.SelectedIndices.Count, "#G2");
Assert.AreEqual ("C", lvw.SelectedItems [0].Text, "#G3");
Assert.AreEqual (2, lvw.SelectedIndices [0], "#G4");
// modify sort order
lvw.Sorting = SortOrder.Ascending;
Assert.AreEqual (1, lvw.SelectedItems.Count, "#H1");
Assert.AreEqual (1, lvw.SelectedIndices.Count, "#H2");
Assert.AreEqual ("C", lvw.SelectedItems [0].Text, "#H3");
Assert.AreEqual (1, lvw.SelectedIndices [0], "#H4");
form.Dispose ();
}
private void AssertSortNoIcon_NotCreated (View view)
{
Form form = new Form ();
form.ShowInTaskbar = false;
ListView lvw = CreateListView (view);
form.Controls.Add (lvw);
Assert.IsNull (lvw.ListViewItemSorter, "#A1");
Assert.AreEqual ("B", lvw.Items [0].Text, "#A2");
Assert.AreEqual ("A", lvw.Items [1].Text, "#A3");
Assert.AreEqual ("C", lvw.Items [2].Text, "#A4");
lvw.Sorting = SortOrder.None;
Assert.IsNull (lvw.ListViewItemSorter, "#B1");
Assert.AreEqual ("B", lvw.Items [0].Text, "#B2");
Assert.AreEqual ("A", lvw.Items [1].Text, "#B3");
Assert.AreEqual ("C", lvw.Items [2].Text, "#B4");
lvw.Sorting = SortOrder.Ascending;
Assert.IsNull (lvw.ListViewItemSorter, "#C1");
Assert.AreEqual ("B", lvw.Items [0].Text, "#C2");
Assert.AreEqual ("A", lvw.Items [1].Text, "#C3");
Assert.AreEqual ("C", lvw.Items [2].Text, "#C4");
lvw.Sorting = SortOrder.Descending;
Assert.IsNull (lvw.ListViewItemSorter, "#D1");
Assert.AreEqual ("B", lvw.Items [0].Text, "#D2");
Assert.AreEqual ("A", lvw.Items [1].Text, "#D3");
Assert.AreEqual ("C", lvw.Items [2].Text, "#D4");
lvw.Sorting = SortOrder.None;
Assert.IsNull (lvw.ListViewItemSorter, "#E1");
Assert.AreEqual ("B", lvw.Items [0].Text, "#E2");
Assert.AreEqual ("A", lvw.Items [1].Text, "#E3");
Assert.AreEqual ("C", lvw.Items [2].Text, "#E4");
lvw.Sorting = SortOrder.Ascending;
Assert.IsNull (lvw.ListViewItemSorter, "#F1");
Assert.AreEqual ("B", lvw.Items [0].Text, "#F2");
Assert.AreEqual ("A", lvw.Items [1].Text, "#F3");
Assert.AreEqual ("C", lvw.Items [2].Text, "#F4");
// when the handle is not created and a new item is added, the new
// item is just appended to the collection
lvw.Items.Add ("BB");
Assert.IsNull (lvw.ListViewItemSorter, "#G1");
Assert.AreEqual ("B", lvw.Items [0].Text, "#G2");
Assert.AreEqual ("A", lvw.Items [1].Text, "#G3");
Assert.AreEqual ("C", lvw.Items [2].Text, "#G4");
Assert.AreEqual ("BB", lvw.Items [3].Text, "#G5");
// assign a custom comparer
MockComparer mc = new MockComparer (false);
lvw.ListViewItemSorter = mc;
// assigning a custom IComparer has no effect
Assert.AreEqual (0, mc.CompareCount, "#H1");
Assert.IsNotNull (lvw.ListViewItemSorter, "#H2");
Assert.AreSame (mc, lvw.ListViewItemSorter, "#H3");
Assert.AreEqual ("B", lvw.Items [0].Text, "#H4");
Assert.AreEqual ("A", lvw.Items [1].Text, "#H5");
Assert.AreEqual ("C", lvw.Items [2].Text, "#H6");
Assert.AreEqual ("BB", lvw.Items [3].Text, "#H7");
// modifying Sorting has no effect
lvw.Sorting = SortOrder.Descending;
Assert.AreEqual (0, mc.CompareCount, "#I1");
Assert.IsNotNull (lvw.ListViewItemSorter, "#I2");
Assert.AreSame (mc, lvw.ListViewItemSorter, "#I3");
Assert.AreEqual ("B", lvw.Items [0].Text, "#I4");
Assert.AreEqual ("A", lvw.Items [1].Text, "#I5");
Assert.AreEqual ("C", lvw.Items [2].Text, "#I6");
Assert.AreEqual ("BB", lvw.Items [3].Text, "#I7");
// setting Sorting to the same value does not result in a sort
// operation
lvw.Sorting = SortOrder.Descending;
Assert.AreEqual (0, mc.CompareCount, "#J1");
Assert.IsNotNull (lvw.ListViewItemSorter, "#J2");
Assert.AreSame (mc, lvw.ListViewItemSorter, "#J3");
Assert.AreEqual ("B", lvw.Items [0].Text, "#J4");
Assert.AreEqual ("A", lvw.Items [1].Text, "#J5");
Assert.AreEqual ("C", lvw.Items [2].Text, "#J6");
Assert.AreEqual ("BB", lvw.Items [3].Text, "#J7");
// setting Sorting to another value does not result in a sort
// operation
lvw.Sorting = SortOrder.Ascending;
Assert.AreEqual (0, mc.CompareCount, "#K1");
Assert.IsNotNull (lvw.ListViewItemSorter, "#K2");
Assert.AreSame (mc, lvw.ListViewItemSorter, "#K3");
Assert.AreEqual ("B", lvw.Items [0].Text, "#K4");
Assert.AreEqual ("A", lvw.Items [1].Text, "#K5");
Assert.AreEqual ("C", lvw.Items [2].Text, "#K6");
Assert.AreEqual ("BB", lvw.Items [3].Text, "#K7");
lvw.Sorting = SortOrder.None;
Assert.AreEqual (0, mc.CompareCount, "#L1");
// setting Sorting to None does not perform a sort and resets the
// ListViewItemSorter
Assert.IsNull (lvw.ListViewItemSorter, "#L2");
Assert.AreEqual ("B", lvw.Items [0].Text, "#L3");
Assert.AreEqual ("A", lvw.Items [1].Text, "#L4");
Assert.AreEqual ("C", lvw.Items [2].Text, "#L5");
Assert.AreEqual ("BB", lvw.Items [3].Text, "#L6");
// explicitly calling Sort when Sorting is None does nothing
lvw.Sort ();
Assert.AreEqual (0, mc.CompareCount, "#M1");
Assert.IsNull (lvw.ListViewItemSorter, "#M2");
Assert.AreEqual ("B", lvw.Items [0].Text, "#M3");
Assert.AreEqual ("A", lvw.Items [1].Text, "#M4");
Assert.AreEqual ("C", lvw.Items [2].Text, "#M5");
Assert.AreEqual ("BB", lvw.Items [3].Text, "#M6");
lvw.Sorting = SortOrder.Ascending;
Assert.AreEqual (0, mc.CompareCount, "#N1");
Assert.IsNull (lvw.ListViewItemSorter, "#N2");
Assert.AreEqual ("B", lvw.Items [0].Text, "#N3");
Assert.AreEqual ("A", lvw.Items [1].Text, "#N4");
Assert.AreEqual ("C", lvw.Items [2].Text, "#N5");
Assert.AreEqual ("BB", lvw.Items [3].Text, "#N6");
// explicitly set the custom IComparer again
lvw.ListViewItemSorter = mc;
Assert.AreEqual (0, mc.CompareCount, "#O1");
Assert.IsNotNull (lvw.ListViewItemSorter, "#O2");
Assert.AreSame (mc, lvw.ListViewItemSorter, "#O3");
Assert.AreEqual ("B", lvw.Items [0].Text, "#O4");
Assert.AreEqual ("A", lvw.Items [1].Text, "#O5");
Assert.AreEqual ("C", lvw.Items [2].Text, "#O6");
Assert.AreEqual ("BB", lvw.Items [3].Text, "#O7");
// explicitly calling Sort when handle is not created does not
// result in sort operation
Assert.AreEqual (0, mc.CompareCount, "#P1");
Assert.IsNotNull (lvw.ListViewItemSorter, "#P2");
Assert.AreSame (mc, lvw.ListViewItemSorter, "#P3");
Assert.AreEqual ("B", lvw.Items [0].Text, "#P4");
Assert.AreEqual ("A", lvw.Items [1].Text, "#P5");
Assert.AreEqual ("C", lvw.Items [2].Text, "#P6");
Assert.AreEqual ("BB", lvw.Items [3].Text, "#P7");
// show the form to create the handle
form.Show ();
// when the handle is created, the items are immediately sorted
Assert.IsTrue (mc.CompareCount > 0, "#Q1");
Assert.IsNotNull (lvw.ListViewItemSorter, "#Q2");
Assert.AreSame (mc, lvw.ListViewItemSorter, "#Q3");
Assert.AreEqual ("C", lvw.Items [0].Text, "#Q4");
Assert.AreEqual ("BB", lvw.Items [1].Text, "#Q5");
Assert.AreEqual ("B", lvw.Items [2].Text, "#Q6");
Assert.AreEqual ("A", lvw.Items [3].Text, "#Q7");
// setting ListViewItemSorter to null does not result in sort
// operation
lvw.ListViewItemSorter = null;
Assert.IsNull (lvw.ListViewItemSorter, "#R1");
Assert.AreEqual ("C", lvw.Items [0].Text, "#R2");
Assert.AreEqual ("BB", lvw.Items [1].Text, "#R3");
Assert.AreEqual ("B", lvw.Items [2].Text, "#R4");
Assert.AreEqual ("A", lvw.Items [3].Text, "#R5");
// explicitly calling sort does not result in sort operation
lvw.Sort ();
Assert.IsNull (lvw.ListViewItemSorter, "#S1");
Assert.AreEqual ("C", lvw.Items [0].Text, "#S2");
Assert.AreEqual ("BB", lvw.Items [1].Text, "#S3");
Assert.AreEqual ("B", lvw.Items [2].Text, "#S4");
Assert.AreEqual ("A", lvw.Items [3].Text, "#S5");
// modifying Sorting does not result in sort operation
lvw.Sorting = SortOrder.Ascending;
Assert.IsNull (lvw.ListViewItemSorter, "#T1");
Assert.AreEqual ("C", lvw.Items [0].Text, "#T2");
Assert.AreEqual ("BB", lvw.Items [1].Text, "#T3");
Assert.AreEqual ("B", lvw.Items [2].Text, "#T4");
Assert.AreEqual ("A", lvw.Items [3].Text, "#T5");
form.Dispose ();
}
public MockHeaderParser(string separator)
: base(true, separator)
{
this.MockComparer = new MockComparer();
}
public MockHeaderParser(bool supportsMultipleValues)
: base(supportsMultipleValues)
{
this.MockComparer = new MockComparer();
}
private void AssertSortNoIcon_Created (View view)
{
int compareCount = 0;
Form form = new Form ();
form.ShowInTaskbar = false;
ListView lvw = CreateListView (view);
form.Controls.Add (lvw);
Assert.IsNull (lvw.ListViewItemSorter, "#A");
form.Show ();
Assert.IsNull (lvw.ListViewItemSorter, "#B1");
Assert.AreEqual ("B", lvw.Items [0].Text, "#B2");
Assert.AreEqual ("A", lvw.Items [1].Text, "#B3");
Assert.AreEqual ("C", lvw.Items [2].Text, "#B4");
lvw.Sorting = SortOrder.None;
Assert.IsNull (lvw.ListViewItemSorter, "#C1");
Assert.AreEqual ("B", lvw.Items [0].Text, "#C2");
Assert.AreEqual ("A", lvw.Items [1].Text, "#C3");
Assert.AreEqual ("C", lvw.Items [2].Text, "#C4");
lvw.Sorting = SortOrder.Ascending;
Assert.IsNull (lvw.ListViewItemSorter, "#D1");
Assert.AreEqual ("A", lvw.Items [0].Text, "#D2");
Assert.AreEqual ("B", lvw.Items [1].Text, "#D3");
Assert.AreEqual ("C", lvw.Items [2].Text, "#D4");
lvw.Sorting = SortOrder.Descending;
Assert.IsNull (lvw.ListViewItemSorter, "#E1");
Assert.AreEqual ("C", lvw.Items [0].Text, "#E2");
Assert.AreEqual ("B", lvw.Items [1].Text, "#E3");
Assert.AreEqual ("A", lvw.Items [2].Text, "#E4");
lvw.Sorting = SortOrder.None;
Assert.IsNull (lvw.ListViewItemSorter, "#F1");
Assert.AreEqual ("C", lvw.Items [0].Text, "#F2");
Assert.AreEqual ("B", lvw.Items [1].Text, "#F3");
Assert.AreEqual ("A", lvw.Items [2].Text, "#F4");
// when Sorting is None and a new item is added, the item is
// appended to the collection
lvw.Items.Add ("BB");
Assert.IsNull (lvw.ListViewItemSorter, "#G1");
Assert.AreEqual ("C", lvw.Items [0].Text, "#G2");
Assert.AreEqual ("B", lvw.Items [1].Text, "#G3");
Assert.AreEqual ("A", lvw.Items [2].Text, "#G4");
Assert.AreEqual ("BB", lvw.Items [3].Text, "#G5");
lvw.Sorting = SortOrder.Ascending;
Assert.IsNull (lvw.ListViewItemSorter, "#H1");
Assert.AreEqual ("A", lvw.Items [0].Text, "#H2");
Assert.AreEqual ("B", lvw.Items [1].Text, "#H3");
Assert.AreEqual ("BB", lvw.Items [2].Text, "#H4");
Assert.AreEqual ("C", lvw.Items [3].Text, "#H5");
// when Sorting is not None and a new item is added, the
// collection is re-sorted automatically
lvw.Items.Add ("BA");
Assert.IsNull (lvw.ListViewItemSorter, "#I1");
Assert.AreEqual ("A", lvw.Items [0].Text, "#I2");
Assert.AreEqual ("B", lvw.Items [1].Text, "#I3");
Assert.AreEqual ("BA", lvw.Items [2].Text, "#I4");
Assert.AreEqual ("BB", lvw.Items [3].Text, "#I5");
Assert.AreEqual ("C", lvw.Items [4].Text, "#I6");
// assign a custom comparer
MockComparer mc = new MockComparer (false);
lvw.ListViewItemSorter = mc;
// when a custom IComparer is assigned, the collection is immediately
// re-sorted
Assert.IsTrue (mc.CompareCount > compareCount, "#J1");
Assert.IsNotNull (lvw.ListViewItemSorter, "#J2");
Assert.AreSame (mc, lvw.ListViewItemSorter, "#J3");
Assert.AreEqual ("C", lvw.Items [0].Text, "#J4");
Assert.AreEqual ("BB", lvw.Items [1].Text, "#J5");
Assert.AreEqual ("BA", lvw.Items [2].Text, "#J6");
Assert.AreEqual ("B", lvw.Items [3].Text, "#J7");
Assert.AreEqual ("A", lvw.Items [4].Text, "#J8");
// record compare count
compareCount = mc.CompareCount;
// modifying the sort order results in a sort
lvw.Sorting = SortOrder.Descending;
Assert.IsTrue (mc.CompareCount > compareCount, "#L1");
Assert.IsNotNull (lvw.ListViewItemSorter, "#K2");
Assert.AreSame (mc, lvw.ListViewItemSorter, "#K3");
Assert.AreEqual ("A", lvw.Items [0].Text, "#K4");
Assert.AreEqual ("B", lvw.Items [1].Text, "#K5");
Assert.AreEqual ("BA", lvw.Items [2].Text, "#K6");
Assert.AreEqual ("BB", lvw.Items [3].Text, "#K7");
Assert.AreEqual ("C", lvw.Items [4].Text, "#K8");
// record compare count
compareCount = mc.CompareCount;
// set the sort order to the same value does not result in a sort
// operation
lvw.Sorting = SortOrder.Descending;
Assert.AreEqual (compareCount, mc.CompareCount, "#L1");
Assert.IsNotNull (lvw.ListViewItemSorter, "#L2");
Assert.AreSame (mc, lvw.ListViewItemSorter, "#L3");
Assert.AreEqual ("A", lvw.Items [0].Text, "#L4");
Assert.AreEqual ("B", lvw.Items [1].Text, "#L5");
Assert.AreEqual ("BA", lvw.Items [2].Text, "#L6");
Assert.AreEqual ("BB", lvw.Items [3].Text, "#L7");
Assert.AreEqual ("C", lvw.Items [4].Text, "#L8");
// modifying the sort order results in a sort
lvw.Sorting = SortOrder.Ascending;
Assert.IsTrue (mc.CompareCount > compareCount, "#M1");
Assert.IsNotNull (lvw.ListViewItemSorter, "#M2");
Assert.AreSame (mc, lvw.ListViewItemSorter, "#M3");
Assert.AreEqual ("C", lvw.Items [0].Text, "#M4");
Assert.AreEqual ("BB", lvw.Items [1].Text, "#M5");
Assert.AreEqual ("BA", lvw.Items [2].Text, "#M6");
Assert.AreEqual ("B", lvw.Items [3].Text, "#M7");
Assert.AreEqual ("A", lvw.Items [4].Text, "#M8");
// record compare count
compareCount = mc.CompareCount;
// adding an item when Sorting is not None caused a re-sort
lvw.Items.Add ("BC");
Assert.IsTrue (mc.CompareCount > compareCount, "#N1");
Assert.IsNotNull (lvw.ListViewItemSorter, "#N2");
Assert.AreSame (mc, lvw.ListViewItemSorter, "#N3");
Assert.AreEqual ("C", lvw.Items [0].Text, "#N4");
Assert.AreEqual ("BC", lvw.Items [1].Text, "#N5");
Assert.AreEqual ("BB", lvw.Items [2].Text, "#N6");
Assert.AreEqual ("BA", lvw.Items [3].Text, "#N7");
Assert.AreEqual ("B", lvw.Items [4].Text, "#N8");
Assert.AreEqual ("A", lvw.Items [5].Text, "#N9");
// record compare count
compareCount = mc.CompareCount;
// assigning the same custom IComparer again does not result in a
// re-sort
lvw.ListViewItemSorter = mc;
Assert.AreEqual (compareCount, mc.CompareCount, "#O1");
Assert.IsNotNull (lvw.ListViewItemSorter, "#O2");
Assert.AreSame (mc, lvw.ListViewItemSorter, "#O3");
Assert.AreEqual ("C", lvw.Items [0].Text, "#O4");
Assert.AreEqual ("BC", lvw.Items [1].Text, "#O5");
Assert.AreEqual ("BB", lvw.Items [2].Text, "#O6");
Assert.AreEqual ("BA", lvw.Items [3].Text, "#O7");
Assert.AreEqual ("B", lvw.Items [4].Text, "#O8");
Assert.AreEqual ("A", lvw.Items [5].Text, "#O9");
// setting sort order to None does not perform a sort and resets
// the ListViewItemSorter
lvw.Sorting = SortOrder.None;
Assert.AreEqual (compareCount, mc.CompareCount, "#P1");
#if NET_2_0
Assert.IsNull (lvw.ListViewItemSorter, "#P2");
#else
Assert.IsNotNull (lvw.ListViewItemSorter, "#P2a");
Assert.AreSame (mc, lvw.ListViewItemSorter, "#P2b");
#endif
Assert.AreEqual ("C", lvw.Items [0].Text, "#P3");
Assert.AreEqual ("BC", lvw.Items [1].Text, "#P4");
Assert.AreEqual ("BB", lvw.Items [2].Text, "#P5");
Assert.AreEqual ("BA", lvw.Items [3].Text, "#P6");
Assert.AreEqual ("B", lvw.Items [4].Text, "#P7");
Assert.AreEqual ("A", lvw.Items [5].Text, "#P8");
lvw.ListViewItemSorter = mc;
#if NET_2_0
// assigning the previous custom IComparer again results in a
// re-sort
Assert.IsTrue (mc.CompareCount > compareCount, "#Q1");
Assert.IsNotNull (lvw.ListViewItemSorter, "#Q2");
Assert.AreSame (mc, lvw.ListViewItemSorter, "#Q3");
Assert.AreEqual ("A", lvw.Items [0].Text, "#Q4");
Assert.AreEqual ("B", lvw.Items [1].Text, "#Q5");
Assert.AreEqual ("BA", lvw.Items [2].Text, "#Q6");
Assert.AreEqual ("BB", lvw.Items [3].Text, "#Q7");
Assert.AreEqual ("BC", lvw.Items [4].Text, "#Q8");
Assert.AreEqual ("C", lvw.Items [5].Text, "#Q9");
#else
Assert.AreEqual (compareCount, mc.CompareCount, "#Q1");
Assert.IsNotNull (lvw.ListViewItemSorter, "#Q2");
Assert.AreSame (mc, lvw.ListViewItemSorter, "#Q3");
Assert.AreEqual ("C", lvw.Items [0].Text, "#Q4");
Assert.AreEqual ("BC", lvw.Items [1].Text, "#Q5");
Assert.AreEqual ("BB", lvw.Items [2].Text, "#Q6");
Assert.AreEqual ("BA", lvw.Items [3].Text, "#Q7");
Assert.AreEqual ("B", lvw.Items [4].Text, "#Q8");
Assert.AreEqual ("A", lvw.Items [5].Text, "#Q9");
#endif
// record compare count
compareCount = mc.CompareCount;
// set Sorting to Ascending again to verify that the internal
// IComparer is not used when we reset Sorting to None
// (as the items would then be sorted alfabetically)
lvw.Sorting = SortOrder.Ascending;
Assert.IsTrue (mc.CompareCount > compareCount, "#R1");
Assert.IsNotNull (lvw.ListViewItemSorter, "#R2");
Assert.AreSame (mc, lvw.ListViewItemSorter, "#R3");
Assert.AreEqual ("C", lvw.Items [0].Text, "#R4");
Assert.AreEqual ("BC", lvw.Items [1].Text, "#R5");
Assert.AreEqual ("BB", lvw.Items [2].Text, "#R6");
Assert.AreEqual ("BA", lvw.Items [3].Text, "#R7");
Assert.AreEqual ("B", lvw.Items [4].Text, "#R8");
Assert.AreEqual ("A", lvw.Items [5].Text, "#R9");
// record compare count
compareCount = mc.CompareCount;
lvw.Sorting = SortOrder.None;
Assert.AreEqual (compareCount, mc.CompareCount, "#S1");
#if NET_2_0
Assert.IsNull (lvw.ListViewItemSorter, "#S2");
#else
Assert.IsNotNull (lvw.ListViewItemSorter, "#S2a");
Assert.AreSame (mc, lvw.ListViewItemSorter, "#S2b");
#endif
Assert.AreEqual ("C", lvw.Items [0].Text, "#S3");
Assert.AreEqual ("BC", lvw.Items [1].Text, "#S4");
Assert.AreEqual ("BB", lvw.Items [2].Text, "#S5");
Assert.AreEqual ("BA", lvw.Items [3].Text, "#S6");
Assert.AreEqual ("B", lvw.Items [4].Text, "#S7");
Assert.AreEqual ("A", lvw.Items [5].Text, "#S8");
// record compare count
compareCount = mc.CompareCount;
lvw.Items.Add ("BD");
#if NET_2_0
// adding an item when Sorting is None does not cause a re-sort
Assert.AreEqual (compareCount, mc.CompareCount, "#T1");
Assert.IsNull (lvw.ListViewItemSorter, "#T2");
Assert.AreEqual ("C", lvw.Items [0].Text, "#T3");
Assert.AreEqual ("BC", lvw.Items [1].Text, "#T4");
Assert.AreEqual ("BB", lvw.Items [2].Text, "#T5");
Assert.AreEqual ("BA", lvw.Items [3].Text, "#T6");
Assert.AreEqual ("B", lvw.Items [4].Text, "#T7");
Assert.AreEqual ("A", lvw.Items [5].Text, "#T8");
Assert.AreEqual ("BD", lvw.Items [6].Text, "#T9");
#else
// adding an item when Sorting is None results in a re-sort
Assert.IsTrue (mc.CompareCount > compareCount, "#T1");
Assert.IsNotNull (lvw.ListViewItemSorter, "#T2");
Assert.AreSame (mc, lvw.ListViewItemSorter, "#T3");
Assert.AreEqual ("A", lvw.Items [0].Text, "#T4");
Assert.AreEqual ("B", lvw.Items [1].Text, "#T5");
Assert.AreEqual ("BA", lvw.Items [2].Text, "#T6");
Assert.AreEqual ("BB", lvw.Items [3].Text, "#T7");
Assert.AreEqual ("BC", lvw.Items [4].Text, "#T8");
Assert.AreEqual ("BD", lvw.Items [5].Text, "#T9");
Assert.AreEqual ("C", lvw.Items [6].Text, "#T10");
#endif
// record compare count
compareCount = mc.CompareCount;
lvw.Sort ();
#if NET_2_0
// explicitly calling Sort when Sorting is None does nothing
Assert.AreEqual (compareCount, mc.CompareCount, "#U1");
Assert.IsNull (lvw.ListViewItemSorter, "#U2");
Assert.AreEqual ("C", lvw.Items [0].Text, "#U3");
Assert.AreEqual ("BC", lvw.Items [1].Text, "#U4");
Assert.AreEqual ("BB", lvw.Items [2].Text, "#U5");
Assert.AreEqual ("BA", lvw.Items [3].Text, "#U6");
Assert.AreEqual ("B", lvw.Items [4].Text, "#U7");
Assert.AreEqual ("A", lvw.Items [5].Text, "#U8");
Assert.AreEqual ("BD", lvw.Items [6].Text, "#U9");
#else
// explicitly calling Sort when Sorting is None results in a re-sort
Assert.IsTrue (mc.CompareCount > compareCount, "#U1");
Assert.IsNotNull (lvw.ListViewItemSorter, "#U2");
Assert.AreSame (mc, lvw.ListViewItemSorter, "#U3");
Assert.AreEqual ("A", lvw.Items [0].Text, "#U4");
Assert.AreEqual ("B", lvw.Items [1].Text, "#U5");
Assert.AreEqual ("BA", lvw.Items [2].Text, "#U6");
Assert.AreEqual ("BB", lvw.Items [3].Text, "#U7");
Assert.AreEqual ("BC", lvw.Items [4].Text, "#U8");
Assert.AreEqual ("BD", lvw.Items [5].Text, "#U9");
Assert.AreEqual ("C", lvw.Items [6].Text, "#U10");
#endif
// record compare count
compareCount = mc.CompareCount;
lvw.Sorting = SortOrder.Ascending;
#if NET_2_0
// setting Sorting again, does not reinstate the custom IComparer
// but sorting is actually performed using an internal non-visible
// comparer
Assert.AreEqual (compareCount, mc.CompareCount, "#V1");
Assert.IsNull (lvw.ListViewItemSorter, "#V2");
Assert.AreEqual ("A", lvw.Items [0].Text, "#V3");
Assert.AreEqual ("B", lvw.Items [1].Text, "#V4");
Assert.AreEqual ("BA", lvw.Items [2].Text, "#V5");
Assert.AreEqual ("BB", lvw.Items [3].Text, "#V6");
Assert.AreEqual ("BC", lvw.Items [4].Text, "#V7");
Assert.AreEqual ("BD", lvw.Items [5].Text, "#V8");
Assert.AreEqual ("C", lvw.Items [6].Text, "#V9");
#else
// setting Sorting again, uses the custom IComparer to sort the items
Assert.IsTrue (mc.CompareCount > compareCount, "#V1");
Assert.IsNotNull (lvw.ListViewItemSorter, "#V2");
Assert.AreSame (mc, lvw.ListViewItemSorter, "#V3");
Assert.AreEqual ("C", lvw.Items [0].Text, "#V4");
Assert.AreEqual ("BD", lvw.Items [1].Text, "#V5");
Assert.AreEqual ("BC", lvw.Items [2].Text, "#V6");
Assert.AreEqual ("BB", lvw.Items [3].Text, "#V7");
Assert.AreEqual ("BA", lvw.Items [4].Text, "#V8");
Assert.AreEqual ("B", lvw.Items [5].Text, "#V9");
Assert.AreEqual ("A", lvw.Items [6].Text, "#V10");
#endif
// record compare count
compareCount = mc.CompareCount;
lvw.Sort ();
#if NET_2_0
// explicitly calling Sort, does not reinstate the custom IComparer
// but sorting is actually performed using an internal non-visible
// comparer
Assert.AreEqual (compareCount, mc.CompareCount, "#W1");
Assert.IsNull (lvw.ListViewItemSorter, "#W2");
Assert.AreEqual ("A", lvw.Items [0].Text, "#W3");
Assert.AreEqual ("B", lvw.Items [1].Text, "#W4");
Assert.AreEqual ("BA", lvw.Items [2].Text, "#W5");
Assert.AreEqual ("BB", lvw.Items [3].Text, "#W6");
Assert.AreEqual ("BC", lvw.Items [4].Text, "#W7");
Assert.AreEqual ("BD", lvw.Items [5].Text, "#W8");
Assert.AreEqual ("C", lvw.Items [6].Text, "#W9");
#else
// setting Sorting again, uses the custom IComparer to sort the items
Assert.IsTrue (mc.CompareCount > compareCount, "#W1");
Assert.IsNotNull (lvw.ListViewItemSorter, "#W2");
Assert.AreSame (mc, lvw.ListViewItemSorter, "#W3");
Assert.AreEqual ("C", lvw.Items [0].Text, "#W4");
Assert.AreEqual ("BD", lvw.Items [1].Text, "#W5");
Assert.AreEqual ("BC", lvw.Items [2].Text, "#W6");
Assert.AreEqual ("BB", lvw.Items [3].Text, "#W7");
Assert.AreEqual ("BA", lvw.Items [4].Text, "#W8");
Assert.AreEqual ("B", lvw.Items [5].Text, "#W9");
Assert.AreEqual ("A", lvw.Items [6].Text, "#W10");
#endif
// record compare count
compareCount = mc.CompareCount;
form.Dispose ();
}
