From ccf27301e04addef0ed0cb6c7e832216cc3c12a8 Mon Sep 17 00:00:00 2001 From: Sergio Ahumada Date: Sun, 23 Oct 2011 13:15:25 +0200 Subject: [PATCH] test: Split `qcontiguouscache' unit and benchmark tests Moving three benchmark tests from 'tests/auto' to 'tests/benchmarks'. Also removing 'qttest_p4' usage while we are at it. - void asScrollingList(); - void cacheBenchmark(); - void contiguousCacheBenchmark(); were moved to 'tests/benchmarks/corelib/tools/qcontiguouscache' Task-number: QTQAINFRA-353 Change-Id: Icbdd852f9c14c3df042d2e19abd42af6c645a3cb Reviewed-by: Rohan McGovern --- .../tools/qcontiguouscache/qcontiguouscache.pro | 9 +- .../qcontiguouscache/tst_qcontiguouscache.cpp | 133 -------------- .../corelib/tools/qcontiguouscache/main.cpp | 192 +++++++++++++++++++++ .../tools/qcontiguouscache/qcontiguouscache.pro | 7 + tests/benchmarks/corelib/tools/tools.pro | 1 + 5 files changed, 204 insertions(+), 138 deletions(-) create mode 100644 tests/benchmarks/corelib/tools/qcontiguouscache/main.cpp create mode 100644 tests/benchmarks/corelib/tools/qcontiguouscache/qcontiguouscache.pro diff --git a/tests/auto/corelib/tools/qcontiguouscache/qcontiguouscache.pro b/tests/auto/corelib/tools/qcontiguouscache/qcontiguouscache.pro index 5951f87..911dd1b 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 076b6ca..96731f7 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 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)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 )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 )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 )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 cache; - cache.setMaxCost(100); - - for (int i = 0; i < 1000; i++) - cache.insert(i, new int(i)); - } -} - -void tst_QContiguousCache::contiguousCacheBenchmark() -{ - QBENCHMARK { - QContiguousCache 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 0000000..85b9e1d --- /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 +#include +#include +#include + +#include +#include + +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 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)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 )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 )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 )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 cache; + cache.setMaxCost(100); + + for (int i = 0; i < 1000; i++) + cache.insert(i, new int(i)); + } +} + +void tst_QContiguousCache::contiguousCacheBenchmark() +{ + QBENCHMARK { + QContiguousCache 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 0000000..fe74daf --- /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 44e8973..1576ccc 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 \ -- 2.7.4