src/tests/kfileitemmodelbenchmark.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2011 by Peter Penz <peter.penz19@gmail.com>             *
   3  *   Copyright (C) 2013 by Frank Reininghaus <frank78ac@googlemail.com>    *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA            *
  19  ***************************************************************************/
  20
  21 #include <QTest>
  22 #include <QSignalSpy>
  23
  24 #include <algorithm>
  25 #include <random>
  26
  27 #include "kitemviews/kfileitemmodel.h"
  28 #include "kitemviews/private/kfileitemmodelsortalgorithm.h"
  29
  30 #include "testdir.h"
  31
  32 void myMessageOutput(QtMsgType type, const QMessageLogContext& context, const QString& msg)
  33 {
  34     Q_UNUSED(context);
  35
  36     switch (type) {
  37     case QtDebugMsg:
  38         break;
  39     case QtWarningMsg:
  40         break;
  41     case QtCriticalMsg:
  42         fprintf(stderr, "Critical: %s\n", msg.toLocal8Bit().data());
  43         break;
  44     case QtFatalMsg:
  45         fprintf(stderr, "Fatal: %s\n", msg.toLocal8Bit().data());
  46         abort();
  47     default:
  48        break;
  49     }
  50 }
  51
  52 Q_DECLARE_METATYPE(KFileItemList)
  53 Q_DECLARE_METATYPE(KItemRangeList)
  54
  55 class KFileItemModelBenchmark : public QObject
  56 {
  57     Q_OBJECT
  58
  59 public:
  60     KFileItemModelBenchmark();
  61
  62 private slots:
  63     void insertAndRemoveManyItems_data();
  64     void insertAndRemoveManyItems();
  65
  66 private:
  67     static KFileItemList createFileItemList(const QStringList& fileNames, const QString& urlPrefix = QLatin1String("file:///"));
  68 };
  69
  70 KFileItemModelBenchmark::KFileItemModelBenchmark()
  71 {
  72 }
  73
  74 void KFileItemModelBenchmark::insertAndRemoveManyItems_data()
  75 {
  76     QTest::addColumn<KFileItemList>("initialItems");
  77     QTest::addColumn<KFileItemList>("newItems");
  78     QTest::addColumn<KFileItemList>("removedItems");
  79     QTest::addColumn<KFileItemList>("expectedFinalItems");
  80     QTest::addColumn<KItemRangeList>("expectedItemsInserted");
  81     QTest::addColumn<KItemRangeList>("expectedItemsRemoved");
  82
  83     QList<int> sizes;
  84     sizes << 1000 << 4000 << 16000 << 64000 << 256000;
  85     //sizes << 50000 << 100000 << 150000 << 200000 << 250000;
  86
  87     foreach (int n, sizes) {
  88         QStringList allStrings;
  89         for (int i = 0; i < n; ++i) {
  90             allStrings << QString::number(i);
  91         }
  92
  93         // We want to keep the sorting overhead in the benchmark low.
  94         // Therefore, we do not use natural sorting. However, this
  95         // means that our list is currently not sorted.
  96         allStrings.sort();
  97
  98         KFileItemList all = createFileItemList(allStrings);
  99
 100         KFileItemList firstHalf, secondHalf, even, odd;
 101         for (int i = 0; i < n; ++i) {
 102             if (i < n / 2) {
 103                 firstHalf << all.at(i);
 104             } else {
 105                 secondHalf << all.at(i);
 106             }
 107
 108             if (i % 2 == 0) {
 109                 even << all.at(i);
 110             } else {
 111                 odd << all.at(i);
 112             }
 113         }
 114
 115         KItemRangeList itemRangeListFirstHalf;
 116         itemRangeListFirstHalf << KItemRange(0, firstHalf.count());
 117
 118         KItemRangeList itemRangeListSecondHalf;
 119         itemRangeListSecondHalf << KItemRange(firstHalf.count(), secondHalf.count());
 120
 121         KItemRangeList itemRangeListOddInserted, itemRangeListOddRemoved;
 122         for (int i = 0; i < odd.count(); ++i) {
 123             // Note that the index in the KItemRange is the index of
 124             // the model *before* the items have been inserted.
 125             itemRangeListOddInserted << KItemRange(i + 1, 1);
 126             itemRangeListOddRemoved << KItemRange(2 * i + 1, 1);
 127         }
 128
 129         const int bufferSize = 128;
 130         char buffer[bufferSize];
 131
 132         snprintf(buffer, bufferSize, "all--n=%i", n);
 133         QTest::newRow(buffer) << all << KFileItemList() << KFileItemList() << all << KItemRangeList() << KItemRangeList();
 134
 135         snprintf(buffer, bufferSize, "1st half + 2nd half--n=%i", n);
 136         QTest::newRow(buffer) << firstHalf << secondHalf << KFileItemList() << all << itemRangeListSecondHalf << KItemRangeList();
 137
 138         snprintf(buffer, bufferSize, "2nd half + 1st half--n=%i", n);
 139         QTest::newRow(buffer) << secondHalf << firstHalf << KFileItemList() << all << itemRangeListFirstHalf << KItemRangeList();
 140
 141         snprintf(buffer, bufferSize, "even + odd--n=%i", n);
 142         QTest::newRow(buffer) << even << odd << KFileItemList() << all << itemRangeListOddInserted << KItemRangeList();
 143
 144         snprintf(buffer, bufferSize, "all - 2nd half--n=%i", n);
 145         QTest::newRow(buffer) << all << KFileItemList() << secondHalf << firstHalf << KItemRangeList() << itemRangeListSecondHalf;
 146
 147         snprintf(buffer, bufferSize, "all - 1st half--n=%i", n);
 148         QTest::newRow(buffer) << all << KFileItemList() << firstHalf << secondHalf << KItemRangeList() << itemRangeListFirstHalf;
 149
 150         snprintf(buffer, bufferSize, "all - odd--n=%i", n);
 151         QTest::newRow(buffer) << all << KFileItemList() << odd << even << KItemRangeList() << itemRangeListOddRemoved;
 152     }
 153 }
 154
 155 void KFileItemModelBenchmark::insertAndRemoveManyItems()
 156 {
 157     QFETCH(KFileItemList, initialItems);
 158     QFETCH(KFileItemList, newItems);
 159     QFETCH(KFileItemList, removedItems);
 160     QFETCH(KFileItemList, expectedFinalItems);
 161     QFETCH(KItemRangeList, expectedItemsInserted);
 162     QFETCH(KItemRangeList, expectedItemsRemoved);
 163
 164     KFileItemModel model;
 165
 166     // Avoid overhead caused by natural sorting
 167     // and determining the isDir/isLink roles.
 168     model.m_naturalSorting = false;
 169     model.setRoles({"text"});
 170
 171     QSignalSpy spyItemsInserted(&model, SIGNAL(itemsInserted(KItemRangeList)));
 172     QSignalSpy spyItemsRemoved(&model, SIGNAL(itemsRemoved(KItemRangeList)));
 173
 174     QBENCHMARK {
 175         model.slotClear();
 176         model.slotItemsAdded(model.directory(), initialItems);
 177         model.slotCompleted();
 178         QCOMPARE(model.count(), initialItems.count());
 179
 180         if (!newItems.isEmpty()) {
 181             model.slotItemsAdded(model.directory(), newItems);
 182             model.slotCompleted();
 183         }
 184         QCOMPARE(model.count(), initialItems.count() + newItems.count());
 185
 186         if (!removedItems.isEmpty()) {
 187             model.slotItemsDeleted(removedItems);
 188         }
 189         QCOMPARE(model.count(), initialItems.count() + newItems.count() - removedItems.count());
 190     }
 191
 192     QVERIFY(model.isConsistent());
 193
 194     for (int i = 0; i < model.count(); ++i) {
 195         QCOMPARE(model.fileItem(i), expectedFinalItems.at(i));
 196     }
 197
 198     if (!expectedItemsInserted.empty()) {
 199         QVERIFY(!spyItemsInserted.empty());
 200         const KItemRangeList actualItemsInserted = spyItemsInserted.last().first().value<KItemRangeList>();
 201         QCOMPARE(actualItemsInserted, expectedItemsInserted);
 202     }
 203
 204     if (!expectedItemsRemoved.empty()) {
 205         QVERIFY(!spyItemsRemoved.empty());
 206         const KItemRangeList actualItemsRemoved = spyItemsRemoved.last().first().value<KItemRangeList>();
 207         QCOMPARE(actualItemsRemoved, expectedItemsRemoved);
 208     }
 209 }
 210
 211 KFileItemList KFileItemModelBenchmark::createFileItemList(const QStringList& fileNames, const QString& prefix)
 212 {
 213     // Suppress 'file does not exist anymore' messages from KFileItemPrivate::init().
 214     qInstallMessageHandler(myMessageOutput);
 215
 216     KFileItemList result;
 217     foreach (const QString& name, fileNames) {
 218         const KFileItem item(QUrl::fromLocalFile(prefix + name), QString(), KFileItem::Unknown);
 219         result << item;
 220     }
 221     return result;
 222 }
 223
 224 QTEST_MAIN(KFileItemModelBenchmark)
 225
 226 #include "kfileitemmodelbenchmark.moc"