Modernize: Use override where possible

[dolphin.git] / src / tests / kitemlistselectionmanagertest.cpp

diff --git a/src/tests/kitemlistselectionmanagertest.cpp b/src/tests/kitemlistselectionmanagertest.cpp
index c27096177038a7d53c88be17e7792a5d2253910b..245f23d64e48c95dd67b9783f7bdd323281cf65b 100644 (file)
--- a/src/tests/kitemlistselectionmanagertest.cpp
+++ b/src/tests/kitemlistselectionmanagertest.cpp
@@ -18,27 +18,39 @@
  *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA            *
  ***************************************************************************/
 
  *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA            *
  ***************************************************************************/
 

-#include <qtest_kde.h>
-

 #include "kitemviews/kitemmodelbase.h"
 #include "kitemviews/kitemlistselectionmanager.h"
 
 #include "kitemviews/kitemmodelbase.h"
 #include "kitemviews/kitemlistselectionmanager.h"
 

+#include <QTest>
+#include <QSignalSpy>
+

 class DummyModel : public KItemModelBase
 {
 class DummyModel : public KItemModelBase
 {

+    Q_OBJECT

 public:
     DummyModel();
 public:
     DummyModel();

-    virtual int count() const;
-    virtual QHash<QByteArray, QVariant> data(int index) const;
+    void setCount(int count);
+    int count() const override;
+    QHash<QByteArray, QVariant> data(int index) const override;
+
+private:
+    int m_count;

 };
 
 DummyModel::DummyModel() :
 };
 
 DummyModel::DummyModel() :

-    KItemModelBase()
+    KItemModelBase(),
+    m_count(100)

 {
 }
 
 {
 }
 

+void DummyModel::setCount(int count)
+{
+    m_count = count;
+}
+

 int DummyModel::count() const
 {
 int DummyModel::count() const
 {

-    return 100;
+    return m_count;

 }
 
 QHash<QByteArray, QVariant> DummyModel::data(int index) const
 }
 
 QHash<QByteArray, QVariant> DummyModel::data(int index) const


@@ -48,7 +60,6 @@ QHash<QByteArray, QVariant> DummyModel::data(int index) const
 }
 
 
 }
 
 

-

 class KItemListSelectionManagerTest : public QObject
 {
     Q_OBJECT
 class KItemListSelectionManagerTest : public QObject
 {
     Q_OBJECT


@@ -67,22 +78,31 @@ private slots:
     void testAnchoredSelection();
     void testChangeSelection_data();
     void testChangeSelection();
     void testAnchoredSelection();
     void testChangeSelection_data();
     void testChangeSelection();

+    void testDeleteCurrentItem_data();
+    void testDeleteCurrentItem();
+    void testAnchoredSelectionAfterMovingItems();

 
 private:
 
 private:

+    void verifySelectionChange(QSignalSpy& spy, const KItemSet& currentSelection, const KItemSet& previousSelection) const;
+

     KItemListSelectionManager* m_selectionManager;
     KItemListSelectionManager* m_selectionManager;

+    DummyModel* m_model;

 };
 
 void KItemListSelectionManagerTest::init()
 {
 };
 
 void KItemListSelectionManagerTest::init()
 {

+    m_model = new DummyModel();

     m_selectionManager = new KItemListSelectionManager();
     m_selectionManager = new KItemListSelectionManager();

-    m_selectionManager->setModel(new DummyModel());
+    m_selectionManager->setModel(m_model);

 }
 
 void KItemListSelectionManagerTest::cleanup()
 {
 }
 
 void KItemListSelectionManagerTest::cleanup()
 {

-    delete m_selectionManager->model();

     delete m_selectionManager;
     m_selectionManager = 0;
     delete m_selectionManager;
     m_selectionManager = 0;

+
+    delete m_model;
+    m_model = 0;

 }
 
 void KItemListSelectionManagerTest::testConstructor()
 }
 
 void KItemListSelectionManagerTest::testConstructor()


@@ -110,7 +130,7 @@ void KItemListSelectionManagerTest::testCurrentItemAnchorItem()
     QCOMPARE(m_selectionManager->m_anchorItem, 5);
 
     // Items between current and anchor should be selected now
     QCOMPARE(m_selectionManager->m_anchorItem, 5);
 
     // Items between current and anchor should be selected now

-    QCOMPARE(m_selectionManager->selectedItems(), QSet<int>() << 4 << 5);
+    QCOMPARE(m_selectionManager->selectedItems(), KItemSet() << 4 << 5);

     QVERIFY(m_selectionManager->hasSelection());
 
     // Change current item again and check the selection
     QVERIFY(m_selectionManager->hasSelection());
 
     // Change current item again and check the selection


@@ -121,7 +141,7 @@ void KItemListSelectionManagerTest::testCurrentItemAnchorItem()
     QCOMPARE(qvariant_cast<int>(spyCurrent.at(0).at(1)), 4);
     spyCurrent.takeFirst();
 
     QCOMPARE(qvariant_cast<int>(spyCurrent.at(0).at(1)), 4);
     spyCurrent.takeFirst();
 

-    QCOMPARE(m_selectionManager->selectedItems(), QSet<int>() << 2 << 3 << 4 << 5);
+    QCOMPARE(m_selectionManager->selectedItems(), KItemSet() << 2 << 3 << 4 << 5);

     QVERIFY(m_selectionManager->hasSelection());
 
     // Inserting items should update current item and anchor item.
     QVERIFY(m_selectionManager->hasSelection());
 
     // Inserting items should update current item and anchor item.


@@ -138,7 +158,7 @@ void KItemListSelectionManagerTest::testCurrentItemAnchorItem()
 
     QCOMPARE(m_selectionManager->m_anchorItem, 8);
 
 
     QCOMPARE(m_selectionManager->m_anchorItem, 8);
 

-    QCOMPARE(m_selectionManager->selectedItems(), QSet<int>() << 5 << 6 << 7 << 8);
+    QCOMPARE(m_selectionManager->selectedItems(), KItemSet() << 5 << 6 << 7 << 8);

     QVERIFY(m_selectionManager->hasSelection());
 
     // Removing items should update current item and anchor item.
     QVERIFY(m_selectionManager->hasSelection());
 
     // Removing items should update current item and anchor item.


@@ -155,12 +175,12 @@ void KItemListSelectionManagerTest::testCurrentItemAnchorItem()
 
     QCOMPARE(m_selectionManager->m_anchorItem, 5);
 
 
     QCOMPARE(m_selectionManager->m_anchorItem, 5);
 

-    QCOMPARE(m_selectionManager->selectedItems(), QSet<int>() << 2 << 3 << 4 << 5);
+    QCOMPARE(m_selectionManager->selectedItems(), KItemSet() << 2 << 3 << 4 << 5);

     QVERIFY(m_selectionManager->hasSelection());
 
     // Verify that clearSelection() also clears the anchored selection.
     m_selectionManager->clearSelection();
     QVERIFY(m_selectionManager->hasSelection());
 
     // Verify that clearSelection() also clears the anchored selection.
     m_selectionManager->clearSelection();

-    QCOMPARE(m_selectionManager->selectedItems(), QSet<int>());
+    QCOMPARE(m_selectionManager->selectedItems(), KItemSet());

     QVERIFY(!m_selectionManager->hasSelection());
 
     m_selectionManager->endAnchoredSelection();
     QVERIFY(!m_selectionManager->hasSelection());
 
     m_selectionManager->endAnchoredSelection();


@@ -195,7 +215,7 @@ void KItemListSelectionManagerTest::testItemsInserted()
 {
     // Select items 10 to 12
     m_selectionManager->setSelected(10, 3);
 {
     // Select items 10 to 12
     m_selectionManager->setSelected(10, 3);

-    QSet<int> selectedItems = m_selectionManager->selectedItems();
+    KItemSet selectedItems = m_selectionManager->selectedItems();

     QCOMPARE(selectedItems.count(), 3);
     QVERIFY(selectedItems.contains(10));
     QVERIFY(selectedItems.contains(11));
     QCOMPARE(selectedItems.count(), 3);
     QVERIFY(selectedItems.contains(10));
     QVERIFY(selectedItems.contains(11));


@@ -225,7 +245,7 @@ void KItemListSelectionManagerTest::testItemsRemoved()
 {
     // Select items 10 to 15
     m_selectionManager->setSelected(10, 6);
 {
     // Select items 10 to 15
     m_selectionManager->setSelected(10, 6);

-    QSet<int> selectedItems = m_selectionManager->selectedItems();
+    KItemSet selectedItems = m_selectionManager->selectedItems();

     QCOMPARE(selectedItems.count(), 6);
     for (int i = 10; i <= 15; ++i) {
         QVERIFY(selectedItems.contains(i));
     QCOMPARE(selectedItems.count(), 6);
     for (int i = 10; i <= 15; ++i) {
         QVERIFY(selectedItems.contains(i));


@@ -259,20 +279,20 @@ void KItemListSelectionManagerTest::testAnchoredSelection()
 
     m_selectionManager->setCurrentItem(6);
     QCOMPARE(m_selectionManager->currentItem(), 6);
 
     m_selectionManager->setCurrentItem(6);
     QCOMPARE(m_selectionManager->currentItem(), 6);

-    QCOMPARE(m_selectionManager->selectedItems(), QSet<int>() << 5 << 6);
+    QCOMPARE(m_selectionManager->selectedItems(), KItemSet() << 5 << 6);

 
     m_selectionManager->setCurrentItem(4);
     QCOMPARE(m_selectionManager->currentItem(), 4);
 
     m_selectionManager->setCurrentItem(4);
     QCOMPARE(m_selectionManager->currentItem(), 4);

-    QCOMPARE(m_selectionManager->selectedItems(), QSet<int>() << 4 << 5);
+    QCOMPARE(m_selectionManager->selectedItems(), KItemSet() << 4 << 5);

 
     m_selectionManager->setCurrentItem(7);
     QCOMPARE(m_selectionManager->currentItem(), 7);
 
     m_selectionManager->setCurrentItem(7);
     QCOMPARE(m_selectionManager->currentItem(), 7);

-    QCOMPARE(m_selectionManager->selectedItems(), QSet<int>() << 5 << 6 << 7);
+    QCOMPARE(m_selectionManager->selectedItems(), KItemSet() << 5 << 6 << 7);

 
     // Ending the anchored selection should not change the selected items.
     m_selectionManager->endAnchoredSelection();
     QVERIFY(!m_selectionManager->isAnchoredSelectionActive());
 
     // Ending the anchored selection should not change the selected items.
     m_selectionManager->endAnchoredSelection();
     QVERIFY(!m_selectionManager->isAnchoredSelectionActive());

-    QCOMPARE(m_selectionManager->selectedItems(), QSet<int>() << 5 << 6 << 7);
+    QCOMPARE(m_selectionManager->selectedItems(), KItemSet() << 5 << 6 << 7);

 
     // Start a new anchored selection that overlaps the previous one
     m_selectionManager->beginAnchoredSelection(9);
 
     // Start a new anchored selection that overlaps the previous one
     m_selectionManager->beginAnchoredSelection(9);


@@ -281,15 +301,15 @@ void KItemListSelectionManagerTest::testAnchoredSelection()
 
     m_selectionManager->setCurrentItem(6);
     QCOMPARE(m_selectionManager->currentItem(), 6);
 
     m_selectionManager->setCurrentItem(6);
     QCOMPARE(m_selectionManager->currentItem(), 6);

-    QCOMPARE(m_selectionManager->selectedItems(), QSet<int>() << 5 << 6 << 7 << 8 << 9);
+    QCOMPARE(m_selectionManager->selectedItems(), KItemSet() << 5 << 6 << 7 << 8 << 9);

 
     m_selectionManager->setCurrentItem(10);
     QCOMPARE(m_selectionManager->currentItem(), 10);
 
     m_selectionManager->setCurrentItem(10);
     QCOMPARE(m_selectionManager->currentItem(), 10);

-    QCOMPARE(m_selectionManager->selectedItems(), QSet<int>() << 5 << 6 << 7 << 9 << 10);
+    QCOMPARE(m_selectionManager->selectedItems(), KItemSet() << 5 << 6 << 7 << 9 << 10);

 
     m_selectionManager->endAnchoredSelection();
     QVERIFY(!m_selectionManager->isAnchoredSelectionActive());
 
     m_selectionManager->endAnchoredSelection();
     QVERIFY(!m_selectionManager->isAnchoredSelectionActive());

-    QCOMPARE(m_selectionManager->selectedItems(), QSet<int>() << 5 << 6 << 7 << 9 << 10);
+    QCOMPARE(m_selectionManager->selectedItems(), KItemSet() << 5 << 6 << 7 << 9 << 10);

 }
 
 namespace {
 }
 
 namespace {


@@ -297,72 +317,135 @@ namespace {
         NoChange,
         InsertItems,
         RemoveItems,
         NoChange,
         InsertItems,
         RemoveItems,

+        MoveItems,

         EndAnchoredSelection,
         EndAnchoredSelection,

-        ToggleSelected
+        SetSelected

     };
 }
 
     };
 }
 

-Q_DECLARE_METATYPE(QSet<int>);
-Q_DECLARE_METATYPE(ChangeType);
-Q_DECLARE_METATYPE(KItemRangeList);
-
+Q_DECLARE_METATYPE(KItemSet)
+Q_DECLARE_METATYPE(ChangeType)
+Q_DECLARE_METATYPE(KItemRange)
+Q_DECLARE_METATYPE(KItemRangeList)
+Q_DECLARE_METATYPE(KItemListSelectionManager::SelectionMode)
+Q_DECLARE_METATYPE(QList<int>)
+
+/**
+ * The following function provides a generic way to test the selection functionality.
+ *
+ * The test is data-driven and takes the following arguments:
+ *
+ * param initialSelection  The selection at the beginning.
+ * param anchor            This item will be the anchor item.
+ * param current           This item will be the current item.
+ * param expectedSelection Expected selection after anchor and current are set.
+ * param changeType        Type of the change that is done then:
+ *                        - NoChange
+ *                        - InsertItems -> data.at(0) provides the KItemRangeList. \sa KItemListSelectionManager::itemsInserted()
+ *                        - RemoveItems -> data.at(0) provides the KItemRangeList. \sa KItemListSelectionManager::itemsRemoved()
+ *                        - MoveItems   -> data.at(0) provides the KItemRange containing the original indices,
+ *                                         data.at(1) provides the list containing the new indices
+ *                                        \sa KItemListSelectionManager::itemsMoved(), KItemModelBase::itemsMoved()
+ *                        - EndAnchoredSelection
+ *                        - SetSelected -> data.at(0) provides the index where the selection process starts,
+ *                                         data.at(1) provides the number of indices to be selected,
+ *                                         data.at(2) provides the selection mode.
+ *                                        \sa KItemListSelectionManager::setSelected()
+ * param data              A list of QVariants which will be cast to the arguments needed for the chosen ChangeType (see above).
+ * param finalSelection    The expected final selection.
+ *
+ */

 void KItemListSelectionManagerTest::testChangeSelection_data()
 {
 void KItemListSelectionManagerTest::testChangeSelection_data()
 {

-    QTest::addColumn<QSet<int> >("initialSelection");
+    QTest::addColumn<KItemSet>("initialSelection");

     QTest::addColumn<int>("anchor");
     QTest::addColumn<int>("current");
     QTest::addColumn<int>("anchor");
     QTest::addColumn<int>("current");

-    QTest::addColumn<QSet<int> >("expectedSelection");
+    QTest::addColumn<KItemSet>("expectedSelection");

     QTest::addColumn<ChangeType>("changeType");
     QTest::addColumn<ChangeType>("changeType");

-    QTest::addColumn<KItemRangeList>("changedItems");
-    QTest::addColumn<QSet<int> >("finalSelection");
+    QTest::addColumn<QList<QVariant> >("data");
+    QTest::addColumn<KItemSet>("finalSelection");

 
     QTest::newRow("No change")
 
     QTest::newRow("No change")

-        << (QSet<int>() << 5 << 6)
+        << (KItemSet() << 5 << 6)

         << 2 << 3
         << 2 << 3

-        << (QSet<int>() << 2 << 3 << 5 << 6)
-        << NoChange << KItemRangeList()
-        << (QSet<int>() << 2 << 3 << 5 << 6);
+        << (KItemSet() << 2 << 3 << 5 << 6)
+        << NoChange
+        << QList<QVariant>{}
+        << (KItemSet() << 2 << 3 << 5 << 6);

 
     QTest::newRow("Insert Items")
 
     QTest::newRow("Insert Items")

-        << (QSet<int>() << 5 << 6)
+        << (KItemSet() << 5 << 6)

         << 2 << 3
         << 2 << 3

-        << (QSet<int>() << 2 << 3 << 5 << 6)
-        << InsertItems << (KItemRangeList() << KItemRange(1, 1) << KItemRange(5, 2) << KItemRange(10, 5))
-        << (QSet<int>() << 3 << 4 << 8 << 9);
+        << (KItemSet() << 2 << 3 << 5 << 6)
+        << InsertItems
+        << QList<QVariant>{QVariant::fromValue(KItemRangeList() << KItemRange(1, 1) << KItemRange(5, 2) << KItemRange(10, 5))}
+        << (KItemSet() << 3 << 4 << 8 << 9);

 
     QTest::newRow("Remove Items")
 
     QTest::newRow("Remove Items")

-        << (QSet<int>() << 5 << 6)
+        << (KItemSet() << 5 << 6)

         << 2 << 3
         << 2 << 3

-        << (QSet<int>() << 2 << 3 << 5 << 6)
-        << RemoveItems << (KItemRangeList() << KItemRange(1, 1) << KItemRange(3, 1) << KItemRange(10, 5))
-        << (QSet<int>() << 1 << 2 << 3 << 4);
+        << (KItemSet() << 2 << 3 << 5 << 6)
+        << RemoveItems
+        << QList<QVariant>{QVariant::fromValue(KItemRangeList() << KItemRange(1, 1) << KItemRange(3, 1) << KItemRange(10, 5))}
+        << (KItemSet() << 1 << 2 << 3 << 4);

 
     QTest::newRow("Empty Anchored Selection")
 
     QTest::newRow("Empty Anchored Selection")

-        << QSet<int>()
+        << KItemSet()

         << 2 << 2
         << 2 << 2

-        << QSet<int>()
-        << EndAnchoredSelection << KItemRangeList()
-        << QSet<int>();
+        << KItemSet()
+        << EndAnchoredSelection
+        << QList<QVariant>{}
+        << KItemSet();

 
     QTest::newRow("Toggle selection")
 
     QTest::newRow("Toggle selection")

-        << (QSet<int>() << 1 << 3 << 4)
+        << (KItemSet() << 1 << 3 << 4)

         << 6 << 8
         << 6 << 8

-        << (QSet<int>() << 1 << 3 << 4 << 6 << 7 << 8)
-        << ToggleSelected << (KItemRangeList() << KItemRange(0, 10))
-        << (QSet<int>() << 0 << 2 << 5 << 9);
+        << (KItemSet() << 1 << 3 << 4 << 6 << 7 << 8)
+        << SetSelected
+        << QList<QVariant>{0, 10, QVariant::fromValue(KItemListSelectionManager::Toggle)}
+        << (KItemSet() << 0 << 2 << 5 << 9);
+
+    // Swap items 2, 3 and 4, 5
+    QTest::newRow("Move items")
+        << (KItemSet() << 0 << 1 << 2 << 3)
+        << -1 << -1
+        << (KItemSet() << 0 << 1 << 2 << 3)
+        << MoveItems
+        << QList<QVariant>{QVariant::fromValue(KItemRange(2, 4)),
+                           QVariant::fromValue(QList<int>{4, 5, 2, 3})}
+        << (KItemSet() << 0 << 1 << 4 << 5);
+
+    QTest::newRow("Move items with active anchored selection")
+        << KItemSet()
+        << 0 << 3
+        << (KItemSet() << 0 << 1 << 2 << 3)
+        << MoveItems
+        << QList<QVariant>{QVariant::fromValue(KItemRange(2, 4)),
+                           QVariant::fromValue(QList<int>{4, 5, 2, 3})}
+        << (KItemSet() << 0 << 1 << 4 << 5);
+
+    // Revert sort order
+    QTest::newRow("Revert sort order")
+        << (KItemSet() << 0 << 1)
+        << 3 << 4
+        << (KItemSet() << 0 << 1 << 3 << 4)
+        << MoveItems
+        << QList<QVariant>{QVariant::fromValue(KItemRange(0, 10)),
+                           QVariant::fromValue(QList<int>{9, 8, 7, 6, 5, 4, 3, 2, 1, 0})}
+        << (KItemSet() << 5 << 6 << 8 << 9);

 }
 
 void KItemListSelectionManagerTest::testChangeSelection()
 {
 }
 
 void KItemListSelectionManagerTest::testChangeSelection()
 {

-    QFETCH(QSet<int>, initialSelection);
+    QFETCH(KItemSet, initialSelection);

     QFETCH(int, anchor);
     QFETCH(int, current);
     QFETCH(int, anchor);
     QFETCH(int, current);

-    QFETCH(QSet<int> , expectedSelection);
+    QFETCH(KItemSet, expectedSelection);

     QFETCH(ChangeType, changeType);
     QFETCH(ChangeType, changeType);

-    QFETCH(KItemRangeList, changedItems);
-    QFETCH(QSet<int> , finalSelection);
+    QFETCH(QList<QVariant>, data);
+    QFETCH(KItemSet, finalSelection);

 
 

-    QSignalSpy spySelectionChanged(m_selectionManager, SIGNAL(selectionChanged(QSet<int>,QSet<int>)));
+    QSignalSpy spySelectionChanged(m_selectionManager, SIGNAL(selectionChanged(KItemSet,KItemSet)));

 
     // Initial selection should be empty
     QVERIFY(!m_selectionManager->hasSelection());
 
     // Initial selection should be empty
     QVERIFY(!m_selectionManager->hasSelection());


@@ -370,18 +453,8 @@ void KItemListSelectionManagerTest::testChangeSelection()
 
     // Perform the initial selectiion
     m_selectionManager->setSelectedItems(initialSelection);
 
     // Perform the initial selectiion
     m_selectionManager->setSelectedItems(initialSelection);

-    QCOMPARE(m_selectionManager->selectedItems(), initialSelection);
-    if (initialSelection.isEmpty()) {
-        QVERIFY(!m_selectionManager->hasSelection());
-        QCOMPARE(spySelectionChanged.count(), 0);
-    }
-    else {
-        QVERIFY(m_selectionManager->hasSelection());
-        QCOMPARE(spySelectionChanged.count(), 1);
-        QList<QVariant> arguments = spySelectionChanged.takeFirst();
-        QCOMPARE(qvariant_cast<QSet<int> >(arguments.at(0)), initialSelection);
-        QCOMPARE(qvariant_cast<QSet<int> >(arguments.at(1)), QSet<int>());
-    }
+
+    verifySelectionChange(spySelectionChanged, initialSelection, KItemSet());

 
     // Perform an anchored selection.
     // Note that current and anchor index are equal first because this is the case in typical uses of the
 
     // Perform an anchored selection.
     // Note that current and anchor index are equal first because this is the case in typical uses of the


@@ -391,67 +464,114 @@ void KItemListSelectionManagerTest::testChangeSelection()
     m_selectionManager->setCurrentItem(current);
     QCOMPARE(m_selectionManager->m_anchorItem, anchor);
     QCOMPARE(m_selectionManager->currentItem(), current);
     m_selectionManager->setCurrentItem(current);
     QCOMPARE(m_selectionManager->m_anchorItem, anchor);
     QCOMPARE(m_selectionManager->currentItem(), current);

-    QCOMPARE(m_selectionManager->selectedItems(), expectedSelection);
-    QCOMPARE(m_selectionManager->hasSelection(), !expectedSelection.isEmpty());
-    if (expectedSelection == initialSelection) {
-        QCOMPARE(spySelectionChanged.count(), 0);
-    }
-    else {
-        QCOMPARE(spySelectionChanged.count(), 1);
-        QList<QVariant> arguments = spySelectionChanged.takeFirst();
-        QCOMPARE(qvariant_cast<QSet<int> >(arguments.at(0)), expectedSelection);
-        QCOMPARE(qvariant_cast<QSet<int> >(arguments.at(1)), initialSelection);
-    }
+
+    verifySelectionChange(spySelectionChanged, expectedSelection, initialSelection);

 
     // Change the model by inserting or removing items.
     switch (changeType) {
     case InsertItems:
 
     // Change the model by inserting or removing items.
     switch (changeType) {
     case InsertItems:

-        m_selectionManager->itemsInserted(changedItems);
+        m_selectionManager->itemsInserted(data.at(0).value<KItemRangeList>());

         break;
     case RemoveItems:
         break;
     case RemoveItems:

-        m_selectionManager->itemsRemoved(changedItems);
+        m_selectionManager->itemsRemoved(data.at(0).value<KItemRangeList>());
+        break;
+    case MoveItems:
+        m_selectionManager->itemsMoved(data.at(0).value<KItemRange>(),
+                                       data.at(1).value<QList<int>>());

         break;
     case EndAnchoredSelection:
         m_selectionManager->endAnchoredSelection();
         QVERIFY(!m_selectionManager->isAnchoredSelectionActive());
         break;
         break;
     case EndAnchoredSelection:
         m_selectionManager->endAnchoredSelection();
         QVERIFY(!m_selectionManager->isAnchoredSelectionActive());
         break;

-    case ToggleSelected:
-        foreach(const KItemRange& range, changedItems) {
-            m_selectionManager->setSelected(range.index, range.count, KItemListSelectionManager::Toggle);
-        }
+    case SetSelected:
+        m_selectionManager->setSelected(data.at(0).value<int>(), // index
+                                        data.at(1).value<int>(), // count
+                                        data.at(2).value<KItemListSelectionManager::SelectionMode>());

         break;
     case NoChange:
         break;
     }
 
         break;
     case NoChange:
         break;
     }
 

-    QCOMPARE(m_selectionManager->selectedItems(), finalSelection);
-    QCOMPARE(m_selectionManager->hasSelection(), !finalSelection.isEmpty());
-    if (finalSelection == expectedSelection) {
-        QCOMPARE(spySelectionChanged.count(), 0);
-    }
-    else {
-        QCOMPARE(spySelectionChanged.count(), 1);
-        QList<QVariant> arguments = spySelectionChanged.takeFirst();
-        QCOMPARE(qvariant_cast<QSet<int> >(arguments.at(0)), finalSelection);
-        QCOMPARE(qvariant_cast<QSet<int> >(arguments.at(1)), expectedSelection);
-    }
+    verifySelectionChange(spySelectionChanged, finalSelection, expectedSelection);

 
     // Finally, clear the selection
     m_selectionManager->clearSelection();
 
     // Finally, clear the selection
     m_selectionManager->clearSelection();

-    QCOMPARE(m_selectionManager->selectedItems(), QSet<int>());
-    QVERIFY(!m_selectionManager->hasSelection());
-    if (finalSelection.isEmpty()) {
-        // Selection has been empty already
-        QCOMPARE(spySelectionChanged.count(), 0);
+
+    verifySelectionChange(spySelectionChanged, KItemSet(), finalSelection);
+}
+
+void KItemListSelectionManagerTest::testDeleteCurrentItem_data()
+{
+    QTest::addColumn<int>("oldCurrentItemIndex");
+    QTest::addColumn<int>("removeIndex");
+    QTest::addColumn<int>("removeCount");
+    QTest::addColumn<int>("newCurrentItemIndex");
+
+    QTest::newRow("Remove before")               << 50 <<  0 << 10 << 40;
+    QTest::newRow("Remove after")                << 50 << 51 << 10 << 50;
+    QTest::newRow("Remove exactly current item") << 50 << 50 <<  1 << 50;
+    QTest::newRow("Remove around current item")  << 50 << 45 << 10 << 45;
+    QTest::newRow("Remove all except one item")  << 50 <<  1 << 99 <<  0;
+}
+
+void KItemListSelectionManagerTest::testDeleteCurrentItem()
+{
+    QFETCH(int, oldCurrentItemIndex);
+    QFETCH(int, removeIndex);
+    QFETCH(int, removeCount);
+    QFETCH(int, newCurrentItemIndex);
+
+    m_selectionManager->setCurrentItem(oldCurrentItemIndex);
+
+    const int newCount = m_model->count() - removeCount;
+    m_model->setCount(newCount);
+    m_selectionManager->itemsRemoved(KItemRangeList() << KItemRange(removeIndex, removeCount));
+
+    QCOMPARE(m_selectionManager->currentItem(), newCurrentItemIndex);
+}
+
+void KItemListSelectionManagerTest::testAnchoredSelectionAfterMovingItems()
+{
+    m_selectionManager->setCurrentItem(4);
+    m_selectionManager->beginAnchoredSelection(4);
+
+    // Reverse the items between 0 and 5.
+    m_selectionManager->itemsMoved(KItemRange(0, 6), {5, 4, 3, 2, 1, 0});
+
+    QCOMPARE(m_selectionManager->currentItem(), 1);
+    QCOMPARE(m_selectionManager->m_anchorItem, 1);
+
+    // Make 2 the current item -> 1 and 2 should be selected.
+    m_selectionManager->setCurrentItem(2);
+    QCOMPARE(m_selectionManager->selectedItems(), KItemSet() << 1 << 2);
+}
+
+void KItemListSelectionManagerTest::verifySelectionChange(QSignalSpy& spy,
+                                                          const KItemSet& currentSelection,
+                                                          const KItemSet& previousSelection) const
+{
+    QCOMPARE(m_selectionManager->selectedItems(), currentSelection);
+    QCOMPARE(m_selectionManager->hasSelection(), !currentSelection.isEmpty());
+    for (int index = 0; index < m_selectionManager->model()->count(); ++index) {
+        if (currentSelection.contains(index)) {
+            QVERIFY(m_selectionManager->isSelected(index));
+        }
+        else {
+            QVERIFY(!m_selectionManager->isSelected(index));
+        }
+    }
+
+    if (currentSelection == previousSelection) {
+        QCOMPARE(spy.count(), 0);

     }
     else {
     }
     else {

-        QCOMPARE(spySelectionChanged.count(), 1);
-        QList<QVariant> arguments = spySelectionChanged.takeFirst();
-        QCOMPARE(qvariant_cast<QSet<int> >(arguments.at(0)), QSet<int>());
-        QCOMPARE(qvariant_cast<QSet<int> >(arguments.at(1)), finalSelection);
+        QCOMPARE(spy.count(), 1);
+        QList<QVariant> arguments = spy.takeFirst();
+        QCOMPARE(qvariant_cast<KItemSet>(arguments.at(0)), currentSelection);
+        QCOMPARE(qvariant_cast<KItemSet>(arguments.at(1)), previousSelection);

     }
 }
 
     }
 }
 

-QTEST_KDEMAIN(KItemListSelectionManagerTest, NoGUI)
+QTEST_GUILESS_MAIN(KItemListSelectionManagerTest)

 
 #include "kitemlistselectionmanagertest.moc"
 
 #include "kitemlistselectionmanagertest.moc"