diff options
Diffstat (limited to 'tests')
5 files changed, 204 insertions, 138 deletions
diff --git a/tests/auto/corelib/tools/qcontiguouscache/qcontiguouscache.pro b/tests/auto/corelib/tools/qcontiguouscache/qcontiguouscache.pro index 5951f87f89..911dd1bb42 100644 --- a/tests/auto/corelib/tools/qcontiguouscache/qcontiguouscache.pro +++ b/tests/auto/corelib/tools/qcontiguouscache/qcontiguouscache.pro @@ -1,9 +1,8 @@ -load(qttest_p4) - -QT = core +TARGET = tst_qcontiguouscache +CONFIG += testcase SOURCES += tst_qcontiguouscache.cpp - - CONFIG += parallel_test + +QT = core testlib diff --git a/tests/auto/corelib/tools/qcontiguouscache/tst_qcontiguouscache.cpp b/tests/auto/corelib/tools/qcontiguouscache/tst_qcontiguouscache.cpp index 076b6ca63b..96731f7d78 100644 --- a/tests/auto/corelib/tools/qcontiguouscache/tst_qcontiguouscache.cpp +++ b/tests/auto/corelib/tools/qcontiguouscache/tst_qcontiguouscache.cpp @@ -63,15 +63,10 @@ private slots: void prepend_data(); void prepend(); - void asScrollingList(); - void complexType(); void operatorAt(); - void cacheBenchmark(); - void contiguousCacheBenchmark(); - void setCapacity(); void zeroCapacity(); @@ -216,105 +211,6 @@ void tst_QContiguousCache::prepend() } } -void tst_QContiguousCache::asScrollingList() -{ - int i; - QContiguousCache<int> c(10); - - // Once allocated QContiguousCache should not - // allocate any additional memory for non - // complex data types. - QBENCHMARK { - // simulate scrolling in a list of items; - for(i = 0; i < 10; ++i) { - QCOMPARE(c.available(), 10-i); - c.append(i); - } - - QCOMPARE(c.firstIndex(), 0); - QCOMPARE(c.lastIndex(), 9); - QCOMPARE(c.first(), 0); - QCOMPARE(c.last(), 9); - QVERIFY(!c.containsIndex(-1)); - QVERIFY(!c.containsIndex(10)); - QCOMPARE(c.available(), 0); - - for (i = 0; i < 10; ++i) { - QVERIFY(c.containsIndex(i)); - QCOMPARE(c.at(i), i); - QCOMPARE(c[i], i); - QCOMPARE(((const QContiguousCache<int>)c)[i], i); - } - - for (i = 10; i < 30; ++i) - c.append(i); - - QCOMPARE(c.firstIndex(), 20); - QCOMPARE(c.lastIndex(), 29); - QCOMPARE(c.first(), 20); - QCOMPARE(c.last(), 29); - QVERIFY(!c.containsIndex(19)); - QVERIFY(!c.containsIndex(30)); - QCOMPARE(c.available(), 0); - - for (i = 20; i < 30; ++i) { - QVERIFY(c.containsIndex(i)); - QCOMPARE(c.at(i), i); - QCOMPARE(c[i], i); - QCOMPARE(((const QContiguousCache<int> )c)[i], i); - } - - for (i = 19; i >= 10; --i) - c.prepend(i); - - QCOMPARE(c.firstIndex(), 10); - QCOMPARE(c.lastIndex(), 19); - QCOMPARE(c.first(), 10); - QCOMPARE(c.last(), 19); - QVERIFY(!c.containsIndex(9)); - QVERIFY(!c.containsIndex(20)); - QCOMPARE(c.available(), 0); - - for (i = 10; i < 20; ++i) { - QVERIFY(c.containsIndex(i)); - QCOMPARE(c.at(i), i); - QCOMPARE(c[i], i); - QCOMPARE(((const QContiguousCache<int> )c)[i], i); - } - - for (i = 200; i < 220; ++i) - c.insert(i, i); - - QCOMPARE(c.firstIndex(), 210); - QCOMPARE(c.lastIndex(), 219); - QCOMPARE(c.first(), 210); - QCOMPARE(c.last(), 219); - QVERIFY(!c.containsIndex(209)); - QVERIFY(!c.containsIndex(300)); - QCOMPARE(c.available(), 0); - - for (i = 210; i < 220; ++i) { - QVERIFY(c.containsIndex(i)); - QCOMPARE(c.at(i), i); - QCOMPARE(c[i], i); - QCOMPARE(((const QContiguousCache<int> )c)[i], i); - } - c.clear(); // needed to reset benchmark - } - - // from a specific bug that was encountered. 100 to 299 cached, attempted to cache 250 - 205 via insert, failed. - // bug was that item at 150 would instead be item that should have been inserted at 250 - c.setCapacity(200); - for(i = 100; i < 300; ++i) - c.insert(i, i); - for (i = 250; i <= 306; ++i) - c.insert(i, 1000+i); - for (i = 107; i <= 306; ++i) { - QVERIFY(c.containsIndex(i)); - QCOMPARE(c.at(i), i < 250 ? i : 1000+i); - } -} - struct RefCountingClassData { QBasicAtomicInt ref; @@ -421,35 +317,6 @@ void tst_QContiguousCache::operatorAt() QCOMPARE(original.refCount(), 22); } -/* - Benchmarks must be near identical in tasks to be fair. - QCache uses pointers to ints as its a requirement of QCache, - whereas QContiguousCache doesn't support pointers (won't free them). - Given the ability to use simple data types is a benefit, its - fair. Although this obviously must take into account we are - testing QContiguousCache use cases here, QCache has its own - areas where it is the more sensible class to use. -*/ -void tst_QContiguousCache::cacheBenchmark() -{ - QBENCHMARK { - QCache<int, int> cache; - cache.setMaxCost(100); - - for (int i = 0; i < 1000; i++) - cache.insert(i, new int(i)); - } -} - -void tst_QContiguousCache::contiguousCacheBenchmark() -{ - QBENCHMARK { - QContiguousCache<int> contiguousCache(100); - for (int i = 0; i < 1000; i++) - contiguousCache.insert(i, i); - } -} - void tst_QContiguousCache::setCapacity() { int i; diff --git a/tests/benchmarks/corelib/tools/qcontiguouscache/main.cpp b/tests/benchmarks/corelib/tools/qcontiguouscache/main.cpp new file mode 100644 index 0000000000..85b9e1d9aa --- /dev/null +++ b/tests/benchmarks/corelib/tools/qcontiguouscache/main.cpp @@ -0,0 +1,192 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the test suite of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** This file may be used under the terms of the GNU Lesser General Public +** License version 2.1 as published by the Free Software Foundation and +** appearing in the file LICENSE.LGPL included in the packaging of this +** file. Please review the following information to ensure the GNU Lesser +** General Public License version 2.1 requirements will be met: +** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include <QObject> +#include <QTest> +#include <QCache> +#include <QContiguousCache> + +#include <QDebug> +#include <stdio.h> + +class tst_QContiguousCache : public QObject +{ + Q_OBJECT +public: + tst_QContiguousCache() {} + virtual ~tst_QContiguousCache() {} +private slots: + void asScrollingList(); + void cacheBenchmark(); + void contiguousCacheBenchmark(); +}; + +QTEST_MAIN(tst_QContiguousCache) + +void tst_QContiguousCache::asScrollingList() +{ + int i; + QContiguousCache<int> c(10); + + // Once allocated QContiguousCache should not + // allocate any additional memory for non + // complex data types. + QBENCHMARK { + // simulate scrolling in a list of items; + for (i = 0; i < 10; ++i) { + QCOMPARE(c.available(), 10-i); + c.append(i); + } + + QCOMPARE(c.firstIndex(), 0); + QCOMPARE(c.lastIndex(), 9); + QCOMPARE(c.first(), 0); + QCOMPARE(c.last(), 9); + QVERIFY(!c.containsIndex(-1)); + QVERIFY(!c.containsIndex(10)); + QCOMPARE(c.available(), 0); + + for (i = 0; i < 10; ++i) { + QVERIFY(c.containsIndex(i)); + QCOMPARE(c.at(i), i); + QCOMPARE(c[i], i); + QCOMPARE(((const QContiguousCache<int>)c)[i], i); + } + + for (i = 10; i < 30; ++i) + c.append(i); + + QCOMPARE(c.firstIndex(), 20); + QCOMPARE(c.lastIndex(), 29); + QCOMPARE(c.first(), 20); + QCOMPARE(c.last(), 29); + QVERIFY(!c.containsIndex(19)); + QVERIFY(!c.containsIndex(30)); + QCOMPARE(c.available(), 0); + + for (i = 20; i < 30; ++i) { + QVERIFY(c.containsIndex(i)); + QCOMPARE(c.at(i), i); + QCOMPARE(c[i], i); + QCOMPARE(((const QContiguousCache<int> )c)[i], i); + } + + for (i = 19; i >= 10; --i) + c.prepend(i); + + QCOMPARE(c.firstIndex(), 10); + QCOMPARE(c.lastIndex(), 19); + QCOMPARE(c.first(), 10); + QCOMPARE(c.last(), 19); + QVERIFY(!c.containsIndex(9)); + QVERIFY(!c.containsIndex(20)); + QCOMPARE(c.available(), 0); + + for (i = 10; i < 20; ++i) { + QVERIFY(c.containsIndex(i)); + QCOMPARE(c.at(i), i); + QCOMPARE(c[i], i); + QCOMPARE(((const QContiguousCache<int> )c)[i], i); + } + + for (i = 200; i < 220; ++i) + c.insert(i, i); + + QCOMPARE(c.firstIndex(), 210); + QCOMPARE(c.lastIndex(), 219); + QCOMPARE(c.first(), 210); + QCOMPARE(c.last(), 219); + QVERIFY(!c.containsIndex(209)); + QVERIFY(!c.containsIndex(300)); + QCOMPARE(c.available(), 0); + + for (i = 210; i < 220; ++i) { + QVERIFY(c.containsIndex(i)); + QCOMPARE(c.at(i), i); + QCOMPARE(c[i], i); + QCOMPARE(((const QContiguousCache<int> )c)[i], i); + } + c.clear(); // needed to reset benchmark + } + + // from a specific bug that was encountered. 100 to 299 cached, attempted to cache 250 - 205 via insert, failed. + // bug was that item at 150 would instead be item that should have been inserted at 250 + c.setCapacity(200); + for (i = 100; i < 300; ++i) + c.insert(i, i); + for (i = 250; i <= 306; ++i) + c.insert(i, 1000+i); + for (i = 107; i <= 306; ++i) { + QVERIFY(c.containsIndex(i)); + QCOMPARE(c.at(i), i < 250 ? i : 1000+i); + } +} + +/* + Benchmarks must be near identical in tasks to be fair. + QCache uses pointers to ints as its a requirement of QCache, + whereas QContiguousCache doesn't support pointers (won't free them). + Given the ability to use simple data types is a benefit, its + fair. Although this obviously must take into account we are + testing QContiguousCache use cases here, QCache has its own + areas where it is the more sensible class to use. +*/ +void tst_QContiguousCache::cacheBenchmark() +{ + QBENCHMARK { + QCache<int, int> cache; + cache.setMaxCost(100); + + for (int i = 0; i < 1000; i++) + cache.insert(i, new int(i)); + } +} + +void tst_QContiguousCache::contiguousCacheBenchmark() +{ + QBENCHMARK { + QContiguousCache<int> contiguousCache(100); + for (int i = 0; i < 1000; i++) + contiguousCache.insert(i, i); + } +} + +#include "main.moc" diff --git a/tests/benchmarks/corelib/tools/qcontiguouscache/qcontiguouscache.pro b/tests/benchmarks/corelib/tools/qcontiguouscache/qcontiguouscache.pro new file mode 100644 index 0000000000..fe74dafef4 --- /dev/null +++ b/tests/benchmarks/corelib/tools/qcontiguouscache/qcontiguouscache.pro @@ -0,0 +1,7 @@ +TARGET = tst_bench_qcontiguouscache + +SOURCES += main.cpp + +CONFIG += parallel_test + +QT = core testlib diff --git a/tests/benchmarks/corelib/tools/tools.pro b/tests/benchmarks/corelib/tools/tools.pro index 44e8973522..1576ccceaf 100644 --- a/tests/benchmarks/corelib/tools/tools.pro +++ b/tests/benchmarks/corelib/tools/tools.pro @@ -3,6 +3,7 @@ SUBDIRS = \ containers-associative \ containers-sequential \ qbytearray \ + qcontiguouscache \ qlist \ qrect \ qregexp \ |