src/tests/kfileitemmodeltest.cpp

   1 /*
   2  * SPDX-FileCopyrightText: 2011 Peter Penz <peter.penz19@gmail.com>
   3  * SPDX-FileCopyrightText: 2011 Frank Reininghaus <frank78ac@googlemail.com>
   4  *
   5  * SPDX-License-Identifier: GPL-2.0-or-later
   6  */
   7
   8 #include <QMimeData>
   9 #include <QRandomGenerator>
  10 #include <QSignalSpy>
  11 #include <QStandardPaths>
  12 #include <QTest>
  13 #include <QTimer>
  14
  15 #include <KDirLister>
  16 #include <KIO/SimpleJob>
  17
  18 #include "kitemviews/kfileitemmodel.h"
  19 #include "testdir.h"
  20
  21 void myMessageOutput(QtMsgType type, const QMessageLogContext &context, const QString &msg)
  22 {
  23     Q_UNUSED(context)
  24
  25     switch (type) {
  26     case QtDebugMsg:
  27         break;
  28     case QtWarningMsg:
  29         break;
  30     case QtCriticalMsg:
  31         fprintf(stderr, "Critical: %s\n", msg.toLocal8Bit().data());
  32         break;
  33     case QtFatalMsg:
  34         fprintf(stderr, "Fatal: %s\n", msg.toLocal8Bit().data());
  35         abort();
  36     default:
  37         break;
  38     }
  39 }
  40
  41 Q_DECLARE_METATYPE(KItemRange)
  42 Q_DECLARE_METATYPE(KItemRangeList)
  43 Q_DECLARE_METATYPE(QList<int>)
  44
  45 class KFileItemModelTest : public QObject
  46 {
  47     Q_OBJECT
  48
  49 private Q_SLOTS:
  50     void init();
  51     void initTestCase();
  52     void cleanup();
  53
  54     void testDefaultRoles();
  55     void testDefaultSortRole();
  56     void testDefaultGroupedSorting();
  57     void testNewItems();
  58     void testRemoveItems();
  59     void testDirLoadingCompleted();
  60     void testSetData();
  61     void testSetDataWithModifiedSortRole_data();
  62     void testSetDataWithModifiedSortRole();
  63     void testChangeSortRole();
  64     void testResortAfterChangingName();
  65     void testModelConsistencyWhenInsertingItems();
  66     void testItemRangeConsistencyWhenInsertingItems();
  67     void testExpandItems();
  68     void testExpandParentItems();
  69     void testMakeExpandedItemHidden();
  70     void testRemoveFilteredExpandedItems();
  71     void testSorting();
  72     void testNaturalSorting();
  73     void testIndexForKeyboardSearch();
  74     void testNameFilter();
  75     void testEmptyPath();
  76     void testRefreshExpandedItem();
  77     void testAddItemToFilteredExpandedFolder();
  78     void testDeleteItemsWithExpandedFolderWithFilter();
  79     void testRefreshItemsWithFilter();
  80     void testRefreshExpandedFolderWithFilter();
  81     void testRemoveHiddenItems();
  82     void collapseParentOfHiddenItems();
  83     void removeParentOfHiddenItems();
  84     void testGeneralParentChildRelationships();
  85     void testNameRoleGroups();
  86     void testNameRoleGroupsWithExpandedItems();
  87     void testInconsistentModel();
  88     void testChangeRolesForFilteredItems();
  89     void testChangeSortRoleWhileFiltering();
  90     void testRefreshFilteredItems();
  91     void testCollapseFolderWhileLoading();
  92     void testCreateMimeData();
  93     void testDeleteFileMoreThanOnce();
  94     void testInsertAfterExpand();
  95     void testCurrentDirRemoved();
  96     void testSizeSortingAfterRefresh();
  97
  98 private:
  99     QStringList itemsInModel() const;
 100
 101 private:
 102     KFileItemModel *m_model;
 103     TestDir *m_testDir;
 104 };
 105
 106 void KFileItemModelTest::initTestCase()
 107 {
 108     QStandardPaths::setTestModeEnabled(true);
 109 }
 110
 111 void KFileItemModelTest::init()
 112 {
 113     // The item-model tests result in a huge number of debugging
 114     // output from kdelibs. Only show critical and fatal messages.
 115     qInstallMessageHandler(myMessageOutput);
 116
 117     qRegisterMetaType<KItemRange>("KItemRange");
 118     qRegisterMetaType<KItemRangeList>("KItemRangeList");
 119     qRegisterMetaType<KFileItemList>("KFileItemList");
 120
 121     m_testDir = new TestDir();
 122     m_model = new KFileItemModel();
 123     m_model->m_dirLister->setAutoUpdate(false);
 124
 125     // Reduce the timer interval to make the test run faster.
 126     m_model->m_resortAllItemsTimer->setInterval(0);
 127 }
 128
 129 void KFileItemModelTest::cleanup()
 130 {
 131     delete m_model;
 132     m_model = nullptr;
 133
 134     delete m_testDir;
 135     m_testDir = nullptr;
 136 }
 137
 138 void KFileItemModelTest::testDefaultRoles()
 139 {
 140     const QSet<QByteArray> roles = m_model->roles();
 141     QCOMPARE(roles.count(), 4);
 142     QVERIFY(roles.contains("text"));
 143     QVERIFY(roles.contains("isDir"));
 144     QVERIFY(roles.contains("isLink"));
 145     QVERIFY(roles.contains("isHidden"));
 146 }
 147
 148 void KFileItemModelTest::testDefaultSortRole()
 149 {
 150     QSignalSpy itemsInsertedSpy(m_model, &KFileItemModel::itemsInserted);
 151     QVERIFY(itemsInsertedSpy.isValid());
 152
 153     QCOMPARE(m_model->sortRole(), QByteArray("text"));
 154
 155     m_testDir->createFiles({"c.txt", "a.txt", "b.txt"});
 156
 157     m_model->loadDirectory(m_testDir->url());
 158     QVERIFY(itemsInsertedSpy.wait());
 159
 160     QCOMPARE(m_model->count(), 3);
 161     QCOMPARE(m_model->data(0).value("text").toString(), QStringLiteral("a.txt"));
 162     QCOMPARE(m_model->data(1).value("text").toString(), QStringLiteral("b.txt"));
 163     QCOMPARE(m_model->data(2).value("text").toString(), QStringLiteral("c.txt"));
 164 }
 165
 166 void KFileItemModelTest::testDefaultGroupedSorting()
 167 {
 168     QCOMPARE(m_model->groupedSorting(), false);
 169 }
 170
 171 void KFileItemModelTest::testNewItems()
 172 {
 173     QSignalSpy itemsInsertedSpy(m_model, &KFileItemModel::itemsInserted);
 174
 175     m_testDir->createFiles({"a.txt", "b.txt", "c.txt"});
 176
 177     m_model->loadDirectory(m_testDir->url());
 178     QVERIFY(itemsInsertedSpy.wait());
 179
 180     QCOMPARE(m_model->count(), 3);
 181
 182     QVERIFY(m_model->isConsistent());
 183 }
 184
 185 void KFileItemModelTest::testRemoveItems()
 186 {
 187     QSignalSpy itemsInsertedSpy(m_model, &KFileItemModel::itemsInserted);
 188     QSignalSpy itemsRemovedSpy(m_model, &KFileItemModel::itemsRemoved);
 189
 190     m_testDir->createFiles({"a.txt", "b.txt"});
 191     m_model->loadDirectory(m_testDir->url());
 192     QVERIFY(itemsInsertedSpy.wait());
 193     QCOMPARE(m_model->count(), 2);
 194     QVERIFY(m_model->isConsistent());
 195
 196     m_testDir->removeFile("a.txt");
 197     m_model->m_dirLister->updateDirectory(m_testDir->url());
 198     QVERIFY(itemsRemovedSpy.wait());
 199     QCOMPARE(m_model->count(), 1);
 200     QVERIFY(m_model->isConsistent());
 201 }
 202
 203 void KFileItemModelTest::testDirLoadingCompleted()
 204 {
 205     QSignalSpy loadingCompletedSpy(m_model, &KFileItemModel::directoryLoadingCompleted);
 206     QSignalSpy itemsInsertedSpy(m_model, &KFileItemModel::itemsInserted);
 207     QSignalSpy itemsRemovedSpy(m_model, &KFileItemModel::itemsRemoved);
 208
 209     m_testDir->createFiles({"a.txt", "b.txt", "c.txt"});
 210
 211     m_model->loadDirectory(m_testDir->url());
 212     QVERIFY(loadingCompletedSpy.wait());
 213     QCOMPARE(loadingCompletedSpy.count(), 1);
 214     QCOMPARE(itemsInsertedSpy.count(), 1);
 215     QCOMPARE(itemsRemovedSpy.count(), 0);
 216     QCOMPARE(m_model->count(), 3);
 217
 218     m_testDir->createFiles({"d.txt", "e.txt"});
 219     m_model->m_dirLister->updateDirectory(m_testDir->url());
 220     QVERIFY(loadingCompletedSpy.wait());
 221     QCOMPARE(loadingCompletedSpy.count(), 2);
 222     QCOMPARE(itemsInsertedSpy.count(), 2);
 223     QCOMPARE(itemsRemovedSpy.count(), 0);
 224     QCOMPARE(m_model->count(), 5);
 225
 226     m_testDir->removeFile("a.txt");
 227     m_testDir->createFile("f.txt");
 228     m_model->m_dirLister->updateDirectory(m_testDir->url());
 229     QVERIFY(loadingCompletedSpy.wait());
 230     QCOMPARE(loadingCompletedSpy.count(), 3);
 231     QCOMPARE(itemsInsertedSpy.count(), 3);
 232     QCOMPARE(itemsRemovedSpy.count(), 1);
 233     QCOMPARE(m_model->count(), 5);
 234
 235     m_testDir->removeFile("b.txt");
 236     m_model->m_dirLister->updateDirectory(m_testDir->url());
 237     QVERIFY(itemsRemovedSpy.wait());
 238     QCOMPARE(loadingCompletedSpy.count(), 4);
 239     QCOMPARE(itemsInsertedSpy.count(), 3);
 240     QCOMPARE(itemsRemovedSpy.count(), 2);
 241     QCOMPARE(m_model->count(), 4);
 242
 243     QVERIFY(m_model->isConsistent());
 244 }
 245
 246 void KFileItemModelTest::testSetData()
 247 {
 248     QSignalSpy itemsInsertedSpy(m_model, &KFileItemModel::itemsInserted);
 249     QVERIFY(itemsInsertedSpy.isValid());
 250     QSignalSpy itemsChangedSpy(m_model, &KFileItemModel::itemsChanged);
 251     QVERIFY(itemsChangedSpy.isValid());
 252
 253     m_testDir->createFile("a.txt");
 254
 255     m_model->loadDirectory(m_testDir->url());
 256     QVERIFY(itemsInsertedSpy.wait());
 257
 258     QHash<QByteArray, QVariant> values;
 259     values.insert("customRole1", "Test1");
 260     values.insert("customRole2", "Test2");
 261
 262     m_model->setData(0, values);
 263     QCOMPARE(itemsChangedSpy.count(), 1);
 264
 265     values = m_model->data(0);
 266     QCOMPARE(values.value("customRole1").toString(), QStringLiteral("Test1"));
 267     QCOMPARE(values.value("customRole2").toString(), QStringLiteral("Test2"));
 268     QVERIFY(m_model->isConsistent());
 269 }
 270
 271 void KFileItemModelTest::testSetDataWithModifiedSortRole_data()
 272 {
 273     QTest::addColumn<int>("changedIndex");
 274     QTest::addColumn<int>("changedRating");
 275     QTest::addColumn<bool>("expectMoveSignal");
 276     QTest::addColumn<int>("ratingIndex0");
 277     QTest::addColumn<int>("ratingIndex1");
 278     QTest::addColumn<int>("ratingIndex2");
 279
 280     // Default setup:
 281     // Index 0 = rating 2
 282     // Index 1 = rating 4
 283     // Index 2 = rating 6
 284
 285     QTest::newRow("Index 0: Rating 3") << 0 << 3 << false << 3 << 4 << 6;
 286     QTest::newRow("Index 0: Rating 5") << 0 << 5 << true << 4 << 5 << 6;
 287     QTest::newRow("Index 0: Rating 8") << 0 << 8 << true << 4 << 6 << 8;
 288
 289     QTest::newRow("Index 2: Rating 1") << 2 << 1 << true << 1 << 2 << 4;
 290     QTest::newRow("Index 2: Rating 3") << 2 << 3 << true << 2 << 3 << 4;
 291     QTest::newRow("Index 2: Rating 5") << 2 << 5 << false << 2 << 4 << 5;
 292 }
 293
 294 void KFileItemModelTest::testSetDataWithModifiedSortRole()
 295 {
 296     QFETCH(int, changedIndex);
 297     QFETCH(int, changedRating);
 298     QFETCH(bool, expectMoveSignal);
 299     QFETCH(int, ratingIndex0);
 300     QFETCH(int, ratingIndex1);
 301     QFETCH(int, ratingIndex2);
 302
 303     QSignalSpy itemsInsertedSpy(m_model, &KFileItemModel::itemsInserted);
 304     QVERIFY(itemsInsertedSpy.isValid());
 305     QSignalSpy itemsMovedSpy(m_model, &KFileItemModel::itemsMoved);
 306     QVERIFY(itemsMovedSpy.isValid());
 307
 308     // Changing the value of a sort-role must result in
 309     // a reordering of the items.
 310     QCOMPARE(m_model->sortRole(), QByteArray("text"));
 311     m_model->setSortRole("rating");
 312     QCOMPARE(m_model->sortRole(), QByteArray("rating"));
 313
 314     m_testDir->createFiles({"a.txt", "b.txt", "c.txt"});
 315
 316     m_model->loadDirectory(m_testDir->url());
 317     QVERIFY(itemsInsertedSpy.wait());
 318
 319     // Fill the "rating" role of each file:
 320     // a.txt -> 2
 321     // b.txt -> 4
 322     // c.txt -> 6
 323
 324     QHash<QByteArray, QVariant> ratingA;
 325     ratingA.insert("rating", 2);
 326     m_model->setData(0, ratingA);
 327
 328     QHash<QByteArray, QVariant> ratingB;
 329     ratingB.insert("rating", 4);
 330     m_model->setData(1, ratingB);
 331
 332     QHash<QByteArray, QVariant> ratingC;
 333     ratingC.insert("rating", 6);
 334     m_model->setData(2, ratingC);
 335
 336     QCOMPARE(m_model->data(0).value("rating").toInt(), 2);
 337     QCOMPARE(m_model->data(1).value("rating").toInt(), 4);
 338     QCOMPARE(m_model->data(2).value("rating").toInt(), 6);
 339
 340     // Now change the rating from a.txt. This usually results
 341     // in reordering of the items.
 342     QHash<QByteArray, QVariant> rating;
 343     rating.insert("rating", changedRating);
 344     m_model->setData(changedIndex, rating);
 345
 346     if (expectMoveSignal) {
 347         QVERIFY(itemsMovedSpy.wait());
 348     }
 349
 350     QCOMPARE(m_model->data(0).value("rating").toInt(), ratingIndex0);
 351     QCOMPARE(m_model->data(1).value("rating").toInt(), ratingIndex1);
 352     QCOMPARE(m_model->data(2).value("rating").toInt(), ratingIndex2);
 353     QVERIFY(m_model->isConsistent());
 354 }
 355
 356 void KFileItemModelTest::testChangeSortRole()
 357 {
 358     QSignalSpy itemsInsertedSpy(m_model, &KFileItemModel::itemsInserted);
 359     QSignalSpy itemsMovedSpy(m_model, &KFileItemModel::itemsMoved);
 360     QVERIFY(itemsMovedSpy.isValid());
 361
 362     QCOMPARE(m_model->sortRole(), QByteArray("text"));
 363
 364     m_testDir->createFiles({"a.txt", "b.jpg", "c.txt"});
 365
 366     m_model->loadDirectory(m_testDir->url());
 367     QVERIFY(itemsInsertedSpy.wait());
 368     QCOMPARE(itemsInModel(),
 369              QStringList() << "a.txt"
 370                            << "b.jpg"
 371                            << "c.txt");
 372
 373     // Simulate that KFileItemModelRolesUpdater determines the mime type.
 374     // Resorting the files by 'type' will only work immediately if their
 375     // mime types are known.
 376     for (int index = 0; index < m_model->count(); ++index) {
 377         m_model->fileItem(index).determineMimeType();
 378     }
 379
 380     // Now: sort by type.
 381     m_model->setSortRole("type");
 382     QCOMPARE(m_model->sortRole(), QByteArray("type"));
 383     QVERIFY(!itemsMovedSpy.isEmpty());
 384
 385     // The actual order of the files might depend on the translation of the
 386     // result of KFileItem::mimeComment() in the user's language.
 387     QStringList version1;
 388     version1 << "b.jpg"
 389              << "a.txt"
 390              << "c.txt";
 391
 392     QStringList version2;
 393     version2 << "a.txt"
 394              << "c.txt"
 395              << "b.jpg";
 396
 397     const bool ok1 = (itemsInModel() == version1);
 398     const bool ok2 = (itemsInModel() == version2);
 399
 400     QVERIFY(ok1 || ok2);
 401 }
 402
 403 void KFileItemModelTest::testResortAfterChangingName()
 404 {
 405     QSignalSpy itemsInsertedSpy(m_model, &KFileItemModel::itemsInserted);
 406     QSignalSpy itemsMovedSpy(m_model, &KFileItemModel::itemsMoved);
 407     QVERIFY(itemsMovedSpy.isValid());
 408
 409     // We sort by size in a directory where all files have the same size.
 410     // Therefore, the files are sorted by their names.
 411     m_model->setSortRole("size");
 412
 413     m_testDir->createFiles({"a.txt", "b.txt", "c.txt"});
 414
 415     m_model->loadDirectory(m_testDir->url());
 416     QVERIFY(itemsInsertedSpy.wait());
 417     QCOMPARE(itemsInModel(),
 418              QStringList() << "a.txt"
 419                            << "b.txt"
 420                            << "c.txt");
 421
 422     // We rename a.txt to d.txt. Even though the size has not changed at all,
 423     // the model must re-sort the items.
 424     QHash<QByteArray, QVariant> data;
 425     data.insert("text", "d.txt");
 426     m_model->setData(0, data);
 427
 428     QVERIFY(itemsMovedSpy.wait());
 429     QCOMPARE(itemsInModel(),
 430              QStringList() << "b.txt"
 431                            << "c.txt"
 432                            << "d.txt");
 433
 434     // We rename d.txt back to a.txt using the dir lister's refreshItems() signal.
 435     const KFileItem fileItemD = m_model->fileItem(2);
 436     KFileItem fileItemA = fileItemD;
 437     QUrl urlA = fileItemA.url().adjusted(QUrl::RemoveFilename);
 438     urlA.setPath(urlA.path() + "a.txt");
 439     fileItemA.setUrl(urlA);
 440
 441     m_model->slotRefreshItems({qMakePair(fileItemD, fileItemA)});
 442
 443     QVERIFY(itemsMovedSpy.wait());
 444     QCOMPARE(itemsInModel(),
 445              QStringList() << "a.txt"
 446                            << "b.txt"
 447                            << "c.txt");
 448 }
 449
 450 void KFileItemModelTest::testModelConsistencyWhenInsertingItems()
 451 {
 452     QSignalSpy itemsInsertedSpy(m_model, &KFileItemModel::itemsInserted);
 453
 454     // KFileItemModel prevents that inserting a punch of items sequentially
 455     // results in an itemsInserted()-signal for each item. Instead internally
 456     // a timeout is given that collects such operations and results in only
 457     // one itemsInserted()-signal. However in this test we want to stress
 458     // KFileItemModel to do a lot of insert operation and hence decrease
 459     // the timeout to 1 millisecond.
 460     m_testDir->createFile("1");
 461     m_model->loadDirectory(m_testDir->url());
 462     QVERIFY(itemsInsertedSpy.wait());
 463     QCOMPARE(m_model->count(), 1);
 464
 465     // Insert 10 items for 20 times. After each insert operation the model consistency
 466     // is checked.
 467     QSet<int> insertedItems;
 468     for (int i = 0; i < 20; ++i) {
 469         itemsInsertedSpy.clear();
 470
 471         for (int j = 0; j < 10; ++j) {
 472             int itemName = QRandomGenerator::global()->generate();
 473             while (insertedItems.contains(itemName)) {
 474                 itemName = QRandomGenerator::global()->generate();
 475             }
 476             insertedItems.insert(itemName);
 477
 478             m_testDir->createFile(QString::number(itemName));
 479         }
 480
 481         m_model->m_dirLister->updateDirectory(m_testDir->url());
 482         if (itemsInsertedSpy.isEmpty()) {
 483             QVERIFY(itemsInsertedSpy.wait());
 484         }
 485
 486         QVERIFY(m_model->isConsistent());
 487     }
 488
 489     QCOMPARE(m_model->count(), 201);
 490 }
 491
 492 void KFileItemModelTest::testItemRangeConsistencyWhenInsertingItems()
 493 {
 494     QSignalSpy itemsInsertedSpy(m_model, &KFileItemModel::itemsInserted);
 495
 496     m_testDir->createFiles({"B", "E", "G"});
 497
 498     // Due to inserting the 3 items one item-range with index == 0 and
 499     // count == 3 must be given
 500     m_model->loadDirectory(m_testDir->url());
 501     QVERIFY(itemsInsertedSpy.wait());
 502
 503     QCOMPARE(itemsInsertedSpy.count(), 1);
 504     QList<QVariant> arguments = itemsInsertedSpy.takeFirst();
 505     KItemRangeList itemRangeList = arguments.at(0).value<KItemRangeList>();
 506     QCOMPARE(itemRangeList, KItemRangeList() << KItemRange(0, 3));
 507
 508     // The indexes of the item-ranges must always be related to the model before
 509     // the items have been inserted. Having:
 510     //   0 1 2
 511     //   B E G
 512     // and inserting A, C, D, F the resulting model will be:
 513     //   0 1 2 3 4 5 6
 514     //   A B C D E F G
 515     // and the item-ranges must be:
 516     //   index: 0, count: 1 for A
 517     //   index: 1, count: 2 for B, C
 518     //   index: 2, count: 1 for G
 519
 520     m_testDir->createFiles({"A", "C", "D", "F"});
 521
 522     m_model->m_dirLister->updateDirectory(m_testDir->url());
 523     QVERIFY(itemsInsertedSpy.wait());
 524
 525     QCOMPARE(itemsInsertedSpy.count(), 1);
 526     arguments = itemsInsertedSpy.takeFirst();
 527     itemRangeList = arguments.at(0).value<KItemRangeList>();
 528     QCOMPARE(itemRangeList, KItemRangeList() << KItemRange(0, 1) << KItemRange(1, 2) << KItemRange(2, 1));
 529 }
 530
 531 void KFileItemModelTest::testExpandItems()
 532 {
 533     QSignalSpy itemsInsertedSpy(m_model, &KFileItemModel::itemsInserted);
 534     QVERIFY(itemsInsertedSpy.isValid());
 535     QSignalSpy itemsRemovedSpy(m_model, &KFileItemModel::itemsRemoved);
 536     QVERIFY(itemsRemovedSpy.isValid());
 537     QSignalSpy loadingCompletedSpy(m_model, &KFileItemModel::directoryLoadingCompleted);
 538     QVERIFY(loadingCompletedSpy.isValid());
 539
 540     // Test expanding subfolders in a folder with the items "a/", "a/a/", "a/a/1", "a/a-1/", "a/a-1/1".
 541     // Besides testing the basic item expansion functionality, the test makes sure that
 542     // KFileItemModel::expansionLevelsCompare(const KFileItem& a, const KFileItem& b)
 543     // yields the correct result for "a/a/1" and "a/a-1/", which is non-trivial because they share the
 544     // first three characters.
 545     QSet<QByteArray> originalModelRoles = m_model->roles();
 546     QSet<QByteArray> modelRoles = originalModelRoles;
 547     modelRoles << "isExpanded"
 548                << "isExpandable"
 549                << "expandedParentsCount";
 550     m_model->setRoles(modelRoles);
 551
 552     m_testDir->createFiles({"a/a/1", "a/a-1/1"});
 553
 554     // Store the URLs of all folders in a set.
 555     QSet<QUrl> allFolders;
 556     allFolders << QUrl::fromLocalFile(m_testDir->path() + "/a") << QUrl::fromLocalFile(m_testDir->path() + "/a/a")
 557                << QUrl::fromLocalFile(m_testDir->path() + "/a/a-1");
 558
 559     m_model->loadDirectory(m_testDir->url());
 560     QVERIFY(itemsInsertedSpy.wait());
 561
 562     // So far, the model contains only "a/"
 563     QCOMPARE(m_model->count(), 1);
 564     QVERIFY(m_model->isExpandable(0));
 565     QVERIFY(!m_model->isExpanded(0));
 566     QVERIFY(m_model->expandedDirectories().empty());
 567
 568     QCOMPARE(itemsInsertedSpy.count(), 1);
 569     KItemRangeList itemRangeList = itemsInsertedSpy.takeFirst().at(0).value<KItemRangeList>();
 570     QCOMPARE(itemRangeList, KItemRangeList() << KItemRange(0, 1)); // 1 new item "a/" with index 0
 571
 572     // Expand the folder "a/" -> "a/a/" and "a/a-1/" become visible
 573     m_model->setExpanded(0, true);
 574     QVERIFY(m_model->isExpanded(0));
 575     QVERIFY(itemsInsertedSpy.wait());
 576     QCOMPARE(m_model->count(), 3); // 3 items: "a/", "a/a/", "a/a-1/"
 577     QCOMPARE(m_model->expandedDirectories(), QSet<QUrl>() << QUrl::fromLocalFile(m_testDir->path() + "/a"));
 578
 579     QCOMPARE(itemsInsertedSpy.count(), 1);
 580     itemRangeList = itemsInsertedSpy.takeFirst().at(0).value<KItemRangeList>();
 581     QCOMPARE(itemRangeList, KItemRangeList() << KItemRange(1, 2)); // 2 new items "a/a/" and "a/a-1/" with indices 1 and 2
 582
 583     QVERIFY(m_model->isExpandable(1));
 584     QVERIFY(!m_model->isExpanded(1));
 585     QVERIFY(m_model->isExpandable(2));
 586     QVERIFY(!m_model->isExpanded(2));
 587
 588     // Expand the folder "a/a/" -> "a/a/1" becomes visible
 589     m_model->setExpanded(1, true);
 590     QVERIFY(m_model->isExpanded(1));
 591     QVERIFY(itemsInsertedSpy.wait());
 592     QCOMPARE(m_model->count(), 4); // 4 items: "a/", "a/a/", "a/a/1", "a/a-1/"
 593     QCOMPARE(m_model->expandedDirectories(), QSet<QUrl>() << QUrl::fromLocalFile(m_testDir->path() + "/a") << QUrl::fromLocalFile(m_testDir->path() + "/a/a"));
 594
 595     QCOMPARE(itemsInsertedSpy.count(), 1);
 596     itemRangeList = itemsInsertedSpy.takeFirst().at(0).value<KItemRangeList>();
 597     QCOMPARE(itemRangeList, KItemRangeList() << KItemRange(2, 1)); // 1 new item "a/a/1" with index 2
 598
 599     QVERIFY(!m_model->isExpandable(2));
 600     QVERIFY(!m_model->isExpanded(2));
 601
 602     // Expand the folder "a/a-1/" -> "a/a-1/1" becomes visible
 603     m_model->setExpanded(3, true);
 604     QVERIFY(m_model->isExpanded(3));
 605     QVERIFY(itemsInsertedSpy.wait());
 606     QCOMPARE(m_model->count(), 5); // 5 items: "a/", "a/a/", "a/a/1", "a/a-1/", "a/a-1/1"
 607     QCOMPARE(m_model->expandedDirectories(), allFolders);
 608
 609     QCOMPARE(itemsInsertedSpy.count(), 1);
 610     itemRangeList = itemsInsertedSpy.takeFirst().at(0).value<KItemRangeList>();
 611     QCOMPARE(itemRangeList, KItemRangeList() << KItemRange(4, 1)); // 1 new item "a/a-1/1" with index 4
 612
 613     QVERIFY(!m_model->isExpandable(4));
 614     QVERIFY(!m_model->isExpanded(4));
 615
 616     // Collapse the top-level folder -> all other items should disappear
 617     m_model->setExpanded(0, false);
 618     QVERIFY(!m_model->isExpanded(0));
 619     QCOMPARE(m_model->count(), 1);
 620     QVERIFY(!m_model->expandedDirectories().contains(QUrl::fromLocalFile(m_testDir->path() + "/a"))); // TODO: Make sure that child URLs are also removed
 621
 622     QCOMPARE(itemsRemovedSpy.count(), 1);
 623     itemRangeList = itemsRemovedSpy.takeFirst().at(0).value<KItemRangeList>();
 624     QCOMPARE(itemRangeList, KItemRangeList() << KItemRange(1, 4)); // 4 items removed
 625     QVERIFY(m_model->isConsistent());
 626
 627     // Clear the model, reload the folder and try to restore the expanded folders.
 628     m_model->clear();
 629     QCOMPARE(m_model->count(), 0);
 630     QVERIFY(m_model->expandedDirectories().empty());
 631
 632     m_model->loadDirectory(m_testDir->url());
 633     m_model->restoreExpandedDirectories(allFolders);
 634     QVERIFY(loadingCompletedSpy.wait());
 635     QCOMPARE(m_model->count(), 5); // 5 items: "a/", "a/a/", "a/a/1", "a/a-1/", "a/a-1/1"
 636     QVERIFY(m_model->isExpanded(0));
 637     QVERIFY(m_model->isExpanded(1));
 638     QVERIFY(!m_model->isExpanded(2));
 639     QVERIFY(m_model->isExpanded(3));
 640     QVERIFY(!m_model->isExpanded(4));
 641     QCOMPARE(m_model->expandedDirectories(), allFolders);
 642     QVERIFY(m_model->isConsistent());
 643
 644     // Move to a sub folder, then call restoreExpandedFolders() *before* going back.
 645     // This is how DolphinView restores the expanded folders when navigating in history.
 646     m_model->loadDirectory(QUrl::fromLocalFile(m_testDir->path() + "/a/a/"));
 647     QVERIFY(loadingCompletedSpy.wait());
 648     QCOMPARE(m_model->count(), 1); // 1 item: "1"
 649     m_model->restoreExpandedDirectories(allFolders);
 650     m_model->loadDirectory(m_testDir->url());
 651     QVERIFY(loadingCompletedSpy.wait());
 652     QCOMPARE(m_model->count(), 5); // 5 items: "a/", "a/a/", "a/a/1", "a/a-1/", "a/a-1/1"
 653     QCOMPARE(m_model->expandedDirectories(), allFolders);
 654
 655     // Remove all expanded items by changing the roles
 656     itemsRemovedSpy.clear();
 657     m_model->setRoles(originalModelRoles);
 658     QVERIFY(!m_model->isExpanded(0));
 659     QCOMPARE(m_model->count(), 1);
 660     QVERIFY(!m_model->expandedDirectories().contains(QUrl::fromLocalFile(m_testDir->path() + "/a")));
 661
 662     QCOMPARE(itemsRemovedSpy.count(), 1);
 663     itemRangeList = itemsRemovedSpy.takeFirst().at(0).value<KItemRangeList>();
 664     QCOMPARE(itemRangeList, KItemRangeList() << KItemRange(1, 4)); // 4 items removed
 665     QVERIFY(m_model->isConsistent());
 666 }
 667
 668 void KFileItemModelTest::testExpandParentItems()
 669 {
 670     QSignalSpy itemsInsertedSpy(m_model, &KFileItemModel::itemsInserted);
 671     QSignalSpy loadingCompletedSpy(m_model, &KFileItemModel::directoryLoadingCompleted);
 672     QVERIFY(loadingCompletedSpy.isValid());
 673
 674     // Create a tree structure of folders:
 675     // a 1/
 676     // a 1/b1/
 677     // a 1/b1/c1/
 678     // a2/
 679     // a2/b2/
 680     // a2/b2/c2/
 681     // a2/b2/c2/d2/
 682     QSet<QByteArray> modelRoles = m_model->roles();
 683     modelRoles << "isExpanded"
 684                << "isExpandable"
 685                << "expandedParentsCount";
 686     m_model->setRoles(modelRoles);
 687
 688     m_testDir->createFiles({"a 1/b1/c1/file.txt", "a2/b2/c2/d2/file.txt"});
 689
 690     m_model->loadDirectory(m_testDir->url());
 691     QVERIFY(itemsInsertedSpy.wait());
 692
 693     // So far, the model contains only "a 1/" and "a2/".
 694     QCOMPARE(m_model->count(), 2);
 695     QVERIFY(m_model->expandedDirectories().empty());
 696
 697     // Expand the parents of "a2/b2/c2".
 698     m_model->expandParentDirectories(QUrl::fromLocalFile(m_testDir->path() + "a2/b2/c2"));
 699     QVERIFY(loadingCompletedSpy.wait());
 700
 701     // The model should now contain "a 1/", "a2/", "a2/b2/", and "a2/b2/c2/".
 702     // It's important that only the parents of "a1/b1/c1" are expanded.
 703     QCOMPARE(m_model->count(), 4);
 704     QVERIFY(!m_model->isExpanded(0));
 705     QVERIFY(m_model->isExpanded(1));
 706     QVERIFY(m_model->isExpanded(2));
 707     QVERIFY(!m_model->isExpanded(3));
 708
 709     // Expand the parents of "a 1/b1".
 710     m_model->expandParentDirectories(QUrl::fromLocalFile(m_testDir->path() + "a 1/b1"));
 711     QVERIFY(loadingCompletedSpy.wait());
 712
 713     // The model should now contain "a 1/", "a 1/b1/", "a2/", "a2/b2", and "a2/b2/c2/".
 714     // It's important that only the parents of "a 1/b1/" and "a2/b2/c2/" are expanded.
 715     QCOMPARE(m_model->count(), 5);
 716     QVERIFY(m_model->isExpanded(0));
 717     QVERIFY(!m_model->isExpanded(1));
 718     QVERIFY(m_model->isExpanded(2));
 719     QVERIFY(m_model->isExpanded(3));
 720     QVERIFY(!m_model->isExpanded(4));
 721     QVERIFY(m_model->isConsistent());
 722
 723     // Expand "a 1/b1/".
 724     m_model->setExpanded(1, true);
 725     QVERIFY(loadingCompletedSpy.wait());
 726     QCOMPARE(m_model->count(), 6);
 727     QVERIFY(m_model->isExpanded(0));
 728     QVERIFY(m_model->isExpanded(1));
 729     QVERIFY(!m_model->isExpanded(2));
 730     QVERIFY(m_model->isExpanded(3));
 731     QVERIFY(m_model->isExpanded(4));
 732     QVERIFY(!m_model->isExpanded(5));
 733     QVERIFY(m_model->isConsistent());
 734
 735     // Collapse "a 1/b1/" again, and verify that the previous state is restored.
 736     m_model->setExpanded(1, false);
 737     QCOMPARE(m_model->count(), 5);
 738     QVERIFY(m_model->isExpanded(0));
 739     QVERIFY(!m_model->isExpanded(1));
 740     QVERIFY(m_model->isExpanded(2));
 741     QVERIFY(m_model->isExpanded(3));
 742     QVERIFY(!m_model->isExpanded(4));
 743     QVERIFY(m_model->isConsistent());
 744 }
 745
 746 /**
 747  * Renaming an expanded folder by prepending its name with a dot makes it
 748  * hidden. Verify that this does not cause an inconsistent model state and
 749  * a crash later on, see https://bugs.kde.org/show_bug.cgi?id=311947
 750  */
 751 void KFileItemModelTest::testMakeExpandedItemHidden()
 752 {
 753     QSignalSpy itemsInsertedSpy(m_model, &KFileItemModel::itemsInserted);
 754     QSignalSpy itemsRemovedSpy(m_model, &KFileItemModel::itemsRemoved);
 755
 756     QSet<QByteArray> modelRoles = m_model->roles();
 757     modelRoles << "isExpanded"
 758                << "isExpandable"
 759                << "expandedParentsCount";
 760     m_model->setRoles(modelRoles);
 761
 762     m_testDir->createFiles({"1a/2a/3a", "1a/2a/3b", "1a/2b", "1b"});
 763
 764     m_model->loadDirectory(m_testDir->url());
 765     QVERIFY(itemsInsertedSpy.wait());
 766
 767     // So far, the model contains only "1a/" and "1b".
 768     QCOMPARE(m_model->count(), 2);
 769     m_model->setExpanded(0, true);
 770     QVERIFY(itemsInsertedSpy.wait());
 771
 772     // Now "1a/2a" and "1a/2b" have appeared.
 773     QCOMPARE(m_model->count(), 4);
 774     m_model->setExpanded(1, true);
 775     QVERIFY(itemsInsertedSpy.wait());
 776     QCOMPARE(m_model->count(), 6);
 777
 778     // Rename "1a/2" and make it hidden.
 779     const QUrl oldUrl = QUrl::fromLocalFile(m_model->fileItem(0).url().path() + "/2a");
 780     const QUrl newUrl = QUrl::fromLocalFile(m_model->fileItem(0).url().path() + "/.2a");
 781
 782     KIO::SimpleJob *job = KIO::rename(oldUrl, newUrl, KIO::HideProgressInfo);
 783     bool ok = job->exec();
 784     QVERIFY(ok);
 785     QVERIFY(itemsRemovedSpy.wait());
 786
 787     // "1a/2" and its subfolders have disappeared now.
 788     QVERIFY(m_model->isConsistent());
 789     QCOMPARE(m_model->count(), 3);
 790
 791     m_model->setExpanded(0, false);
 792     QCOMPARE(m_model->count(), 2);
 793 }
 794
 795 void KFileItemModelTest::testRemoveFilteredExpandedItems()
 796 {
 797     QSignalSpy itemsInsertedSpy(m_model, &KFileItemModel::itemsInserted);
 798
 799     QSet<QByteArray> originalModelRoles = m_model->roles();
 800     QSet<QByteArray> modelRoles = originalModelRoles;
 801     modelRoles << "isExpanded"
 802                << "isExpandable"
 803                << "expandedParentsCount";
 804     m_model->setRoles(modelRoles);
 805
 806     m_testDir->createFiles({"folder/child", "file"});
 807
 808     m_model->loadDirectory(m_testDir->url());
 809     QVERIFY(itemsInsertedSpy.wait());
 810
 811     // So far, the model contains only "folder/" and "file".
 812     QCOMPARE(m_model->count(), 2);
 813     QVERIFY(m_model->isExpandable(0));
 814     QVERIFY(!m_model->isExpandable(1));
 815     QVERIFY(!m_model->isExpanded(0));
 816     QVERIFY(!m_model->isExpanded(1));
 817     QCOMPARE(itemsInModel(),
 818              QStringList() << "folder"
 819                            << "file");
 820
 821     // Expand "folder" -> "folder/child" becomes visible.
 822     m_model->setExpanded(0, true);
 823     QVERIFY(m_model->isExpanded(0));
 824     QVERIFY(itemsInsertedSpy.wait());
 825     QCOMPARE(itemsInModel(),
 826              QStringList() << "folder"
 827                            << "child"
 828                            << "file");
 829
 830     // Add a name filter.
 831     m_model->setNameFilter("f");
 832     QCOMPARE(itemsInModel(),
 833              QStringList() << "folder"
 834                            << "file");
 835
 836     m_model->setNameFilter("fo");
 837     QCOMPARE(itemsInModel(), QStringList() << "folder");
 838
 839     // Remove all expanded items by changing the roles
 840     m_model->setRoles(originalModelRoles);
 841     QVERIFY(!m_model->isExpanded(0));
 842     QCOMPARE(itemsInModel(), QStringList() << "folder");
 843
 844     // Remove the name filter and verify that "folder/child" does not reappear.
 845     m_model->setNameFilter(QString());
 846     QCOMPARE(itemsInModel(),
 847              QStringList() << "folder"
 848                            << "file");
 849 }
 850
 851 void KFileItemModelTest::testSizeSortingAfterRefresh()
 852 {
 853     // testDir structure is as follows
 854     // ./
 855     // ├─ a
 856     // ├─ b
 857     // ├─ c/
 858     // │  ├─ c-2/
 859     // │  │  ├─ c-3
 860     // │  ├─ c-1
 861     // ├─ d
 862     // ├─ e
 863
 864     QSignalSpy itemsInsertedSpy(m_model, &KFileItemModel::itemsInserted);
 865     QSignalSpy itemsMovedSpy(m_model, &KFileItemModel::itemsMoved);
 866     QVERIFY(itemsMovedSpy.isValid());
 867
 868     // Create some files with different sizes and modification times to check the different sorting options
 869     QDateTime now = QDateTime::currentDateTime();
 870
 871     QSet<QByteArray> roles;
 872     roles.insert("text");
 873     roles.insert("isExpanded");
 874     roles.insert("isExpandable");
 875     roles.insert("expandedParentsCount");
 876     m_model->setRoles(roles);
 877
 878     m_testDir->createDir("c/c-2");
 879     m_testDir->createFile("c/c-2/c-3");
 880     m_testDir->createFile("c/c-1");
 881
 882     m_testDir->createFile("a", "A file", now.addDays(-3));
 883     m_testDir->createFile("b", "A larger file", now.addDays(0));
 884     m_testDir->createDir("c", now.addDays(-2));
 885     m_testDir->createFile("d", "The largest file in this directory", now.addDays(-1));
 886     m_testDir->createFile("e", "An even larger file", now.addDays(-4));
 887
 888     m_model->loadDirectory(m_testDir->url());
 889     QVERIFY(itemsInsertedSpy.wait());
 890
 891     int index = m_model->index(QUrl(m_testDir->url().url() + "/c"));
 892     m_model->setExpanded(index, true);
 893     QVERIFY(itemsInsertedSpy.wait());
 894
 895     index = m_model->index(QUrl(m_testDir->url().url() + "/c/c-2"));
 896     m_model->setExpanded(index, true);
 897     QVERIFY(itemsInsertedSpy.wait());
 898
 899     // Default: Sort by Name, ascending
 900     QCOMPARE(m_model->sortRole(), QByteArray("text"));
 901     QCOMPARE(m_model->sortOrder(), Qt::AscendingOrder);
 902     QCOMPARE(itemsInModel(),
 903              QStringList() << "c"
 904                            << "c-2"
 905                            << "c-3"
 906                            << "c-1"
 907                            << "a"
 908                            << "b"
 909                            << "d"
 910                            << "e");
 911
 912     // Sort by Size, ascending, before refresh
 913     m_model->setSortRole("size");
 914     QCOMPARE(m_model->sortRole(), QByteArray("size"));
 915     QCOMPARE(m_model->sortOrder(), Qt::AscendingOrder);
 916     QCOMPARE(itemsInModel(),
 917              QStringList() << "c"
 918                            << "c-2"
 919                            << "c-3"
 920                            << "c-1"
 921                            << "a"
 922                            << "b"
 923                            << "e"
 924                            << "d");
 925
 926     // Refresh directory
 927     m_model->refreshDirectory(m_model->directory());
 928     QVERIFY(itemsInsertedSpy.wait());
 929
 930     // Expand folders again
 931     index = m_model->index(QUrl(m_testDir->url().url() + "/c"));
 932     m_model->setExpanded(index, true);
 933     QVERIFY(itemsInsertedSpy.wait());
 934
 935     index = m_model->index(QUrl(m_testDir->url().url() + "/c/c-2"));
 936     m_model->setExpanded(index, true);
 937     QVERIFY(itemsInsertedSpy.wait());
 938
 939     // Sort by Size, ascending, after refresh
 940     QCOMPARE(m_model->sortRole(), QByteArray("size"));
 941     QCOMPARE(m_model->sortOrder(), Qt::AscendingOrder);
 942     QCOMPARE(itemsInModel(),
 943              QStringList() << "c"
 944                            << "c-2"
 945                            << "c-3"
 946                            << "c-1"
 947                            << "a"
 948                            << "b"
 949                            << "e"
 950                            << "d");
 951 }
 952
 953 void KFileItemModelTest::testSorting()
 954 {
 955     // testDir structure is as follows
 956     // ./
 957     // ├─ .g/
 958     // ├─ a
 959     // ├─ b
 960     // ├─ c/
 961     // │  ├─ c-2/
 962     // │  │  ├─ c-3
 963     // │  ├─ c-1
 964     // ├─ .f
 965     // ├─ d
 966     // ├─ e
 967
 968     QSignalSpy itemsInsertedSpy(m_model, &KFileItemModel::itemsInserted);
 969     QSignalSpy itemsMovedSpy(m_model, &KFileItemModel::itemsMoved);
 970     QVERIFY(itemsMovedSpy.isValid());
 971
 972     // Create some files with different sizes and modification times to check the different sorting options
 973     QDateTime now = QDateTime::currentDateTime();
 974
 975     QSet<QByteArray> roles;
 976     roles.insert("text");
 977     roles.insert("isExpanded");
 978     roles.insert("isExpandable");
 979     roles.insert("expandedParentsCount");
 980     m_model->setRoles(roles);
 981
 982     m_testDir->createDir("c/c-2");
 983     m_testDir->createFile("c/c-2/c-3");
 984     m_testDir->createFile("c/c-1");
 985
 986     m_testDir->createFile("a", "A file", now.addDays(-3));
 987     m_testDir->createFile("b", "A larger file", now.addDays(0));
 988     m_testDir->createDir("c", now.addDays(-2));
 989     m_testDir->createFile("d", "The largest file in this directory", now.addDays(-1));
 990     m_testDir->createFile("e", "An even larger file", now.addDays(-4));
 991     m_testDir->createFile(".f");
 992     m_testDir->createDir(".g");
 993
 994     m_model->loadDirectory(m_testDir->url());
 995     QVERIFY(itemsInsertedSpy.wait());
 996     QCOMPARE(itemsInsertedSpy.count(), 1);
 997     KItemRangeList itemRangeList = itemsInsertedSpy.takeFirst().at(0).value<KItemRangeList>();
 998     QCOMPARE(itemRangeList, KItemRangeList() << KItemRange(0, 5));
 999
1000     int index = m_model->index(QUrl(m_testDir->url().url() + "/c"));
1001     m_model->setExpanded(index, true);
1002     QVERIFY(itemsInsertedSpy.wait());
1003     QCOMPARE(itemsInsertedSpy.count(), 1);
1004     itemRangeList = itemsInsertedSpy.takeFirst().at(0).value<KItemRangeList>();
1005     QCOMPARE(itemRangeList, KItemRangeList() << KItemRange(1, 2));
1006
1007     index = m_model->index(QUrl(m_testDir->url().url() + "/c/c-2"));
1008     m_model->setExpanded(index, true);
1009     QVERIFY(itemsInsertedSpy.wait());
1010     QCOMPARE(itemsInsertedSpy.count(), 1);
1011     itemRangeList = itemsInsertedSpy.takeFirst().at(0).value<KItemRangeList>();
1012     QCOMPARE(itemRangeList, KItemRangeList() << KItemRange(2, 1));
1013
1014     // Default: Sort by Name, ascending
1015     QCOMPARE(m_model->sortRole(), QByteArray("text"));
1016     QCOMPARE(m_model->sortOrder(), Qt::AscendingOrder);
1017     QVERIFY(m_model->sortDirectoriesFirst());
1018     QVERIFY(!m_model->showHiddenFiles());
1019     QCOMPARE(itemsInModel(),
1020              QStringList() << "c"
1021                            << "c-2"
1022                            << "c-3"
1023                            << "c-1"
1024                            << "a"
1025                            << "b"
1026                            << "d"
1027                            << "e");
1028
1029     // Sort by Name, ascending, 'Sort Folders First' disabled
1030     m_model->setSortDirectoriesFirst(false);
1031     QCOMPARE(m_model->sortRole(), QByteArray("text"));
1032     QCOMPARE(m_model->sortOrder(), Qt::AscendingOrder);
1033     QCOMPARE(itemsInModel(),
1034              QStringList() << "a"
1035                            << "b"
1036                            << "c"
1037                            << "c-1"
1038                            << "c-2"
1039                            << "c-3"
1040                            << "d"
1041                            << "e");
1042     QCOMPARE(itemsMovedSpy.count(), 1);
1043     QCOMPARE(itemsMovedSpy.first().at(0).value<KItemRange>(), KItemRange(0, 6));
1044     QCOMPARE(itemsMovedSpy.takeFirst().at(1).value<QList<int>>(), QList<int>() << 2 << 4 << 5 << 3 << 0 << 1);
1045
1046     // Sort by Name, descending
1047     m_model->setSortDirectoriesFirst(true);
1048     m_model->setSortOrder(Qt::DescendingOrder);
1049     QCOMPARE(m_model->sortRole(), QByteArray("text"));
1050     QCOMPARE(m_model->sortOrder(), Qt::DescendingOrder);
1051     QCOMPARE(itemsInModel(),
1052              QStringList() << "c"
1053                            << "c-2"
1054                            << "c-3"
1055                            << "c-1"
1056                            << "e"
1057                            << "d"
1058                            << "b"
1059                            << "a");
1060     QCOMPARE(itemsMovedSpy.count(), 2);
1061     QCOMPARE(itemsMovedSpy.first().at(0).value<KItemRange>(), KItemRange(0, 6));
1062     QCOMPARE(itemsMovedSpy.takeFirst().at(1).value<QList<int>>(), QList<int>() << 4 << 5 << 0 << 3 << 1 << 2);
1063     QCOMPARE(itemsMovedSpy.first().at(0).value<KItemRange>(), KItemRange(4, 4));
1064     QCOMPARE(itemsMovedSpy.takeFirst().at(1).value<QList<int>>(), QList<int>() << 7 << 6 << 5 << 4);
1065
1066     // Sort by Date, descending
1067     m_model->setSortDirectoriesFirst(true);
1068     m_model->setSortRole("modificationtime");
1069     QCOMPARE(m_model->sortRole(), QByteArray("modificationtime"));
1070     QCOMPARE(m_model->sortOrder(), Qt::DescendingOrder);
1071     QCOMPARE(itemsInModel(),
1072              QStringList() << "c"
1073                            << "c-2"
1074                            << "c-3"
1075                            << "c-1"
1076                            << "b"
1077                            << "d"
1078                            << "a"
1079                            << "e");
1080     QCOMPARE(itemsMovedSpy.count(), 1);
1081     QCOMPARE(itemsMovedSpy.first().at(0).value<KItemRange>(), KItemRange(4, 4));
1082     QCOMPARE(itemsMovedSpy.takeFirst().at(1).value<QList<int>>(), QList<int>() << 7 << 5 << 4 << 6);
1083
1084     // Sort by Date, ascending
1085     m_model->setSortOrder(Qt::AscendingOrder);
1086     QCOMPARE(m_model->sortRole(), QByteArray("modificationtime"));
1087     QCOMPARE(m_model->sortOrder(), Qt::AscendingOrder);
1088     QCOMPARE(itemsInModel(),
1089              QStringList() << "c"
1090                            << "c-2"
1091                            << "c-3"
1092                            << "c-1"
1093                            << "e"
1094                            << "a"
1095                            << "d"
1096                            << "b");
1097     QCOMPARE(itemsMovedSpy.count(), 1);
1098     QCOMPARE(itemsMovedSpy.first().at(0).value<KItemRange>(), KItemRange(4, 4));
1099     QCOMPARE(itemsMovedSpy.takeFirst().at(1).value<QList<int>>(), QList<int>() << 7 << 6 << 5 << 4);
1100
1101     // Sort by Date, ascending, 'Sort Folders First' disabled
1102     m_model->setSortDirectoriesFirst(false);
1103     QCOMPARE(m_model->sortRole(), QByteArray("modificationtime"));
1104     QCOMPARE(m_model->sortOrder(), Qt::AscendingOrder);
1105     QVERIFY(!m_model->sortDirectoriesFirst());
1106     QCOMPARE(itemsInModel(),
1107              QStringList() << "e"
1108                            << "a"
1109                            << "c"
1110                            << "c-1"
1111                            << "c-2"
1112                            << "c-3"
1113                            << "d"
1114                            << "b");
1115     QCOMPARE(itemsMovedSpy.count(), 1);
1116     QCOMPARE(itemsMovedSpy.first().at(0).value<KItemRange>(), KItemRange(0, 6));
1117     QCOMPARE(itemsMovedSpy.takeFirst().at(1).value<QList<int>>(), QList<int>() << 2 << 4 << 5 << 3 << 0 << 1);
1118
1119     // Sort by Name, ascending, 'Sort Folders First' disabled
1120     m_model->setSortRole("text");
1121     QCOMPARE(m_model->sortOrder(), Qt::AscendingOrder);
1122     QVERIFY(!m_model->sortDirectoriesFirst());
1123     QCOMPARE(itemsInModel(),
1124              QStringList() << "a"
1125                            << "b"
1126                            << "c"
1127                            << "c-1"
1128                            << "c-2"
1129                            << "c-3"
1130                            << "d"
1131                            << "e");
1132     QCOMPARE(itemsMovedSpy.count(), 1);
1133     QCOMPARE(itemsMovedSpy.first().at(0).value<KItemRange>(), KItemRange(0, 8));
1134     QCOMPARE(itemsMovedSpy.takeFirst().at(1).value<QList<int>>(), QList<int>() << 7 << 0 << 2 << 3 << 4 << 5 << 6 << 1);
1135
1136     // Sort by Size, ascending, 'Sort Folders First' disabled
1137     m_model->setSortRole("size");
1138     QCOMPARE(m_model->sortRole(), QByteArray("size"));
1139     QCOMPARE(m_model->sortOrder(), Qt::AscendingOrder);
1140     QVERIFY(!m_model->sortDirectoriesFirst());
1141     QCOMPARE(itemsInModel(),
1142              QStringList() << "c"
1143                            << "c-2"
1144                            << "c-3"
1145                            << "c-1"
1146                            << "a"
1147                            << "b"
1148                            << "e"
1149                            << "d");
1150     QCOMPARE(itemsMovedSpy.count(), 1);
1151     QCOMPARE(itemsMovedSpy.first().at(0).value<KItemRange>(), KItemRange(0, 8));
1152     QCOMPARE(itemsMovedSpy.takeFirst().at(1).value<QList<int>>(), QList<int>() << 4 << 5 << 0 << 3 << 1 << 2 << 7 << 6);
1153
1154     // In 'Sort by Size' mode, folders are always first -> changing 'Sort Folders First' does not resort the model
1155     m_model->setSortDirectoriesFirst(true);
1156     QCOMPARE(m_model->sortRole(), QByteArray("size"));
1157     QCOMPARE(m_model->sortOrder(), Qt::AscendingOrder);
1158     QVERIFY(m_model->sortDirectoriesFirst());
1159     QCOMPARE(itemsInModel(),
1160              QStringList() << "c"
1161                            << "c-2"
1162                            << "c-3"
1163                            << "c-1"
1164                            << "a"
1165                            << "b"
1166                            << "e"
1167                            << "d");
1168     QCOMPARE(itemsMovedSpy.count(), 0);
1169
1170     // Sort by Size, descending, 'Sort Folders First' enabled
1171     m_model->setSortOrder(Qt::DescendingOrder);
1172     QCOMPARE(m_model->sortRole(), QByteArray("size"));
1173     QCOMPARE(m_model->sortOrder(), Qt::DescendingOrder);
1174     QVERIFY(m_model->sortDirectoriesFirst());
1175     QCOMPARE(itemsInModel(),
1176              QStringList() << "c"
1177                            << "c-2"
1178                            << "c-3"
1179                            << "c-1"
1180                            << "d"
1181                            << "e"
1182                            << "b"
1183                            << "a");
1184     QCOMPARE(itemsMovedSpy.count(), 1);
1185     QCOMPARE(itemsMovedSpy.first().at(0).value<KItemRange>(), KItemRange(4, 4));
1186     QCOMPARE(itemsMovedSpy.takeFirst().at(1).value<QList<int>>(), QList<int>() << 7 << 6 << 5 << 4);
1187
1188     // 'Show Hidden Files' enabled
1189     m_model->setShowHiddenFiles(true);
1190     QVERIFY(m_model->showHiddenFiles());
1191     QVERIFY(!m_model->sortHiddenLast());
1192     QCOMPARE(itemsInModel(),
1193              QStringList() << "c"
1194                            << "c-2"
1195                            << "c-3"
1196                            << "c-1"
1197                            << ".g"
1198                            << "d"
1199                            << "e"
1200                            << "b"
1201                            << "a"
1202                            << ".f");
1203     QCOMPARE(itemsMovedSpy.count(), 0);
1204     QCOMPARE(itemsInsertedSpy.count(), 1);
1205     QCOMPARE(itemsInsertedSpy.takeFirst().at(0).value<KItemRangeList>(), KItemRangeList() << KItemRange(4, 1) << KItemRange(8, 1));
1206
1207     // 'Sort Hidden Files Last' enabled
1208     m_model->setSortHiddenLast(true);
1209     QVERIFY(m_model->sortHiddenLast());
1210     QCOMPARE(itemsInModel(),
1211              QStringList() << "c"
1212                            << "c-2"
1213                            << "c-3"
1214                            << "c-1"
1215                            << "d"
1216                            << "e"
1217                            << "b"
1218                            << "a"
1219                            << ".g"
1220                            << ".f");
1221     QCOMPARE(itemsMovedSpy.count(), 1);
1222     QCOMPARE(itemsInsertedSpy.count(), 0);
1223     QCOMPARE(itemsMovedSpy.first().at(0).value<KItemRange>(), KItemRange(4, 5));
1224     QCOMPARE(itemsMovedSpy.takeFirst().at(1).value<QList<int>>(), QList<int>() << 8 << 4 << 5 << 6 << 7);
1225
1226     // Sort by Name
1227     m_model->setSortRole("text");
1228     QCOMPARE(itemsInModel(),
1229              QStringList() << "c"
1230                            << "c-2"
1231                            << "c-3"
1232                            << "c-1"
1233                            << "e"
1234                            << "d"
1235                            << "b"
1236                            << "a"
1237                            << ".g"
1238                            << ".f");
1239     QCOMPARE(itemsMovedSpy.count(), 1);
1240     QCOMPARE(itemsMovedSpy.first().at(0).value<KItemRange>(), KItemRange(4, 2));
1241     QCOMPARE(itemsMovedSpy.takeFirst().at(1).value<QList<int>>(), QList<int>() << 5 << 4);
1242
1243     // Sort ascending
1244     m_model->setSortOrder(Qt::AscendingOrder);
1245     QCOMPARE(itemsInModel(),
1246              QStringList() << "c"
1247                            << "c-2"
1248                            << "c-3"
1249                            << "c-1"
1250                            << "a"
1251                            << "b"
1252                            << "d"
1253                            << "e"
1254                            << ".g"
1255                            << ".f");
1256     QCOMPARE(itemsMovedSpy.count(), 1);
1257     QCOMPARE(itemsMovedSpy.first().at(0).value<KItemRange>(), KItemRange(4, 4));
1258     QCOMPARE(itemsMovedSpy.takeFirst().at(1).value<QList<int>>(), QList<int>() << 7 << 6 << 5 << 4);
1259
1260     // 'Sort Folders First' disabled
1261     m_model->setSortDirectoriesFirst(false);
1262     QVERIFY(!m_model->sortDirectoriesFirst());
1263     QCOMPARE(itemsInModel(),
1264              QStringList() << "a"
1265                            << "b"
1266                            << "c"
1267                            << "c-1"
1268                            << "c-2"
1269                            << "c-3"
1270                            << "d"
1271                            << "e"
1272                            << ".f"
1273                            << ".g");
1274     QCOMPARE(itemsMovedSpy.count(), 1);
1275     QCOMPARE(itemsMovedSpy.first().at(0).value<KItemRange>(), KItemRange(0, 10));
1276     QCOMPARE(itemsMovedSpy.takeFirst().at(1).value<QList<int>>(), QList<int>() << 2 << 4 << 5 << 3 << 0 << 1 << 6 << 7 << 9 << 8);
1277 }
1278
1279 void KFileItemModelTest::testNaturalSorting()
1280 {
1281     QSignalSpy itemsInsertedSpy(m_model, &KFileItemModel::itemsInserted);
1282     QSignalSpy itemsMovedSpy(m_model, &KFileItemModel::itemsMoved);
1283     QVERIFY(itemsMovedSpy.isValid());
1284
1285     m_model->setSortRole("text");
1286     m_model->setShowHiddenFiles(true);
1287
1288     m_testDir->createFiles({".a", "a.txt", "b.txt", "a 1.txt", "a 2.txt", "a 10.txt", "a.tar", "b.tar"});
1289
1290     m_model->loadDirectory(m_testDir->url());
1291     QVERIFY(itemsInsertedSpy.wait());
1292
1293     // Sort by Name, ascending, natural sorting enabled
1294     QCOMPARE(m_model->sortRole(), QByteArray("text"));
1295     QCOMPARE(m_model->sortOrder(), Qt::AscendingOrder);
1296     QCOMPARE(itemsInModel(),
1297              QStringList() << ".a"
1298                            << "a.tar"
1299                            << "a.txt"
1300                            << "a 1.txt"
1301                            << "a 2.txt"
1302                            << "a 10.txt"
1303                            << "b.tar"
1304                            << "b.txt");
1305
1306     // Sort by Extension
1307     m_model->setSortRole("extension");
1308     QCOMPARE(m_model->sortRole(), QByteArray("extension"));
1309     QCOMPARE(itemsInModel(),
1310              QStringList() << ".a"
1311                            << "a.tar"
1312                            << "b.tar"
1313                            << "a.txt"
1314                            << "a 1.txt"
1315                            << "a 2.txt"
1316                            << "a 10.txt"
1317                            << "b.txt");
1318     QCOMPARE(itemsMovedSpy.count(), 1);
1319     QCOMPARE(itemsMovedSpy.first().at(0).value<KItemRange>(), KItemRange(2, 5));
1320     QCOMPARE(itemsMovedSpy.takeFirst().at(1).value<QList<int>>(), QList<int>() << 3 << 4 << 5 << 6 << 2);
1321
1322     // Disable natural sorting, refresh directory for the change to take effect
1323     m_model->m_naturalSorting = false;
1324     m_model->refreshDirectory(m_model->directory());
1325     QVERIFY(itemsInsertedSpy.wait());
1326
1327     // Sort by Extension, ascending, natural sorting disabled
1328     QCOMPARE(m_model->sortRole(), QByteArray("extension"));
1329     QCOMPARE(itemsInModel(),
1330              QStringList() << ".a"
1331                            << "a.tar"
1332                            << "b.tar"
1333                            << "a 1.txt"
1334                            << "a 10.txt"
1335                            << "a 2.txt"
1336                            << "a.txt"
1337                            << "b.txt");
1338
1339     // Sort by Name
1340     m_model->setSortRole("text");
1341     QCOMPARE(m_model->sortRole(), QByteArray("text"));
1342     QCOMPARE(itemsInModel(),
1343              QStringList() << ".a"
1344                            << "a 1.txt"
1345                            << "a 10.txt"
1346                            << "a 2.txt"
1347                            << "a.tar"
1348                            << "a.txt"
1349                            << "b.tar"
1350                            << "b.txt");
1351     QCOMPARE(itemsMovedSpy.count(), 1);
1352     QCOMPARE(itemsMovedSpy.first().at(0).value<KItemRange>(), KItemRange(1, 6));
1353     QCOMPARE(itemsMovedSpy.takeFirst().at(1).value<QList<int>>(), QList<int>() << 4 << 6 << 1 << 2 << 3 << 5);
1354 }
1355
1356 void KFileItemModelTest::testIndexForKeyboardSearch()
1357 {
1358     QSignalSpy itemsInsertedSpy(m_model, &KFileItemModel::itemsInserted);
1359
1360     m_testDir->createFiles({"a", "aa", "Image.jpg", "Image.png", "Text", "Text1", "Text2", "Text11"});
1361
1362     m_model->loadDirectory(m_testDir->url());
1363     QVERIFY(itemsInsertedSpy.wait());
1364
1365     // Search from index 0
1366     QCOMPARE(m_model->indexForKeyboardSearch("a", 0), 0);
1367     QCOMPARE(m_model->indexForKeyboardSearch("aa", 0), 1);
1368     QCOMPARE(m_model->indexForKeyboardSearch("i", 0), 2);
1369     QCOMPARE(m_model->indexForKeyboardSearch("image", 0), 2);
1370     QCOMPARE(m_model->indexForKeyboardSearch("image.jpg", 0), 2);
1371     QCOMPARE(m_model->indexForKeyboardSearch("image.png", 0), 3);
1372     QCOMPARE(m_model->indexForKeyboardSearch("t", 0), 4);
1373     QCOMPARE(m_model->indexForKeyboardSearch("text", 0), 4);
1374     QCOMPARE(m_model->indexForKeyboardSearch("text1", 0), 5);
1375     QCOMPARE(m_model->indexForKeyboardSearch("text2", 0), 6);
1376     QCOMPARE(m_model->indexForKeyboardSearch("text11", 0), 7);
1377
1378     // Start a search somewhere in the middle
1379     QCOMPARE(m_model->indexForKeyboardSearch("a", 1), 1);
1380     QCOMPARE(m_model->indexForKeyboardSearch("i", 3), 3);
1381     QCOMPARE(m_model->indexForKeyboardSearch("t", 5), 5);
1382     QCOMPARE(m_model->indexForKeyboardSearch("text1", 6), 7);
1383
1384     // Test searches that go past the last item back to index 0
1385     QCOMPARE(m_model->indexForKeyboardSearch("a", 2), 0);
1386     QCOMPARE(m_model->indexForKeyboardSearch("i", 7), 2);
1387     QCOMPARE(m_model->indexForKeyboardSearch("image.jpg", 3), 2);
1388     QCOMPARE(m_model->indexForKeyboardSearch("text2", 7), 6);
1389
1390     // Test searches that yield no result
1391     QCOMPARE(m_model->indexForKeyboardSearch("aaa", 0), -1);
1392     QCOMPARE(m_model->indexForKeyboardSearch("b", 0), -1);
1393     QCOMPARE(m_model->indexForKeyboardSearch("image.svg", 0), -1);
1394     QCOMPARE(m_model->indexForKeyboardSearch("text3", 0), -1);
1395     QCOMPARE(m_model->indexForKeyboardSearch("text3", 5), -1);
1396
1397     // Test upper case searches (note that search is case insensitive)
1398     QCOMPARE(m_model->indexForKeyboardSearch("A", 0), 0);
1399     QCOMPARE(m_model->indexForKeyboardSearch("aA", 0), 1);
1400     QCOMPARE(m_model->indexForKeyboardSearch("TexT", 5), 5);
1401     QCOMPARE(m_model->indexForKeyboardSearch("IMAGE", 4), 2);
1402
1403     // TODO: Maybe we should also test keyboard searches in directories which are not sorted by Name?
1404 }
1405
1406 void KFileItemModelTest::testNameFilter()
1407 {
1408     QSignalSpy itemsInsertedSpy(m_model, &KFileItemModel::itemsInserted);
1409
1410     m_testDir->createFiles({"A1", "A2", "Abc", "Bcd", "Cde"});
1411
1412     m_model->loadDirectory(m_testDir->url());
1413     QVERIFY(itemsInsertedSpy.wait());
1414
1415     m_model->setNameFilter("A"); // Shows A1, A2 and Abc
1416     QCOMPARE(m_model->count(), 3);
1417
1418     m_model->setNameFilter("A2"); // Shows only A2
1419     QCOMPARE(m_model->count(), 1);
1420
1421     m_model->setNameFilter("A2"); // Shows only A1
1422     QCOMPARE(m_model->count(), 1);
1423
1424     m_model->setNameFilter("Bc"); // Shows "Abc" and "Bcd"
1425     QCOMPARE(m_model->count(), 2);
1426
1427     m_model->setNameFilter("bC"); // Shows "Abc" and "Bcd"
1428     QCOMPARE(m_model->count(), 2);
1429
1430     m_model->setNameFilter(QString()); // Shows again all items
1431     QCOMPARE(m_model->count(), 5);
1432 }
1433
1434 /**
1435  * Verifies that we do not crash when adding a KFileItem with an empty path.
1436  * Before this issue was fixed, KFileItemModel::expandedParentsCountCompare()
1437  * tried to always read the first character of the path, even if the path is empty.
1438  */
1439 void KFileItemModelTest::testEmptyPath()
1440 {
1441     QSet<QByteArray> roles;
1442     roles.insert("text");
1443     roles.insert("isExpanded");
1444     roles.insert("isExpandable");
1445     roles.insert("expandedParentsCount");
1446     m_model->setRoles(roles);
1447
1448     const QUrl emptyUrl;
1449     QVERIFY(emptyUrl.path().isEmpty());
1450
1451     const QUrl url("file:///test/");
1452
1453     KFileItemList items;
1454     items << KFileItem(emptyUrl, QString(), KFileItem::Unknown) << KFileItem(url, QString(), KFileItem::Unknown);
1455     m_model->slotItemsAdded(emptyUrl, items);
1456     m_model->slotCompleted();
1457 }
1458
1459 /**
1460  * Verifies that the 'isExpanded' state of folders does not change when the
1461  * 'refreshItems' signal is received, see https://bugs.kde.org/show_bug.cgi?id=299675.
1462  */
1463 void KFileItemModelTest::testRefreshExpandedItem()
1464 {
1465     QSignalSpy itemsInsertedSpy(m_model, &KFileItemModel::itemsInserted);
1466     QSignalSpy itemsChangedSpy(m_model, &KFileItemModel::itemsChanged);
1467     QVERIFY(itemsChangedSpy.isValid());
1468
1469     QSet<QByteArray> modelRoles = m_model->roles();
1470     modelRoles << "isExpanded"
1471                << "isExpandable"
1472                << "expandedParentsCount";
1473     m_model->setRoles(modelRoles);
1474
1475     m_testDir->createFiles({"a/1", "a/2", "3", "4"});
1476
1477     m_model->loadDirectory(m_testDir->url());
1478     QVERIFY(itemsInsertedSpy.wait());
1479     QCOMPARE(m_model->count(), 3); // "a/", "3", "4"
1480
1481     m_model->setExpanded(0, true);
1482     QVERIFY(itemsInsertedSpy.wait());
1483     QCOMPARE(m_model->count(), 5); // "a/", "a/1", "a/2", "3", "4"
1484     QVERIFY(m_model->isExpanded(0));
1485
1486     const KFileItem item = m_model->fileItem(0);
1487     m_model->slotRefreshItems({qMakePair(item, item)});
1488     QVERIFY(!itemsChangedSpy.isEmpty());
1489
1490     QCOMPARE(m_model->count(), 5); // "a/", "a/1", "a/2", "3", "4"
1491     QVERIFY(m_model->isExpanded(0));
1492 }
1493
1494 /**
1495  * Verifies that adding an item to an expanded folder that's filtered makes the parental chain visible.
1496  */
1497 void KFileItemModelTest::testAddItemToFilteredExpandedFolder()
1498 {
1499     QSignalSpy itemsInsertedSpy(m_model, &KFileItemModel::itemsInserted);
1500     QSignalSpy fileItemsChangedSpy(m_model, &KFileItemModel::fileItemsChanged);
1501
1502     QSet<QByteArray> modelRoles = m_model->roles();
1503     modelRoles << "isExpanded"
1504                << "isExpandable"
1505                << "expandedParentsCount";
1506     m_model->setRoles(modelRoles);
1507
1508     m_testDir->createFile("a/b/file");
1509
1510     m_model->loadDirectory(m_testDir->url());
1511     QVERIFY(itemsInsertedSpy.wait());
1512     QCOMPARE(m_model->count(), 1); // "a
1513
1514     // Expand "a/".
1515     m_model->setExpanded(0, true);
1516     QVERIFY(itemsInsertedSpy.wait());
1517
1518     // Expand "a/b/".
1519     m_model->setExpanded(1, true);
1520     QVERIFY(itemsInsertedSpy.wait());
1521
1522     QCOMPARE(m_model->count(), 3); // 3 items: "a/", "a/b/", "a/b/file"
1523
1524     const QUrl urlB = m_model->fileItem(1).url();
1525
1526     // Set a filter that matches ".txt" extension
1527     m_model->setNameFilter("*.txt");
1528     QCOMPARE(m_model->count(), 0); // Everything got hidden since we don't have a .txt file yet
1529
1530     m_model->slotItemsAdded(urlB, KFileItemList() << KFileItem(QUrl("a/b/newItem.txt")));
1531     m_model->slotCompleted();
1532
1533     // Entire parental chain should now be shown
1534     QCOMPARE(m_model->count(), 3); // 3 items: "a/", "a/b/", "a/b/newItem.txt"
1535     QCOMPARE(itemsInModel(),
1536              QStringList() << "a"
1537                            << "b"
1538                            << "newItem.txt");
1539
1540     // Items should be indented in hierarchy
1541     QCOMPARE(m_model->expandedParentsCount(0), 0);
1542     QCOMPARE(m_model->expandedParentsCount(1), 1);
1543     QCOMPARE(m_model->expandedParentsCount(2), 2);
1544 }
1545
1546 /**
1547  * Verifies that deleting the last filter-passing child from expanded folders
1548  * makes the parental chain hidden.
1549  */
1550 void KFileItemModelTest::testDeleteItemsWithExpandedFolderWithFilter()
1551 {
1552     QSignalSpy itemsInsertedSpy(m_model, &KFileItemModel::itemsInserted);
1553     QSignalSpy itemsRemovedSpy(m_model, &KFileItemModel::itemsRemoved);
1554
1555     QSet<QByteArray> modelRoles = m_model->roles();
1556     modelRoles << "isExpanded"
1557                << "isExpandable"
1558                << "expandedParentsCount";
1559     m_model->setRoles(modelRoles);
1560
1561     m_testDir->createFile("a/b/file");
1562
1563     m_model->loadDirectory(m_testDir->url());
1564     QVERIFY(itemsInsertedSpy.wait());
1565     QCOMPARE(m_model->count(), 1); // "a
1566
1567     // Expand "a/".
1568     m_model->setExpanded(0, true);
1569     QVERIFY(itemsInsertedSpy.wait());
1570
1571     // Expand "a/b/".
1572     m_model->setExpanded(1, true);
1573     QVERIFY(itemsInsertedSpy.wait());
1574
1575     QCOMPARE(m_model->count(), 3); // 3 items: "a/", "a/b/", "a/b/file"
1576
1577     // Set a filter that matches "file" extension
1578     m_model->setNameFilter("file");
1579     QCOMPARE(m_model->count(), 3); // Everything is still shown
1580
1581     // Delete "file"
1582     QCOMPARE(itemsRemovedSpy.count(), 0);
1583     m_model->slotItemsDeleted(KFileItemList() << m_model->fileItem(2));
1584     QCOMPARE(itemsRemovedSpy.count(), 1);
1585
1586     // Entire parental chain should now be filtered
1587     QCOMPARE(m_model->count(), 0);
1588     QCOMPARE(m_model->m_filteredItems.size(), 2);
1589 }
1590
1591 /**
1592  * Verifies that the fileItemsChanged signal is raised with the correct index after renaming files with filter set.
1593  * The rename operation will cause one item to be filtered out and another item to be reordered.
1594  */
1595 void KFileItemModelTest::testRefreshItemsWithFilter()
1596 {
1597     QSignalSpy itemsInsertedSpy(m_model, &KFileItemModel::itemsInserted);
1598     QSignalSpy itemsRemovedSpy(m_model, &KFileItemModel::itemsRemoved);
1599     QSignalSpy itemsChangedSpy(m_model, &KFileItemModel::itemsChanged);
1600     QSignalSpy itemsMovedSpy(m_model, &KFileItemModel::itemsMoved);
1601
1602     // Creates three .txt files
1603     m_testDir->createFiles({"b.txt", "c.txt", "d.txt"});
1604
1605     m_model->loadDirectory(m_testDir->url());
1606     QVERIFY(itemsInsertedSpy.wait());
1607
1608     QCOMPARE(m_model->count(), 3); // "b.txt", "c.txt", "d.txt"
1609
1610     // Set a filter that matches ".txt" extension
1611     m_model->setNameFilter("*.txt");
1612     QCOMPARE(m_model->count(), 3); // Still all items are shown
1613     QCOMPARE(itemsInModel(),
1614              QStringList() << "b.txt"
1615                            << "c.txt"
1616                            << "d.txt");
1617
1618     // Objects used to rename
1619     const KFileItem fileItemC_txt = m_model->fileItem(1);
1620     KFileItem fileItemC_cfg = fileItemC_txt;
1621     fileItemC_cfg.setUrl(QUrl("c.cfg"));
1622
1623     const KFileItem fileItemD_txt = m_model->fileItem(2);
1624     KFileItem fileItemA_txt = fileItemD_txt;
1625     fileItemA_txt.setUrl(QUrl("a.txt"));
1626
1627     // Rename "c.txt" to "c.cfg"; and rename "d.txt" to "a.txt"
1628     QCOMPARE(itemsRemovedSpy.count(), 0);
1629     QCOMPARE(itemsChangedSpy.count(), 0);
1630     m_model->slotRefreshItems({qMakePair(fileItemC_txt, fileItemC_cfg), qMakePair(fileItemD_txt, fileItemA_txt)});
1631     QCOMPARE(itemsRemovedSpy.count(), 1);
1632     QCOMPARE(itemsChangedSpy.count(), 1);
1633     QCOMPARE(m_model->count(), 2); // Only "a.txt" and "b.txt". "c.cfg" got filtered out
1634
1635     QList<QVariant> arguments = itemsChangedSpy.takeLast();
1636     KItemRangeList itemRangeList = arguments.at(0).value<KItemRangeList>();
1637
1638     // We started with the order "b.txt", "c.txt", "d.txt"
1639     // "d.txt" started with index "2"
1640     // "c.txt" got renamed and got filtered out
1641     // "d.txt" index shifted from index "2" to "1"
1642     // So we expect index "1" in this argument, meaning "d.txt" was renamed
1643     QCOMPARE(itemRangeList, KItemRangeList() << KItemRange(1, 1));
1644
1645     // Re-sorting is done asynchronously:
1646     QCOMPARE(itemsInModel(),
1647              QStringList() << "b.txt"
1648                            << "a.txt"); // Files should still be in the incorrect order
1649     QVERIFY(itemsMovedSpy.wait());
1650     QCOMPARE(itemsInModel(),
1651              QStringList() << "a.txt"
1652                            << "b.txt"); // Files were re-sorted and should now be in the correct order
1653 }
1654
1655 /**
1656  * Verifies that parental chains are hidden and shown as needed while their children get filtered/unfiltered due to renaming.
1657  * Also verifies that the "isExpanded" and "expandedParentsCount" values are kept for expanded folders that get refreshed.
1658  */
1659 void KFileItemModelTest::testRefreshExpandedFolderWithFilter()
1660 {
1661     QSignalSpy itemsInsertedSpy(m_model, &KFileItemModel::itemsInserted);
1662     QSignalSpy itemsRemovedSpy(m_model, &KFileItemModel::itemsRemoved);
1663
1664     QSet<QByteArray> modelRoles = m_model->roles();
1665     modelRoles << "isExpanded"
1666                << "isExpandable"
1667                << "expandedParentsCount";
1668     m_model->setRoles(modelRoles);
1669
1670     m_testDir->createFile("a/b/someFolder/someFile");
1671
1672     m_model->loadDirectory(m_testDir->url());
1673     QVERIFY(itemsInsertedSpy.wait());
1674
1675     QCOMPARE(m_model->count(), 1); // Only "a/"
1676
1677     // Expand "a/".
1678     m_model->setExpanded(0, true);
1679     QVERIFY(itemsInsertedSpy.wait());
1680
1681     // Expand "a/b/".
1682     m_model->setExpanded(1, true);
1683     QVERIFY(itemsInsertedSpy.wait());
1684
1685     // Expand "a/b/someFolder/".
1686     m_model->setExpanded(2, true);
1687     QVERIFY(itemsInsertedSpy.wait());
1688     QCOMPARE(m_model->count(), 4); // 4 items: "a/", "a/b/", "a/b/someFolder", "a/b/someFolder/someFile"
1689
1690     // Set a filter that matches the expanded folder "someFolder"
1691     m_model->setNameFilter("someFolder");
1692     QCOMPARE(m_model->count(), 3); // 3 items: "a/", "a/b/", "a/b/someFolder"
1693
1694     // Objects used to rename
1695     const KFileItem fileItemA = m_model->fileItem(0);
1696     KFileItem fileItemARenamed = fileItemA;
1697     fileItemARenamed.setUrl(QUrl("a_renamed"));
1698
1699     const KFileItem fileItemSomeFolder = m_model->fileItem(2);
1700     KFileItem fileItemRenamedFolder = fileItemSomeFolder;
1701     fileItemRenamedFolder.setUrl(QUrl("/a_renamed/b/renamedFolder"));
1702
1703     // Rename "a" to "a_renamed"
1704     // This way we test if the algorithm is sane as to NOT hide "a_renamed" since it will have visible children
1705     m_model->slotRefreshItems({qMakePair(fileItemA, fileItemARenamed)});
1706     QCOMPARE(m_model->count(), 3); // Entire parental chain must still be shown
1707     QCOMPARE(itemsInModel(),
1708              QStringList() << "a_renamed"
1709                            << "b"
1710                            << "someFolder");
1711
1712     // Rename "a_renamed" back to "a"; and "someFolder" to "renamedFolder"
1713     m_model->slotRefreshItems({qMakePair(fileItemARenamed, fileItemA), qMakePair(fileItemSomeFolder, fileItemRenamedFolder)});
1714     QCOMPARE(m_model->count(), 0); // Entire parental chain became hidden
1715
1716     // Rename "renamedFolder" back to "someFolder". Filter is passing again
1717     m_model->slotRefreshItems({qMakePair(fileItemRenamedFolder, fileItemSomeFolder)});
1718     QCOMPARE(m_model->count(), 3); // Entire parental chain is shown again
1719     QCOMPARE(itemsInModel(),
1720              QStringList() << "a"
1721                            << "b"
1722                            << "someFolder");
1723
1724     // slotRefreshItems() should preserve "isExpanded" and "expandedParentsCount" values explicitly in this case
1725     QCOMPARE(m_model->m_itemData.at(2)->values.value("isExpanded").toBool(), true);
1726     QCOMPARE(m_model->m_itemData.at(2)->values.value("expandedParentsCount"), 2);
1727 }
1728
1729 /**
1730  * Verify that removing hidden files and folders from the model does not
1731  * result in a crash, see https://bugs.kde.org/show_bug.cgi?id=314046
1732  */
1733 void KFileItemModelTest::testRemoveHiddenItems()
1734 {
1735     m_testDir->createDir(".a");
1736     m_testDir->createDir(".b");
1737     m_testDir->createDir("c");
1738     m_testDir->createDir("d");
1739     m_testDir->createFiles({".f", ".g", "h", "i"});
1740
1741     QSignalSpy itemsInsertedSpy(m_model, &KFileItemModel::itemsInserted);
1742     QSignalSpy itemsRemovedSpy(m_model, &KFileItemModel::itemsRemoved);
1743
1744     m_model->setShowHiddenFiles(true);
1745     m_model->loadDirectory(m_testDir->url());
1746     QVERIFY(itemsInsertedSpy.wait());
1747     QCOMPARE(itemsInModel(),
1748              QStringList() << ".a"
1749                            << ".b"
1750                            << "c"
1751                            << "d"
1752                            << ".f"
1753                            << ".g"
1754                            << "h"
1755                            << "i");
1756     QCOMPARE(itemsInsertedSpy.count(), 1);
1757     QCOMPARE(itemsRemovedSpy.count(), 0);
1758     KItemRangeList itemRangeList = itemsInsertedSpy.takeFirst().at(0).value<KItemRangeList>();
1759     QCOMPARE(itemRangeList, KItemRangeList() << KItemRange(0, 8));
1760
1761     m_model->setShowHiddenFiles(false);
1762     QCOMPARE(itemsInModel(),
1763              QStringList() << "c"
1764                            << "d"
1765                            << "h"
1766                            << "i");
1767     QCOMPARE(itemsInsertedSpy.count(), 0);
1768     QCOMPARE(itemsRemovedSpy.count(), 1);
1769     itemRangeList = itemsRemovedSpy.takeFirst().at(0).value<KItemRangeList>();
1770     QCOMPARE(itemRangeList, KItemRangeList() << KItemRange(0, 2) << KItemRange(4, 2));
1771
1772     m_model->setShowHiddenFiles(true);
1773     QCOMPARE(itemsInModel(),
1774              QStringList() << ".a"
1775                            << ".b"
1776                            << "c"
1777                            << "d"
1778                            << ".f"
1779                            << ".g"
1780                            << "h"
1781                            << "i");
1782     QCOMPARE(itemsInsertedSpy.count(), 1);
1783     QCOMPARE(itemsRemovedSpy.count(), 0);
1784     itemRangeList = itemsInsertedSpy.takeFirst().at(0).value<KItemRangeList>();
1785     QCOMPARE(itemRangeList, KItemRangeList() << KItemRange(0, 2) << KItemRange(2, 2));
1786
1787     m_model->clear();
1788     QCOMPARE(itemsInModel(), QStringList());
1789     QCOMPARE(itemsInsertedSpy.count(), 0);
1790     QCOMPARE(itemsRemovedSpy.count(), 1);
1791     itemRangeList = itemsRemovedSpy.takeFirst().at(0).value<KItemRangeList>();
1792     QCOMPARE(itemRangeList, KItemRangeList() << KItemRange(0, 8));
1793
1794     // Hiding hidden files makes the dir lister emit its itemsDeleted signal.
1795     // Verify that this does not make the model crash.
1796     m_model->setShowHiddenFiles(false);
1797 }
1798
1799 /**
1800  * Verify that filtered items are removed when their parent is collapsed.
1801  */
1802 void KFileItemModelTest::collapseParentOfHiddenItems()
1803 {
1804     QSignalSpy itemsInsertedSpy(m_model, &KFileItemModel::itemsInserted);
1805     QSignalSpy itemsRemovedSpy(m_model, &KFileItemModel::itemsRemoved);
1806
1807     QSet<QByteArray> modelRoles = m_model->roles();
1808     modelRoles << "isExpanded"
1809                << "isExpandable"
1810                << "expandedParentsCount";
1811     m_model->setRoles(modelRoles);
1812
1813     m_testDir->createFiles({"a/1", "a/b/1", "a/b/c/1", "a/b/c/d/1"});
1814
1815     m_model->loadDirectory(m_testDir->url());
1816     QVERIFY(itemsInsertedSpy.wait());
1817     QCOMPARE(m_model->count(), 1); // Only "a/"
1818
1819     // Expand "a/".
1820     m_model->setExpanded(0, true);
1821     QVERIFY(itemsInsertedSpy.wait());
1822     QCOMPARE(m_model->count(), 3); // 3 items: "a/", "a/b/", "a/1"
1823
1824     // Expand "a/b/".
1825     m_model->setExpanded(1, true);
1826     QVERIFY(itemsInsertedSpy.wait());
1827     QCOMPARE(m_model->count(), 5); // 5 items: "a/", "a/b/", "a/b/c", "a/b/1", "a/1"
1828
1829     // Expand "a/b/c/".
1830     m_model->setExpanded(2, true);
1831     QVERIFY(itemsInsertedSpy.wait());
1832     QCOMPARE(m_model->count(), 7); // 7 items: "a/", "a/b/", "a/b/c", "a/b/c/d/", "a/b/c/1", "a/b/1", "a/1"
1833
1834     // Set a name filter that matches nothing -> nothing should remain.
1835     m_model->setNameFilter("xyz");
1836     QCOMPARE(itemsRemovedSpy.count(), 1);
1837     QCOMPARE(m_model->count(), 0); // Everything is hidden
1838     QCOMPARE(itemsInModel(), QStringList());
1839
1840     // Filter by the file names. Folder "d" will be hidden since it was collapsed
1841     m_model->setNameFilter("1");
1842     QCOMPARE(itemsRemovedSpy.count(), 1); // nothing was removed, itemsRemovedSpy count will remain the same:
1843     QCOMPARE(m_model->count(), 6); // 6 items: "a/", "a/b/", "a/b/c", "a/b/c/1", "a/b/1", "a/1"
1844
1845     // Collapse the folder "a/".
1846     m_model->setExpanded(0, false);
1847     QCOMPARE(itemsRemovedSpy.count(), 2);
1848     QCOMPARE(m_model->count(), 1);
1849     QCOMPARE(itemsInModel(), QStringList() << "a");
1850
1851     // Remove the filter -> "a" should still appear (and we should not get a crash).
1852     m_model->setNameFilter(QString());
1853     QCOMPARE(itemsRemovedSpy.count(), 2); // nothing was removed, itemsRemovedSpy count will remain the same:
1854     QCOMPARE(m_model->count(), 1);
1855     QCOMPARE(itemsInModel(), QStringList() << "a");
1856 }
1857
1858 /**
1859  * Verify that filtered items are removed when their parent is deleted.
1860  */
1861 void KFileItemModelTest::removeParentOfHiddenItems()
1862 {
1863     QSignalSpy itemsInsertedSpy(m_model, &KFileItemModel::itemsInserted);
1864     QSignalSpy itemsRemovedSpy(m_model, &KFileItemModel::itemsRemoved);
1865
1866     QSet<QByteArray> modelRoles = m_model->roles();
1867     modelRoles << "isExpanded"
1868                << "isExpandable"
1869                << "expandedParentsCount";
1870     m_model->setRoles(modelRoles);
1871
1872     m_testDir->createFiles({"a/1", "a/b/1", "a/b/c/1", "a/b/c/d/1"});
1873
1874     m_model->loadDirectory(m_testDir->url());
1875     QVERIFY(itemsInsertedSpy.wait());
1876     QCOMPARE(m_model->count(), 1); // Only "a/"
1877
1878     // Expand "a/".
1879     m_model->setExpanded(0, true);
1880     QVERIFY(itemsInsertedSpy.wait());
1881     QCOMPARE(m_model->count(), 3); // 3 items: "a/", "a/b/", "a/1"
1882
1883     // Expand "a/b/".
1884     m_model->setExpanded(1, true);
1885     QVERIFY(itemsInsertedSpy.wait());
1886     QCOMPARE(m_model->count(), 5); // 5 items: "a/", "a/b/", "a/b/c", "a/b/1", "a/1"
1887
1888     // Expand "a/b/c/".
1889     m_model->setExpanded(2, true);
1890     QVERIFY(itemsInsertedSpy.wait());
1891     QCOMPARE(m_model->count(), 7); // 7 items: "a/", "a/b/", "a/b/c", "a/b/c/d/", "a/b/c/1", "a/b/1", "a/1"
1892
1893     // Set a name filter that matches nothing -> nothing should remain.
1894     m_model->setNameFilter("xyz");
1895     QCOMPARE(itemsRemovedSpy.count(), 1);
1896     QCOMPARE(m_model->count(), 0);
1897     QCOMPARE(itemsInModel(), QStringList());
1898
1899     // Filter by "c". Folder "b" will also be shown because it is its parent.
1900     m_model->setNameFilter("c");
1901     QCOMPARE(itemsRemovedSpy.count(), 1); // nothing was removed, itemsRemovedSpy count will remain the same:
1902     QCOMPARE(m_model->count(), 3);
1903     QCOMPARE(itemsInModel(),
1904              QStringList() << "a"
1905                            << "b"
1906                            << "c");
1907
1908     // Simulate the deletion of the directory "a/b/".
1909     m_model->slotItemsDeleted(KFileItemList() << m_model->fileItem(1));
1910     QCOMPARE(itemsRemovedSpy.count(), 2);
1911     QCOMPARE(m_model->count(), 0); // "a" will be filtered out since it doesn't pass the filter and doesn't have visible children
1912
1913     // Remove the filter -> only the file "a/1" should appear.
1914     m_model->setNameFilter(QString());
1915     QCOMPARE(m_model->count(), 2);
1916     QCOMPARE(itemsInModel(),
1917              QStringList() << "a"
1918                            << "1");
1919 }
1920
1921 /**
1922  * Create a tree structure where parent-child relationships can not be
1923  * determined by parsing the URLs, and verify that KFileItemModel
1924  * handles them correctly.
1925  */
1926 void KFileItemModelTest::testGeneralParentChildRelationships()
1927 {
1928     QSignalSpy itemsInsertedSpy(m_model, &KFileItemModel::itemsInserted);
1929     QSignalSpy itemsRemovedSpy(m_model, &KFileItemModel::itemsRemoved);
1930
1931     QSet<QByteArray> modelRoles = m_model->roles();
1932     modelRoles << "isExpanded"
1933                << "isExpandable"
1934                << "expandedParentsCount";
1935     m_model->setRoles(modelRoles);
1936
1937     m_testDir->createFiles({"parent1/realChild1/realGrandChild1", "parent2/realChild2/realGrandChild2"});
1938
1939     m_model->loadDirectory(m_testDir->url());
1940     QVERIFY(itemsInsertedSpy.wait());
1941     QCOMPARE(itemsInModel(),
1942              QStringList() << "parent1"
1943                            << "parent2");
1944
1945     // Expand all folders.
1946     m_model->setExpanded(0, true);
1947     QVERIFY(itemsInsertedSpy.wait());
1948     QCOMPARE(itemsInModel(),
1949              QStringList() << "parent1"
1950                            << "realChild1"
1951                            << "parent2");
1952
1953     m_model->setExpanded(1, true);
1954     QVERIFY(itemsInsertedSpy.wait());
1955     QCOMPARE(itemsInModel(),
1956              QStringList() << "parent1"
1957                            << "realChild1"
1958                            << "realGrandChild1"
1959                            << "parent2");
1960
1961     m_model->setExpanded(3, true);
1962     QVERIFY(itemsInsertedSpy.wait());
1963     QCOMPARE(itemsInModel(),
1964              QStringList() << "parent1"
1965                            << "realChild1"
1966                            << "realGrandChild1"
1967                            << "parent2"
1968                            << "realChild2");
1969
1970     m_model->setExpanded(4, true);
1971     QVERIFY(itemsInsertedSpy.wait());
1972     QCOMPARE(itemsInModel(),
1973              QStringList() << "parent1"
1974                            << "realChild1"
1975                            << "realGrandChild1"
1976                            << "parent2"
1977                            << "realChild2"
1978                            << "realGrandChild2");
1979
1980     // Add some more children and grand-children.
1981     const QUrl parent1 = m_model->fileItem(0).url();
1982     const QUrl parent2 = m_model->fileItem(3).url();
1983     const QUrl realChild1 = m_model->fileItem(1).url();
1984     const QUrl realChild2 = m_model->fileItem(4).url();
1985
1986     m_model->slotItemsAdded(parent1, KFileItemList() << KFileItem(QUrl("child1"), QString(), KFileItem::Unknown));
1987     m_model->slotCompleted();
1988     QCOMPARE(itemsInModel(),
1989              QStringList() << "parent1"
1990                            << "realChild1"
1991                            << "realGrandChild1"
1992                            << "child1"
1993                            << "parent2"
1994                            << "realChild2"
1995                            << "realGrandChild2");
1996
1997     m_model->slotItemsAdded(parent2, KFileItemList() << KFileItem(QUrl("child2"), QString(), KFileItem::Unknown));
1998     m_model->slotCompleted();
1999     QCOMPARE(itemsInModel(),
2000              QStringList() << "parent1"
2001                            << "realChild1"
2002                            << "realGrandChild1"
2003                            << "child1"
2004                            << "parent2"
2005                            << "realChild2"
2006                            << "realGrandChild2"
2007                            << "child2");
2008
2009     m_model->slotItemsAdded(realChild1, KFileItemList() << KFileItem(QUrl("grandChild1"), QString(), KFileItem::Unknown));
2010     m_model->slotCompleted();
2011     QCOMPARE(itemsInModel(),
2012              QStringList() << "parent1"
2013                            << "realChild1"
2014                            << "grandChild1"
2015                            << "realGrandChild1"
2016                            << "child1"
2017                            << "parent2"
2018                            << "realChild2"
2019                            << "realGrandChild2"
2020                            << "child2");
2021
2022     m_model->slotItemsAdded(realChild2, KFileItemList() << KFileItem(QUrl("grandChild2"), QString(), KFileItem::Unknown));
2023     m_model->slotCompleted();
2024     QCOMPARE(itemsInModel(),
2025              QStringList() << "parent1"
2026                            << "realChild1"
2027                            << "grandChild1"
2028                            << "realGrandChild1"
2029                            << "child1"
2030                            << "parent2"
2031                            << "realChild2"
2032                            << "grandChild2"
2033                            << "realGrandChild2"
2034                            << "child2");
2035
2036     // Set a name filter that matches nothing -> nothing will remain.
2037     m_model->setNameFilter("xyz");
2038     QCOMPARE(itemsInModel(), QStringList());
2039     QCOMPARE(itemsRemovedSpy.count(), 1);
2040     QList<QVariant> arguments = itemsRemovedSpy.takeFirst();
2041     KItemRangeList itemRangeList = arguments.at(0).value<KItemRangeList>();
2042     QCOMPARE(itemRangeList, KItemRangeList() << KItemRange(0, 10));
2043
2044     // Set a name filter that matches only "realChild". Their prarents should still show.
2045     m_model->setNameFilter("realChild");
2046     QCOMPARE(itemsInModel(),
2047              QStringList() << "parent1"
2048                            << "realChild1"
2049                            << "parent2"
2050                            << "realChild2");
2051     QCOMPARE(itemsRemovedSpy.count(), 0); // nothing was removed, itemsRemovedSpy will not be called this time
2052
2053     // Collapse "parent1".
2054     m_model->setExpanded(0, false);
2055     QCOMPARE(itemsInModel(),
2056              QStringList() << "parent1"
2057                            << "parent2"
2058                            << "realChild2");
2059     QCOMPARE(itemsRemovedSpy.count(), 1);
2060     arguments = itemsRemovedSpy.takeFirst();
2061     itemRangeList = arguments.at(0).value<KItemRangeList>();
2062     QCOMPARE(itemRangeList, KItemRangeList() << KItemRange(1, 1));
2063
2064     // Remove "parent2".
2065     m_model->slotItemsDeleted(KFileItemList() << m_model->fileItem(1));
2066     QCOMPARE(itemsInModel(), QStringList() << "parent1");
2067     QCOMPARE(itemsRemovedSpy.count(), 1);
2068     arguments = itemsRemovedSpy.takeFirst();
2069     itemRangeList = arguments.at(0).value<KItemRangeList>();
2070     QCOMPARE(itemRangeList, KItemRangeList() << KItemRange(1, 2));
2071
2072     // Clear filter, verify that no items reappear.
2073     m_model->setNameFilter(QString());
2074     QCOMPARE(itemsInModel(), QStringList() << "parent1");
2075 }
2076
2077 void KFileItemModelTest::testNameRoleGroups()
2078 {
2079     QSignalSpy itemsInsertedSpy(m_model, &KFileItemModel::itemsInserted);
2080     QSignalSpy itemsMovedSpy(m_model, &KFileItemModel::itemsMoved);
2081     QVERIFY(itemsMovedSpy.isValid());
2082     QSignalSpy groupsChangedSpy(m_model, &KFileItemModel::groupsChanged);
2083     QVERIFY(groupsChangedSpy.isValid());
2084
2085     m_testDir->createFiles({"b.txt", "c.txt", "d.txt", "e.txt"});
2086
2087     m_model->setGroupedSorting(true);
2088     m_model->loadDirectory(m_testDir->url());
2089     QVERIFY(itemsInsertedSpy.wait());
2090     QCOMPARE(itemsInModel(),
2091              QStringList() << "b.txt"
2092                            << "c.txt"
2093                            << "d.txt"
2094                            << "e.txt");
2095
2096     QList<QPair<int, QVariant>> expectedGroups;
2097     expectedGroups << QPair<int, QVariant>(0, QLatin1String("B"));
2098     expectedGroups << QPair<int, QVariant>(1, QLatin1String("C"));
2099     expectedGroups << QPair<int, QVariant>(2, QLatin1String("D"));
2100     expectedGroups << QPair<int, QVariant>(3, QLatin1String("E"));
2101     QCOMPARE(m_model->groups(), expectedGroups);
2102
2103     // Rename d.txt to a.txt.
2104     QHash<QByteArray, QVariant> data;
2105     data.insert("text", "a.txt");
2106     m_model->setData(2, data);
2107     QVERIFY(itemsMovedSpy.wait());
2108     QCOMPARE(itemsInModel(),
2109              QStringList() << "a.txt"
2110                            << "b.txt"
2111                            << "c.txt"
2112                            << "e.txt");
2113
2114     expectedGroups.clear();
2115     expectedGroups << QPair<int, QVariant>(0, QLatin1String("A"));
2116     expectedGroups << QPair<int, QVariant>(1, QLatin1String("B"));
2117     expectedGroups << QPair<int, QVariant>(2, QLatin1String("C"));
2118     expectedGroups << QPair<int, QVariant>(3, QLatin1String("E"));
2119     QCOMPARE(m_model->groups(), expectedGroups);
2120
2121     // Rename c.txt to d.txt.
2122     data.insert("text", "d.txt");
2123     m_model->setData(2, data);
2124     QVERIFY(groupsChangedSpy.wait());
2125     QCOMPARE(itemsInModel(),
2126              QStringList() << "a.txt"
2127                            << "b.txt"
2128                            << "d.txt"
2129                            << "e.txt");
2130
2131     expectedGroups.clear();
2132     expectedGroups << QPair<int, QVariant>(0, QLatin1String("A"));
2133     expectedGroups << QPair<int, QVariant>(1, QLatin1String("B"));
2134     expectedGroups << QPair<int, QVariant>(2, QLatin1String("D"));
2135     expectedGroups << QPair<int, QVariant>(3, QLatin1String("E"));
2136     QCOMPARE(m_model->groups(), expectedGroups);
2137
2138     // Change d.txt back to c.txt, but this time using the dir lister's refreshItems() signal.
2139     const KFileItem fileItemD = m_model->fileItem(2);
2140     KFileItem fileItemC = fileItemD;
2141     QUrl urlC = fileItemC.url().adjusted(QUrl::RemoveFilename);
2142     urlC.setPath(urlC.path() + "c.txt");
2143     fileItemC.setUrl(urlC);
2144
2145     m_model->slotRefreshItems({qMakePair(fileItemD, fileItemC)});
2146     QVERIFY(groupsChangedSpy.wait());
2147     QCOMPARE(itemsInModel(),
2148              QStringList() << "a.txt"
2149                            << "b.txt"
2150                            << "c.txt"
2151                            << "e.txt");
2152
2153     expectedGroups.clear();
2154     expectedGroups << QPair<int, QVariant>(0, QLatin1String("A"));
2155     expectedGroups << QPair<int, QVariant>(1, QLatin1String("B"));
2156     expectedGroups << QPair<int, QVariant>(2, QLatin1String("C"));
2157     expectedGroups << QPair<int, QVariant>(3, QLatin1String("E"));
2158     QCOMPARE(m_model->groups(), expectedGroups);
2159 }
2160
2161 void KFileItemModelTest::testNameRoleGroupsWithExpandedItems()
2162 {
2163     QSignalSpy itemsInsertedSpy(m_model, &KFileItemModel::itemsInserted);
2164
2165     QSet<QByteArray> modelRoles = m_model->roles();
2166     modelRoles << "isExpanded"
2167                << "isExpandable"
2168                << "expandedParentsCount";
2169     m_model->setRoles(modelRoles);
2170
2171     m_testDir->createFiles({"a/b.txt", "a/c.txt", "d/e.txt", "d/f.txt"});
2172
2173     m_model->setGroupedSorting(true);
2174     m_model->loadDirectory(m_testDir->url());
2175     QVERIFY(itemsInsertedSpy.wait());
2176     QCOMPARE(itemsInModel(),
2177              QStringList() << "a"
2178                            << "d");
2179
2180     QList<QPair<int, QVariant>> expectedGroups;
2181     expectedGroups << QPair<int, QVariant>(0, QLatin1String("A"));
2182     expectedGroups << QPair<int, QVariant>(1, QLatin1String("D"));
2183     QCOMPARE(m_model->groups(), expectedGroups);
2184
2185     // Verify that expanding "a" and "d" will not change the groups (except for the index of "D").
2186     expectedGroups.clear();
2187     expectedGroups << QPair<int, QVariant>(0, QLatin1String("A"));
2188     expectedGroups << QPair<int, QVariant>(3, QLatin1String("D"));
2189
2190     m_model->setExpanded(0, true);
2191     QVERIFY(m_model->isExpanded(0));
2192     QVERIFY(itemsInsertedSpy.wait());
2193     QCOMPARE(itemsInModel(),
2194              QStringList() << "a"
2195                            << "b.txt"
2196                            << "c.txt"
2197                            << "d");
2198     QCOMPARE(m_model->groups(), expectedGroups);
2199
2200     m_model->setExpanded(3, true);
2201     QVERIFY(m_model->isExpanded(3));
2202     QVERIFY(itemsInsertedSpy.wait());
2203     QCOMPARE(itemsInModel(),
2204              QStringList() << "a"
2205                            << "b.txt"
2206                            << "c.txt"
2207                            << "d"
2208                            << "e.txt"
2209                            << "f.txt");
2210     QCOMPARE(m_model->groups(), expectedGroups);
2211 }
2212
2213 void KFileItemModelTest::testInconsistentModel()
2214 {
2215     QSignalSpy itemsInsertedSpy(m_model, &KFileItemModel::itemsInserted);
2216
2217     QSet<QByteArray> modelRoles = m_model->roles();
2218     modelRoles << "isExpanded"
2219                << "isExpandable"
2220                << "expandedParentsCount";
2221     m_model->setRoles(modelRoles);
2222
2223     m_testDir->createFiles({"a/b/c1.txt", "a/b/c2.txt"});
2224
2225     m_model->loadDirectory(m_testDir->url());
2226     QVERIFY(itemsInsertedSpy.wait());
2227     QCOMPARE(itemsInModel(), QStringList() << "a");
2228
2229     // Expand "a/" and "a/b/".
2230     m_model->setExpanded(0, true);
2231     QVERIFY(m_model->isExpanded(0));
2232     QVERIFY(itemsInsertedSpy.wait());
2233     QCOMPARE(itemsInModel(),
2234              QStringList() << "a"
2235                            << "b");
2236
2237     m_model->setExpanded(1, true);
2238     QVERIFY(m_model->isExpanded(1));
2239     QVERIFY(itemsInsertedSpy.wait());
2240     QCOMPARE(itemsInModel(),
2241              QStringList() << "a"
2242                            << "b"
2243                            << "c1.txt"
2244                            << "c2.txt");
2245
2246     // Add the files "c1.txt" and "c2.txt" to the model also as top-level items.
2247     // Such a thing can in principle happen when performing a search, and there
2248     // are files which
2249     // (a) match the search string, and
2250     // (b) are children of a folder that matches the search string and is expanded.
2251     //
2252     // Note that the first item in the list of added items must be new (i.e., not
2253     // in the model yet). Otherwise, KFileItemModel::slotItemsAdded() will see that
2254     // it receives items that are in the model already and ignore them.
2255     QUrl url(m_model->directory().url() + "/a2");
2256     KFileItem newItem(url);
2257
2258     KFileItemList items;
2259     items << newItem << m_model->fileItem(2) << m_model->fileItem(3);
2260     m_model->slotItemsAdded(m_model->directory(), items);
2261     m_model->slotCompleted();
2262     QCOMPARE(itemsInModel(),
2263              QStringList() << "a"
2264                            << "b"
2265                            << "c1.txt"
2266                            << "c2.txt"
2267                            << "a2"
2268                            << "c1.txt"
2269                            << "c2.txt");
2270
2271     m_model->setExpanded(0, false);
2272
2273     // Test that the right items have been removed, see
2274     // https://bugs.kde.org/show_bug.cgi?id=324371
2275     QCOMPARE(itemsInModel(),
2276              QStringList() << "a"
2277                            << "a2"
2278                            << "c1.txt"
2279                            << "c2.txt");
2280
2281     // Test that resorting does not cause a crash, see
2282     // https://bugs.kde.org/show_bug.cgi?id=325359
2283     // The crash is not 100% reproducible, but Valgrind will report an invalid memory access.
2284     m_model->resortAllItems();
2285 }
2286
2287 void KFileItemModelTest::testChangeRolesForFilteredItems()
2288 {
2289     QSignalSpy itemsInsertedSpy(m_model, &KFileItemModel::itemsInserted);
2290
2291     QSet<QByteArray> modelRoles = m_model->roles();
2292     modelRoles << "owner";
2293     m_model->setRoles(modelRoles);
2294
2295     m_testDir->createFiles({"a.txt", "aa.txt", "aaa.txt"});
2296
2297     m_model->loadDirectory(m_testDir->url());
2298     QVERIFY(itemsInsertedSpy.wait());
2299     QCOMPARE(itemsInModel(),
2300              QStringList() << "a.txt"
2301                            << "aa.txt"
2302                            << "aaa.txt");
2303
2304     for (int index = 0; index < m_model->count(); ++index) {
2305         // All items should have the "text" and "owner" roles, but not "group".
2306         QVERIFY(m_model->data(index).contains("text"));
2307         QVERIFY(m_model->data(index).contains("owner"));
2308         QVERIFY(!m_model->data(index).contains("group"));
2309     }
2310
2311     // Add a filter, such that only "aaa.txt" remains in the model.
2312     m_model->setNameFilter("aaa");
2313     QCOMPARE(itemsInModel(), QStringList() << "aaa.txt");
2314
2315     // Add the "group" role.
2316     modelRoles << "group";
2317     m_model->setRoles(modelRoles);
2318
2319     // Modify the filter, such that "aa.txt" reappears, and verify that all items have the expected roles.
2320     m_model->setNameFilter("aa");
2321     QCOMPARE(itemsInModel(),
2322              QStringList() << "aa.txt"
2323                            << "aaa.txt");
2324
2325     for (int index = 0; index < m_model->count(); ++index) {
2326         // All items should have the "text", "owner", and "group" roles.
2327         QVERIFY(m_model->data(index).contains("text"));
2328         QVERIFY(m_model->data(index).contains("owner"));
2329         QVERIFY(m_model->data(index).contains("group"));
2330     }
2331
2332     // Remove the "owner" role.
2333     modelRoles.remove("owner");
2334     m_model->setRoles(modelRoles);
2335
2336     // Clear the filter, and verify that all items have the expected roles
2337     m_model->setNameFilter(QString());
2338     QCOMPARE(itemsInModel(),
2339              QStringList() << "a.txt"
2340                            << "aa.txt"
2341                            << "aaa.txt");
2342
2343     for (int index = 0; index < m_model->count(); ++index) {
2344         // All items should have the "text" and "group" roles, but now "owner".
2345         QVERIFY(m_model->data(index).contains("text"));
2346         QVERIFY(!m_model->data(index).contains("owner"));
2347         QVERIFY(m_model->data(index).contains("group"));
2348     }
2349 }
2350
2351 void KFileItemModelTest::testChangeSortRoleWhileFiltering()
2352 {
2353     KFileItemList items;
2354
2355     KIO::UDSEntry entry[3];
2356
2357     entry[0].fastInsert(KIO::UDSEntry::UDS_NAME, "a.txt");
2358     entry[0].fastInsert(KIO::UDSEntry::UDS_USER, "user-b");
2359
2360     entry[1].fastInsert(KIO::UDSEntry::UDS_NAME, "b.txt");
2361     entry[1].fastInsert(KIO::UDSEntry::UDS_USER, "user-c");
2362
2363     entry[2].fastInsert(KIO::UDSEntry::UDS_NAME, "c.txt");
2364     entry[2].fastInsert(KIO::UDSEntry::UDS_USER, "user-a");
2365
2366     for (int i = 0; i < 3; ++i) {
2367         entry[i].fastInsert(KIO::UDSEntry::UDS_FILE_TYPE, 0100000); // S_IFREG might not be defined on non-Unix platforms.
2368         entry[i].fastInsert(KIO::UDSEntry::UDS_ACCESS, 07777);
2369         entry[i].fastInsert(KIO::UDSEntry::UDS_SIZE, 0);
2370         entry[i].fastInsert(KIO::UDSEntry::UDS_MODIFICATION_TIME, 0);
2371         entry[i].fastInsert(KIO::UDSEntry::UDS_GROUP, "group");
2372         entry[i].fastInsert(KIO::UDSEntry::UDS_ACCESS_TIME, 0);
2373         items.append(KFileItem(entry[i], m_testDir->url(), false, true));
2374     }
2375
2376     m_model->slotItemsAdded(m_testDir->url(), items);
2377     m_model->slotCompleted();
2378
2379     QCOMPARE(itemsInModel(),
2380              QStringList() << "a.txt"
2381                            << "b.txt"
2382                            << "c.txt");
2383
2384     // Add a filter.
2385     m_model->setNameFilter("a");
2386     QCOMPARE(itemsInModel(), QStringList() << "a.txt");
2387
2388     // Sort by "owner".
2389     m_model->setSortRole("owner");
2390
2391     // Clear the filter, and verify that the items are sorted correctly.
2392     m_model->setNameFilter(QString());
2393     QCOMPARE(itemsInModel(),
2394              QStringList() << "c.txt"
2395                            << "a.txt"
2396                            << "b.txt");
2397 }
2398
2399 void KFileItemModelTest::testRefreshFilteredItems()
2400 {
2401     QSignalSpy itemsInsertedSpy(m_model, &KFileItemModel::itemsInserted);
2402
2403     m_testDir->createFiles({"a.txt", "b.txt", "c.jpg", "d.jpg"});
2404
2405     m_model->loadDirectory(m_testDir->url());
2406     QVERIFY(itemsInsertedSpy.wait());
2407     QCOMPARE(itemsInModel(),
2408              QStringList() << "a.txt"
2409                            << "b.txt"
2410                            << "c.jpg"
2411                            << "d.jpg");
2412
2413     const KFileItem fileItemC = m_model->fileItem(2);
2414
2415     // Show only the .txt files.
2416     m_model->setNameFilter(".txt");
2417     QCOMPARE(itemsInModel(),
2418              QStringList() << "a.txt"
2419                            << "b.txt");
2420
2421     // Rename one of the .jpg files.
2422     KFileItem fileItemE = fileItemC;
2423     QUrl urlE = fileItemE.url().adjusted(QUrl::RemoveFilename);
2424     urlE.setPath(urlE.path() + "/e.jpg");
2425     fileItemE.setUrl(urlE);
2426
2427     m_model->slotRefreshItems({qMakePair(fileItemC, fileItemE)});
2428
2429     // Show all files again, and verify that the model has updated the file name.
2430     m_model->setNameFilter(QString());
2431     QCOMPARE(itemsInModel(),
2432              QStringList() << "a.txt"
2433                            << "b.txt"
2434                            << "d.jpg"
2435                            << "e.jpg");
2436 }
2437
2438 void KFileItemModelTest::testCreateMimeData()
2439 {
2440     QSignalSpy itemsInsertedSpy(m_model, &KFileItemModel::itemsInserted);
2441
2442     QSet<QByteArray> modelRoles = m_model->roles();
2443     modelRoles << "isExpanded"
2444                << "isExpandable"
2445                << "expandedParentsCount";
2446     m_model->setRoles(modelRoles);
2447
2448     m_testDir->createFile("a/1");
2449
2450     m_model->loadDirectory(m_testDir->url());
2451     QVERIFY(itemsInsertedSpy.wait());
2452     QCOMPARE(itemsInModel(), QStringList() << "a");
2453
2454     // Expand "a/".
2455     m_model->setExpanded(0, true);
2456     QVERIFY(itemsInsertedSpy.wait());
2457     QCOMPARE(itemsInModel(),
2458              QStringList() << "a"
2459                            << "1");
2460
2461     // Verify that creating the MIME data for a child of an expanded folder does
2462     // not cause a crash, see https://bugs.kde.org/show_bug.cgi?id=329119
2463     KItemSet selection;
2464     selection.insert(1);
2465     QMimeData *mimeData = m_model->createMimeData(selection);
2466     delete mimeData;
2467 }
2468
2469 void KFileItemModelTest::testCollapseFolderWhileLoading()
2470 {
2471     QSignalSpy itemsInsertedSpy(m_model, &KFileItemModel::itemsInserted);
2472
2473     QSet<QByteArray> modelRoles = m_model->roles();
2474     modelRoles << "isExpanded"
2475                << "isExpandable"
2476                << "expandedParentsCount";
2477     m_model->setRoles(modelRoles);
2478
2479     m_testDir->createFile("a2/b/c1.txt");
2480
2481     m_model->loadDirectory(m_testDir->url());
2482     QVERIFY(itemsInsertedSpy.wait());
2483     QCOMPARE(itemsInModel(), QStringList() << "a2");
2484
2485     // Expand "a2/".
2486     m_model->setExpanded(0, true);
2487     QVERIFY(m_model->isExpanded(0));
2488     QVERIFY(itemsInsertedSpy.wait());
2489     QCOMPARE(itemsInModel(),
2490              QStringList() << "a2"
2491                            << "b");
2492
2493     // Expand "a2/b/".
2494     m_model->setExpanded(1, true);
2495     QVERIFY(m_model->isExpanded(1));
2496     QVERIFY(itemsInsertedSpy.wait());
2497     QCOMPARE(itemsInModel(),
2498              QStringList() << "a2"
2499                            << "b"
2500                            << "c1.txt");
2501
2502     // Simulate that a new item "c2.txt" appears, but that the dir lister's completed()
2503     // signal is not emitted yet.
2504     const KFileItem fileItemC1 = m_model->fileItem(2);
2505     KFileItem fileItemC2 = fileItemC1;
2506     QUrl urlC2 = fileItemC2.url();
2507     urlC2 = urlC2.adjusted(QUrl::RemoveFilename);
2508     urlC2.setPath(urlC2.path() + "c2.txt");
2509     fileItemC2.setUrl(urlC2);
2510
2511     const QUrl urlB = m_model->fileItem(1).url();
2512     m_model->slotItemsAdded(urlB, KFileItemList() << fileItemC2);
2513     QCOMPARE(itemsInModel(),
2514              QStringList() << "a2"
2515                            << "b"
2516                            << "c1.txt");
2517
2518     // Collapse "a2/". This should also remove all its (indirect) children from
2519     // the model and from the model's m_pendingItemsToInsert member.
2520     m_model->setExpanded(0, false);
2521     QCOMPARE(itemsInModel(), QStringList() << "a2");
2522
2523     // Simulate that the dir lister's completed() signal is emitted. If "c2.txt"
2524     // is still in m_pendingItemsToInsert, then we might get a crash, see
2525     // https://bugs.kde.org/show_bug.cgi?id=332102. Even if the crash is not
2526     // reproducible here, Valgrind will complain, and the item "c2.txt" will appear
2527     // without parent in the model.
2528     m_model->slotCompleted();
2529     QCOMPARE(itemsInModel(), QStringList() << "a2");
2530
2531     // Expand "a2/" again.
2532     m_model->setExpanded(0, true);
2533     QVERIFY(m_model->isExpanded(0));
2534     QVERIFY(itemsInsertedSpy.wait());
2535     QCOMPARE(itemsInModel(),
2536              QStringList() << "a2"
2537                            << "b");
2538
2539     // Now simulate that a new folder "a1/" is appears, but that the dir lister's
2540     // completed() signal is not emitted yet.
2541     const KFileItem fileItemA2 = m_model->fileItem(0);
2542     KFileItem fileItemA1 = fileItemA2;
2543     QUrl urlA1 = fileItemA1.url().adjusted(QUrl::RemoveFilename);
2544     urlA1.setPath(urlA1.path() + "a1");
2545     fileItemA1.setUrl(urlA1);
2546
2547     m_model->slotItemsAdded(m_model->directory(), KFileItemList() << fileItemA1);
2548     QCOMPARE(itemsInModel(),
2549              QStringList() << "a2"
2550                            << "b");
2551
2552     // Collapse "a2/". Note that this will cause "a1/" to be added to the model,
2553     // i.e., the index of "a2/" will change from 0 to 1. Check that this does not
2554     // confuse the code which collapses the folder.
2555     m_model->setExpanded(0, false);
2556     QCOMPARE(itemsInModel(),
2557              QStringList() << "a1"
2558                            << "a2");
2559     QVERIFY(!m_model->isExpanded(0));
2560     QVERIFY(!m_model->isExpanded(1));
2561 }
2562
2563 void KFileItemModelTest::testDeleteFileMoreThanOnce()
2564 {
2565     QSignalSpy itemsInsertedSpy(m_model, &KFileItemModel::itemsInserted);
2566
2567     m_testDir->createFiles({"a.txt", "b.txt", "c.txt", "d.txt"});
2568
2569     m_model->loadDirectory(m_testDir->url());
2570     QVERIFY(itemsInsertedSpy.wait());
2571     QCOMPARE(itemsInModel(),
2572              QStringList() << "a.txt"
2573                            << "b.txt"
2574                            << "c.txt"
2575                            << "d.txt");
2576
2577     const KFileItem fileItemB = m_model->fileItem(1);
2578
2579     // Tell the model that a list of items has been deleted, where "b.txt" appears twice in the list.
2580     KFileItemList list;
2581     list << fileItemB << fileItemB;
2582     m_model->slotItemsDeleted(list);
2583
2584     QVERIFY(m_model->isConsistent());
2585     QCOMPARE(itemsInModel(),
2586              QStringList() << "a.txt"
2587                            << "c.txt"
2588                            << "d.txt");
2589 }
2590
2591 void KFileItemModelTest::testInsertAfterExpand()
2592 {
2593     m_model->m_dirLister->setAutoUpdate(true);
2594
2595     QSignalSpy itemsInsertedSpy(m_model, &KFileItemModel::itemsInserted);
2596     QVERIFY(itemsInsertedSpy.isValid());
2597     QSignalSpy itemsRemovedSpy(m_model, &KFileItemModel::itemsRemoved);
2598     QVERIFY(itemsRemovedSpy.isValid());
2599     QSignalSpy loadingCompletedSpy(m_model, &KFileItemModel::directoryLoadingCompleted);
2600     QVERIFY(loadingCompletedSpy.isValid());
2601
2602     // Test expanding subfolders in a folder with the items "a/", "a/a/"
2603     QSet<QByteArray> originalModelRoles = m_model->roles();
2604     QSet<QByteArray> modelRoles = originalModelRoles;
2605     modelRoles << "isExpanded"
2606                << "isExpandable"
2607                << "expandedParentsCount";
2608     m_model->setRoles(modelRoles);
2609
2610     m_testDir->createFile("a/b/1");
2611
2612     m_model->loadDirectory(m_testDir->url());
2613     QVERIFY(itemsInsertedSpy.wait());
2614
2615     // So far, the model contains only "a/"
2616     QCOMPARE(m_model->count(), 1);
2617     QVERIFY(m_model->isExpandable(0));
2618     QVERIFY(!m_model->isExpanded(0));
2619     QVERIFY(m_model->expandedDirectories().empty());
2620
2621     QCOMPARE(itemsInsertedSpy.count(), 1);
2622     {
2623         KItemRangeList itemRangeList = itemsInsertedSpy.takeFirst().at(0).value<KItemRangeList>();
2624         QCOMPARE(itemRangeList, KItemRangeList() << KItemRange(0, 1)); // 1 new item "a/" with index 0
2625         QCOMPARE(m_model->expandedParentsCount(0), 0);
2626     }
2627     itemsInsertedSpy.clear();
2628
2629     // Expand the folder "a/" -> "a/b" become visible
2630     m_model->setExpanded(0, true);
2631     QVERIFY(m_model->isExpanded(0));
2632     QVERIFY(itemsInsertedSpy.wait());
2633     QCOMPARE(m_model->count(), 2); // 3 items: "a/", "a/a/"
2634     QCOMPARE(m_model->expandedDirectories(), QSet<QUrl>({QUrl::fromLocalFile(m_testDir->path() + "/a")}));
2635
2636     QCOMPARE(itemsInsertedSpy.count(), 1);
2637     {
2638         KItemRangeList itemRangeList = itemsInsertedSpy.takeFirst().at(0).value<KItemRangeList>();
2639         QCOMPARE(itemRangeList, KItemRangeList() << KItemRange(1, 1)); // 1 new item "a/b" with index 1
2640         QCOMPARE(m_model->expandedParentsCount(1), 1);
2641     }
2642     itemsInsertedSpy.clear();
2643
2644     // Expand "a/b" -> "a/b/1" becomes visible
2645     m_model->setExpanded(1, true);
2646     QVERIFY(itemsInsertedSpy.wait());
2647     QCOMPARE(m_model->expandedDirectories(), QSet({QUrl::fromLocalFile(m_testDir->path() + "/a"), QUrl::fromLocalFile(m_testDir->path() + "/a/b")}));
2648
2649     QCOMPARE(itemsInsertedSpy.count(), 1);
2650     {
2651         KItemRangeList itemRangeList = itemsInsertedSpy.takeFirst().at(0).value<KItemRangeList>();
2652         QCOMPARE(itemRangeList, KItemRangeList() << KItemRange(2, 1)); // 1 new item "a/b/1" with index 2
2653         QCOMPARE(m_model->expandedParentsCount(2), 2);
2654     }
2655     itemsInsertedSpy.clear();
2656
2657     // Collapse "a" whilst leaving "b" expanded
2658     m_model->setExpanded(0, false);
2659
2660     // Insert additional files into "a/b/"
2661     m_testDir->createFile("a/b/2");
2662
2663     QVERIFY(!itemsInsertedSpy.wait(5000));
2664
2665     QCOMPARE(itemsInModel(), {"a"});
2666
2667     m_model->setExpanded(0, true);
2668     ;
2669     QTRY_COMPARE(itemsInModel(), QStringList({"a", "b", "1", "2"}));
2670
2671     QCOMPARE(m_model->expandedParentsCount(0), 0); // a
2672     QCOMPARE(m_model->expandedParentsCount(1), 1); // a/b
2673     QCOMPARE(m_model->expandedParentsCount(2), 2); // a/b/1
2674     QCOMPARE(m_model->expandedParentsCount(3), 2); // a/b/2
2675 }
2676
2677 void KFileItemModelTest::testCurrentDirRemoved()
2678 {
2679     m_model->m_dirLister->setAutoUpdate(true);
2680     QSignalSpy currentDirectoryRemovedSpy(m_model, &KFileItemModel::currentDirectoryRemoved);
2681     QVERIFY(currentDirectoryRemovedSpy.isValid());
2682     QSignalSpy loadingCompletedSpy(m_model, &KFileItemModel::directoryLoadingCompleted);
2683     QVERIFY(loadingCompletedSpy.isValid());
2684     QSignalSpy dirListerClearSpy(m_model->m_dirLister, &KCoreDirLister::clear);
2685     QVERIFY(dirListerClearSpy.isValid());
2686
2687     m_testDir->createFiles({"dir/a.txt", "dir/b.txt"});
2688     m_model->loadDirectory(QUrl::fromLocalFile(m_testDir->path() + "/dir/"));
2689     QVERIFY(loadingCompletedSpy.wait());
2690     QCOMPARE(m_model->count(), 2);
2691     QVERIFY(m_model->isConsistent());
2692
2693     m_testDir->removeDir("dir");
2694     QVERIFY(currentDirectoryRemovedSpy.wait());
2695
2696     // dirLister calls clear
2697     QCOMPARE(dirListerClearSpy.count(), 2);
2698     QVERIFY(m_model->isConsistent());
2699     QVERIFY(m_model->m_itemData.isEmpty());
2700     QCOMPARE(m_model->count(), 0);
2701 }
2702
2703 QStringList KFileItemModelTest::itemsInModel() const
2704 {
2705     QStringList items;
2706     for (int i = 0; i < m_model->count(); i++) {
2707         items << m_model->fileItem(i).text();
2708     }
2709     return items;
2710 }
2711
2712 QTEST_MAIN(KFileItemModelTest)
2713
2714 #include "kfileitemmodeltest.moc"