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_kde.h>
  22
  23 #include "kitemviews/kfileitemmodel.h"
  24 #include "kitemviews/private/kfileitemmodelsortalgorithm.h"
  25
  26 void myMessageOutput(QtMsgType type, const char* msg)
  27 {
  28     switch (type) {
  29     case QtDebugMsg:
  30         break;
  31     case QtWarningMsg:
  32         break;
  33     case QtCriticalMsg:
  34         fprintf(stderr, "Critical: %s\n", msg);
  35         break;
  36     case QtFatalMsg:
  37         fprintf(stderr, "Fatal: %s\n", msg);
  38         abort();
  39     default:
  40        break;
  41     }
  42 }
  43
  44 Q_DECLARE_METATYPE(KFileItemList)
  45 Q_DECLARE_METATYPE(KItemRangeList)
  46
  47 class KFileItemModelBenchmark : public QObject
  48 {
  49     Q_OBJECT
  50
  51 public:
  52     KFileItemModelBenchmark();
  53
  54 private slots:
  55     void insertAndRemoveManyItems_data();
  56     void insertAndRemoveManyItems();
  57
  58 private:
  59     static KFileItemList createFileItemList(const QStringList& fileNames, const QString& urlPrefix = QLatin1String("file:///"));
  60 };
  61
  62 KFileItemModelBenchmark::KFileItemModelBenchmark()
  63 {
  64 }
  65
  66 void KFileItemModelBenchmark::insertAndRemoveManyItems_data()
  67 {
  68     QTest::addColumn<KFileItemList>("initialItems");
  69     QTest::addColumn<KFileItemList>("newItems");
  70     QTest::addColumn<KFileItemList>("removedItems");
  71     QTest::addColumn<KFileItemList>("expectedFinalItems");
  72     QTest::addColumn<KItemRangeList>("expectedItemsInserted");
  73     QTest::addColumn<KItemRangeList>("expectedItemsRemoved");
  74
  75     QList<int> sizes;
  76     sizes << 1000 << 4000 << 16000 << 64000 << 256000;
  77     //sizes << 50000 << 100000 << 150000 << 200000 << 250000;
  78
  79     foreach (int n, sizes) {
  80         QStringList allStrings;
  81         for (int i = 0; i < n; ++i) {
  82             allStrings << QString::number(i);
  83         }
  84
  85         // We want to keep the sorting overhead in the benchmark low.
  86         // Therefore, we do not use natural sorting. However, this
  87         // means that our list is currently not sorted.
  88         allStrings.sort();
  89
  90         KFileItemList all = createFileItemList(allStrings);
  91
  92         KFileItemList firstHalf, secondHalf, even, odd;
  93         for (int i = 0; i < n; ++i) {
  94             if (i < n / 2) {
  95                 firstHalf << all.at(i);
  96             } else {
  97                 secondHalf << all.at(i);
  98             }
  99
 100             if (i % 2 == 0) {
 101                 even << all.at(i);
 102             } else {
 103                 odd << all.at(i);
 104             }
 105         }
 106
 107         KItemRangeList itemRangeListFirstHalf;
 108         itemRangeListFirstHalf << KItemRange(0, firstHalf.count());
 109
 110         KItemRangeList itemRangeListSecondHalf;
 111         itemRangeListSecondHalf << KItemRange(firstHalf.count(), secondHalf.count());
 112
 113         KItemRangeList itemRangeListOddInserted, itemRangeListOddRemoved;
 114         for (int i = 0; i < odd.count(); ++i) {
 115             // Note that the index in the KItemRange is the index of
 116             // the model *before* the items have been inserted.
 117             itemRangeListOddInserted << KItemRange(i + 1, 1);
 118             itemRangeListOddRemoved << KItemRange(2 * i + 1, 1);
 119         }
 120
 121         const int bufferSize = 128;
 122         char buffer[bufferSize];
 123
 124         snprintf(buffer, bufferSize, "all--n=%i", n);
 125         QTest::newRow(buffer) << all << KFileItemList() << KFileItemList() << all << KItemRangeList() << KItemRangeList();
 126
 127         snprintf(buffer, bufferSize, "1st half + 2nd half--n=%i", n);
 128         QTest::newRow(buffer) << firstHalf << secondHalf << KFileItemList() << all << itemRangeListSecondHalf << KItemRangeList();
 129
 130         snprintf(buffer, bufferSize, "2nd half + 1st half--n=%i", n);
 131         QTest::newRow(buffer) << secondHalf << firstHalf << KFileItemList() << all << itemRangeListFirstHalf << KItemRangeList();
 132
 133         snprintf(buffer, bufferSize, "even + odd--n=%i", n);
 134         QTest::newRow(buffer) << even << odd << KFileItemList() << all << itemRangeListOddInserted << KItemRangeList();
 135
 136         snprintf(buffer, bufferSize, "all - 2nd half--n=%i", n);
 137         QTest::newRow(buffer) << all << KFileItemList() << secondHalf << firstHalf << KItemRangeList() << itemRangeListSecondHalf;
 138
 139         snprintf(buffer, bufferSize, "all - 1st half--n=%i", n);
 140         QTest::newRow(buffer) << all << KFileItemList() << firstHalf << secondHalf << KItemRangeList() << itemRangeListFirstHalf;
 141
 142         snprintf(buffer, bufferSize, "all - odd--n=%i", n);
 143         QTest::newRow(buffer) << all << KFileItemList() << odd << even << KItemRangeList() << itemRangeListOddRemoved;
 144     }
 145 }
 146
 147 void KFileItemModelBenchmark::insertAndRemoveManyItems()
 148 {
 149     QFETCH(KFileItemList, initialItems);
 150     QFETCH(KFileItemList, newItems);
 151     QFETCH(KFileItemList, removedItems);
 152     QFETCH(KFileItemList, expectedFinalItems);
 153     QFETCH(KItemRangeList, expectedItemsInserted);
 154     QFETCH(KItemRangeList, expectedItemsRemoved);
 155
 156     KFileItemModel model;
 157
 158     // Avoid overhead caused by natural sorting
 159     // and determining the isDir/isLink roles.
 160     model.m_naturalSorting = false;
 161     model.setRoles(QSet<QByteArray>() << "text");
 162
 163     QSignalSpy spyItemsInserted(&model, SIGNAL(itemsInserted(KItemRangeList)));
 164     QSignalSpy spyItemsRemoved(&model, SIGNAL(itemsRemoved(KItemRangeList)));
 165
 166     QBENCHMARK {
 167         model.slotClear();
 168         model.slotNewItems(initialItems);
 169         model.slotCompleted();
 170         QCOMPARE(model.count(), initialItems.count());
 171
 172         if (!newItems.isEmpty()) {
 173             model.slotNewItems(newItems);
 174             model.slotCompleted();
 175         }
 176         QCOMPARE(model.count(), initialItems.count() + newItems.count());
 177
 178         if (!removedItems.isEmpty()) {
 179             model.removeItems(removedItems);
 180         }
 181         QCOMPARE(model.count(), initialItems.count() + newItems.count() - removedItems.count());
 182     }
 183
 184     QVERIFY(model.isConsistent());
 185
 186     for (int i = 0; i < model.count(); ++i) {
 187         QCOMPARE(model.fileItem(i), expectedFinalItems.at(i));
 188     }
 189
 190     if (!expectedItemsInserted.empty()) {
 191         QVERIFY(!spyItemsInserted.empty());
 192         const KItemRangeList actualItemsInserted = spyItemsInserted.last().first().value<KItemRangeList>();
 193         QCOMPARE(actualItemsInserted, expectedItemsInserted);
 194     }
 195
 196     if (!expectedItemsRemoved.empty()) {
 197         QVERIFY(!spyItemsRemoved.empty());
 198         const KItemRangeList actualItemsRemoved = spyItemsRemoved.last().first().value<KItemRangeList>();
 199         QCOMPARE(actualItemsRemoved, expectedItemsRemoved);
 200     }
 201 }
 202
 203 KFileItemList KFileItemModelBenchmark::createFileItemList(const QStringList& fileNames, const QString& prefix)
 204 {
 205     // Suppress 'file does not exist anymore' messages from KFileItemPrivate::init().
 206     qInstallMsgHandler(myMessageOutput);
 207
 208     KFileItemList result;
 209     foreach (const QString& name, fileNames) {
 210         const KUrl url(prefix + name);
 211         const KFileItem item(url, QString(), KFileItem::Unknown);
 212         result << item;
 213     }
 214     return result;
 215 }
 216
 217 QTEST_KDEMAIN(KFileItemModelBenchmark, NoGUI)
 218
 219 #include "kfileitemmodelbenchmark.moc"