{
public:
DummyModel();
+ void setCount(int count);
virtual int count() const;
virtual QHash<QByteArray, QVariant> data(int index) const;
+
+private:
+ int m_count;
};
DummyModel::DummyModel() :
- KItemModelBase()
+ KItemModelBase(),
+ m_count(100)
+{
+}
+
+void DummyModel::setCount(int count)
{
+ m_count = count;
}
int DummyModel::count() const
{
- return 100;
+ return m_count;
}
QHash<QByteArray, QVariant> DummyModel::data(int index) const
}
-
class KItemListSelectionManagerTest : public QObject
{
Q_OBJECT
void testAnchoredSelection();
void testChangeSelection_data();
void testChangeSelection();
+ void testDeleteCurrentItem_data();
+ void testDeleteCurrentItem();
private:
+ void verifySelectionChange(QSignalSpy& spy, const QSet<int>& currentSelection, const QSet<int>& previousSelection) const;
+
KItemListSelectionManager* m_selectionManager;
+ DummyModel* m_model;
};
void KItemListSelectionManagerTest::init()
{
+ m_model = new DummyModel();
m_selectionManager = new KItemListSelectionManager();
- m_selectionManager->setModel(new DummyModel());
+ m_selectionManager->setModel(m_model);
}
void KItemListSelectionManagerTest::cleanup()
{
- delete m_selectionManager->model();
delete m_selectionManager;
m_selectionManager = 0;
+
+ delete m_model;
+ m_model = 0;
}
void KItemListSelectionManagerTest::testConstructor()
QVERIFY(!m_selectionManager->hasSelection());
QCOMPARE(m_selectionManager->selectedItems().count(), 0);
QCOMPARE(m_selectionManager->currentItem(), 0);
- QCOMPARE(m_selectionManager->anchorItem(), -1);
+ QCOMPARE(m_selectionManager->m_anchorItem, -1);
}
void KItemListSelectionManagerTest::testCurrentItemAnchorItem()
// Begin an anchored selection.
m_selectionManager->beginAnchoredSelection(5);
QVERIFY(m_selectionManager->isAnchoredSelectionActive());
- QCOMPARE(m_selectionManager->anchorItem(), 5);
+ QCOMPARE(m_selectionManager->m_anchorItem, 5);
// Items between current and anchor should be selected now
QCOMPARE(m_selectionManager->selectedItems(), QSet<int>() << 4 << 5);
QCOMPARE(qvariant_cast<int>(spyCurrent.at(0).at(1)), 2);
spyCurrent.takeFirst();
- QCOMPARE(m_selectionManager->anchorItem(), 8);
+ QCOMPARE(m_selectionManager->m_anchorItem, 8);
QCOMPARE(m_selectionManager->selectedItems(), QSet<int>() << 5 << 6 << 7 << 8);
QVERIFY(m_selectionManager->hasSelection());
QCOMPARE(qvariant_cast<int>(spyCurrent.at(0).at(1)), 5);
spyCurrent.takeFirst();
- QCOMPARE(m_selectionManager->anchorItem(), 5);
+ QCOMPARE(m_selectionManager->m_anchorItem, 5);
QCOMPARE(m_selectionManager->selectedItems(), QSet<int>() << 2 << 3 << 4 << 5);
QVERIFY(m_selectionManager->hasSelection());
{
m_selectionManager->beginAnchoredSelection(5);
QVERIFY(m_selectionManager->isAnchoredSelectionActive());
- QCOMPARE(m_selectionManager->anchorItem(), 5);
+ QCOMPARE(m_selectionManager->m_anchorItem, 5);
m_selectionManager->setCurrentItem(6);
QCOMPARE(m_selectionManager->currentItem(), 6);
// Start a new anchored selection that overlaps the previous one
m_selectionManager->beginAnchoredSelection(9);
QVERIFY(m_selectionManager->isAnchoredSelectionActive());
- QCOMPARE(m_selectionManager->anchorItem(), 9);
+ QCOMPARE(m_selectionManager->m_anchorItem, 9);
m_selectionManager->setCurrentItem(6);
QCOMPARE(m_selectionManager->currentItem(), 6);
NoChange,
InsertItems,
RemoveItems,
+ MoveItems,
EndAnchoredSelection,
- ToggleSelected
+ SetSelected
};
}
Q_DECLARE_METATYPE(QSet<int>);
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()
{
QTest::addColumn<int>("current");
QTest::addColumn<QSet<int> >("expectedSelection");
QTest::addColumn<ChangeType>("changeType");
- QTest::addColumn<KItemRangeList>("changedItems");
+ QTest::addColumn<QList<QVariant> >("data");
QTest::addColumn<QSet<int> >("finalSelection");
QTest::newRow("No change")
<< (QSet<int>() << 5 << 6)
<< 2 << 3
<< (QSet<int>() << 2 << 3 << 5 << 6)
- << NoChange << KItemRangeList()
+ << NoChange
+ << QList<QVariant>()
<< (QSet<int>() << 2 << 3 << 5 << 6);
QTest::newRow("Insert Items")
<< (QSet<int>() << 5 << 6)
<< 2 << 3
<< (QSet<int>() << 2 << 3 << 5 << 6)
- << InsertItems << (KItemRangeList() << KItemRange(1, 1) << KItemRange(5, 2) << KItemRange(10, 5))
+ << InsertItems
+ << (QList<QVariant>() << QVariant::fromValue(KItemRangeList() << KItemRange(1, 1) << KItemRange(5, 2) << KItemRange(10, 5)))
<< (QSet<int>() << 3 << 4 << 8 << 9);
QTest::newRow("Remove Items")
<< (QSet<int>() << 5 << 6)
<< 2 << 3
<< (QSet<int>() << 2 << 3 << 5 << 6)
- << RemoveItems << (KItemRangeList() << KItemRange(1, 1) << KItemRange(3, 1) << KItemRange(10, 5))
+ << RemoveItems
+ << (QList<QVariant>() << QVariant::fromValue(KItemRangeList() << KItemRange(1, 1) << KItemRange(3, 1) << KItemRange(10, 5)))
<< (QSet<int>() << 1 << 2 << 3 << 4);
QTest::newRow("Empty Anchored Selection")
<< QSet<int>()
<< 2 << 2
<< QSet<int>()
- << EndAnchoredSelection << KItemRangeList()
+ << EndAnchoredSelection
+ << QList<QVariant>()
<< QSet<int>();
QTest::newRow("Toggle selection")
<< (QSet<int>() << 1 << 3 << 4)
<< 6 << 8
<< (QSet<int>() << 1 << 3 << 4 << 6 << 7 << 8)
- << ToggleSelected << (KItemRangeList() << KItemRange(0, 10))
+ << SetSelected
+ << (QList<QVariant>() << 0 << 10 << QVariant::fromValue(KItemListSelectionManager::Toggle))
<< (QSet<int>() << 0 << 2 << 5 << 9);
+
+ // Swap items 2, 3 and 4, 5
+ QTest::newRow("Move items")
+ << (QSet<int>() << 0 << 1 << 2 << 3)
+ << -1 << -1
+ << (QSet<int>() << 0 << 1 << 2 << 3)
+ << MoveItems
+ << (QList<QVariant>() << QVariant::fromValue(KItemRange(2, 4))
+ << QVariant::fromValue(QList<int>() << 4 << 5 << 2 << 3))
+ << (QSet<int>() << 0 << 1 << 4 << 5);
+
+ // Revert sort order
+ QTest::newRow("Revert sort order")
+ << (QSet<int>() << 0 << 1)
+ << 3 << 4
+ << (QSet<int>() << 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))
+ << (QSet<int>() << 5 << 6 << 8 << 9);
}
void KItemListSelectionManagerTest::testChangeSelection()
QFETCH(QSet<int>, initialSelection);
QFETCH(int, anchor);
QFETCH(int, current);
- QFETCH(QSet<int> , expectedSelection);
+ QFETCH(QSet<int>, expectedSelection);
QFETCH(ChangeType, changeType);
- QFETCH(KItemRangeList, changedItems);
- QFETCH(QSet<int> , finalSelection);
+ QFETCH(QList<QVariant>, data);
+ QFETCH(QSet<int>, finalSelection);
QSignalSpy spySelectionChanged(m_selectionManager, SIGNAL(selectionChanged(QSet<int>,QSet<int>)));
// 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, QSet<int>());
// Perform an anchored selection.
// Note that current and anchor index are equal first because this is the case in typical uses of the
m_selectionManager->setCurrentItem(anchor);
m_selectionManager->beginAnchoredSelection(anchor);
m_selectionManager->setCurrentItem(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);
- }
+ QCOMPARE(m_selectionManager->m_anchorItem, anchor);
+ QCOMPARE(m_selectionManager->currentItem(), current);
+
+ verifySelectionChange(spySelectionChanged, expectedSelection, initialSelection);
// 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:
- 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;
- 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;
}
- 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();
- QCOMPARE(m_selectionManager->selectedItems(), QSet<int>());
- QVERIFY(!m_selectionManager->hasSelection());
- if (finalSelection.isEmpty()) {
- // Selection has been empty already
- QCOMPARE(spySelectionChanged.count(), 0);
+
+ verifySelectionChange(spySelectionChanged, QSet<int>(), 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::verifySelectionChange(QSignalSpy& spy,
+ const QSet<int>& currentSelection,
+ const QSet<int>& 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 {
- 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<QSet<int> >(arguments.at(0)), currentSelection);
+ QCOMPARE(qvariant_cast<QSet<int> >(arguments.at(1)), previousSelection);
}
}
projects / dolphin.git / blobdiff