1berry/qtbase
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

test: Split `qcontiguouscache' unit and benchmark tests

Browse Source 
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 <rohan.mcgovern@nokia.com>
This commit is contained in:
Sergio Ahumada 2011-10-23 13:15:25 +02:00 committed by Qt by Nokia
parent 8c13b6b21f
commit ccf27301e0
5 changed files with 204 additions and 138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
tests/auto/corelib/tools/qcontiguouscache/qcontiguouscache.pro
View File

@ -1,9 +1,8 @@
load(qttest_p4) TARGET = tst_qcontiguouscache
CONFIG += testcase
QT = core
SOURCES += tst_qcontiguouscache.cpp SOURCES += tst_qcontiguouscache.cpp
CONFIG += parallel_test CONFIG += parallel_test
QT = core testlib

133
tests/auto/corelib/tools/qcontiguouscache/tst_qcontiguouscache.cpp
View File

@ -63,15 +63,10 @@ private slots:
void prepend_data(); void prepend_data();
void prepend(); void prepend();
void asScrollingList();
void complexType(); void complexType();
void operatorAt(); void operatorAt();
void cacheBenchmark();
void contiguousCacheBenchmark();
void setCapacity(); void setCapacity();
void zeroCapacity(); 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 struct RefCountingClassData
{ {
QBasicAtomicInt ref; QBasicAtomicInt ref;
@ -421,35 +317,6 @@ void tst_QContiguousCache::operatorAt()
QCOMPARE(original.refCount(), 22); 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() void tst_QContiguousCache::setCapacity()
{ {
int i; int i;

192
tests/benchmarks/corelib/tools/qcontiguouscache/main.cpp Normal file
View File

@ -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"

7
tests/benchmarks/corelib/tools/qcontiguouscache/qcontiguouscache.pro Normal file
View File

@ -0,0 +1,7 @@
TARGET = tst_bench_qcontiguouscache
SOURCES += main.cpp
CONFIG += parallel_test
QT = core testlib

1
tests/benchmarks/corelib/tools/tools.pro
View File

@ -3,6 +3,7 @@ SUBDIRS = \
containers-associative \ containers-associative \
containers-sequential \ containers-sequential \
qbytearray \ qbytearray \
qcontiguouscache \
qlist \ qlist \
qrect \ qrect \
qregexp \ qregexp \