diff -r 41300fa6a67c -r f7bc934e204c util/tests/benchmarks/uimodels/GraphicsViewBenchmark/testautom/testthread.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/util/tests/benchmarks/uimodels/GraphicsViewBenchmark/testautom/testthread.cpp Wed Mar 31 11:06:36 2010 +0300 @@ -0,0 +1,310 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the examples of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** GNU Lesser General Public License Usage +** Alternatively, 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.0, 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. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at http://qt.nokia.com/contact. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include +#include + +#include "testthread.h" +#include "theme.h" + +static const int SleepTimeBetweenCases = 1000; + +Q_DECLARE_METATYPE(TestThread*) + +TestThread::TestThread(TestController *ctrl, QObject *parent) + : QThread(parent), + m_doExit(false), + m_resultLogger(0) +{ + setController(ctrl); + connect(controller(), SIGNAL(stop()), this, SLOT(stop())); + connect(controller(), SIGNAL(testDone()), this, SLOT(testDone()), Qt::QueuedConnection); + connect(this, SIGNAL(changeTheme(Theme::Themes)), + controller(), SLOT(changeTheme(Theme::Themes))); + + connect(this, SIGNAL(fillList(int,Benchmark::ListType,TestFunctionResult*, const QString &)), + controller(), SLOT(fillList(int,Benchmark::ListType, TestFunctionResult*, const QString &)), + Qt::QueuedConnection); + + connect(this, SIGNAL(doRotateMainWindow(int)), controller(), SLOT(rotateMainWindow(int)), + Qt::QueuedConnection); + connect(this, SIGNAL(doSetTwoColumns(bool)), controller(), SLOT(setTwoColumns(bool)), + Qt::QueuedConnection); + + connect(this, SIGNAL(deleteList(TestFunctionResult*, const QString &)), + controller(), SLOT(deleteList(TestFunctionResult*, const QString &)), + Qt::QueuedConnection); + connect(this, SIGNAL(themeChange(int,TestFunctionResult*, const QString &)), + controller(), SLOT(themeChange(int,TestFunctionResult*, const QString &)), + Qt::QueuedConnection); + connect(this, SIGNAL(scrollList(int,TestFunctionResult*, const QString &)), + controller(), SLOT(scrollList(int,TestFunctionResult*, const QString &)), + Qt::QueuedConnection); + connect(this, SIGNAL(forceUpdate(int,TestFunctionResult*, const QString &)), + controller(), SLOT(forceUpdate(int,TestFunctionResult*, const QString &)), + Qt::QueuedConnection); + connect(this, SIGNAL(addToBeginningOfList(int,TestFunctionResult*, const QString &)), + controller(), SLOT(addToBeginningOfList(int,TestFunctionResult*, const QString &)), + Qt::QueuedConnection); + connect(this, SIGNAL(removeFromBeginningOfList(int,TestFunctionResult*, const QString &)), + controller(), SLOT(removeFromBeginningOfList(int,TestFunctionResult*, const QString &)), + Qt::QueuedConnection); +} + +TestThread::~TestThread() +{ + delete m_resultLogger; +} + +void TestThread::stop() +{ + m_doExit = true; + testDone(); +} + +void TestThread::testDone() +{ + m_waitCondition.wakeAll(); +} + +TestController *TestThread::controller() const +{ + return m_controller; +} +void TestThread::setController(TestController *ctrl) +{ + m_controller = ctrl; +} + +void TestThread::setResultLogger(ResultLogger *logger) +{ + if (m_resultLogger == logger) + return; + if (m_resultLogger) + delete m_resultLogger; + m_resultLogger = logger; +} + +ResultLogger* TestThread::resultLogger() const +{ + return m_resultLogger; +} + + +void TestThread::addTestFunctionBenchmark(const QString &functionName, const QString &benchmarkTag, const qreal value) +{ + if (!m_resultLogger) + return; + TestFunctionResult *f = m_resultLogger->getTestFunctionResult(functionName); + if (!f) + f = m_resultLogger->createTestFunctionResult(functionName); + + Benchmark *b = f->createBenchmark(); + b->setTag(benchmarkTag); + b->setValue(value); + b->setTheme(Theme::p()->currentThemeName()); +} + +void TestThread::setScrollStep(const int step) +{ + controller()->setScrollStep(step); +} +int TestThread::scrollStep() const +{ + return controller()->scrollStep(); +} + +bool TestThread::imageBasedRendering() const +{ + return controller()->imageBasedRendering(); +} + +bool TestThread::subtreeCache() const +{ + return controller()->subtreeCache(); +} + +void TestThread::rotateMainWindow(const int angle) +{ + if (m_doExit) return; + m_mutex.lock(); + emit doRotateMainWindow(angle); + m_waitCondition.wait(&m_mutex); + m_mutex.unlock(); + if (m_doExit) return; + msleep(SleepTimeBetweenCases); +} + +int TestThread::mainWindowRotationAngle() const +{ + return controller()->mainWindowRotationAngle(); +} + +int TestThread::themeCount() const +{ + return Theme::p()->themes().count(); +} + +int TestThread::currentThemeId() const +{ + return int(Theme::p()->theme()); +} + +void TestThread::setTheme(int index) +{ + emit changeTheme(Theme::Themes(index)); + if (m_doExit) return; + msleep(SleepTimeBetweenCases); +} + +QString TestThread::currentThemeName() const +{ + return Theme::p()->currentThemeName(); +} +QString TestThread::themeName(int theme) const +{ + return Theme::p()->themes().at(theme); +} + +void TestThread::setImageBasedRendering(const bool imageBasedRendering) +{ + controller()->setImageBasedRendering(imageBasedRendering); +} + +void TestThread::setTwoColumns(const bool twoCols) +{ + if (m_doExit) return; + m_mutex.lock(); + emit doSetTwoColumns(twoCols); + m_waitCondition.wait(&m_mutex); + m_mutex.unlock(); + if (m_doExit) return; + msleep(SleepTimeBetweenCases); +} + +bool TestThread::twoColumns() const +{ + return controller()->twoColumns(); +} + +void TestThread::fillListTest(int itemCount, int listType, TestFunctionResult *testFunctionResult, const QString &tag) +{ + if (m_doExit) return; + m_mutex.lock(); + emit fillList(itemCount, Benchmark::ListType(listType), testFunctionResult, tag); + m_waitCondition.wait(&m_mutex); + m_mutex.unlock(); + if (m_doExit) return; + msleep(SleepTimeBetweenCases); +} + +void TestThread::deleteListTest(TestFunctionResult *testFunctionResult, const QString &tag) +{ + if (m_doExit) return; + m_mutex.lock(); + emit deleteList(testFunctionResult, tag); + m_waitCondition.wait(&m_mutex); + m_mutex.unlock(); + if (m_doExit) return; + msleep(SleepTimeBetweenCases); +} + +void TestThread::scrollListTest(int maxTimeMs,TestFunctionResult *testFunctionResult, const QString &tag) +{ + if (m_doExit) return; + m_mutex.lock(); + emit scrollList(maxTimeMs, testFunctionResult, tag); + m_waitCondition.wait(&m_mutex); + m_mutex.unlock(); + if (m_doExit) return; + msleep(SleepTimeBetweenCases); +} + +void TestThread::addToBeginningOfListTest(int itemCount,TestFunctionResult *testFunctionResult, const QString &tag) +{ + if (m_doExit) return; + m_mutex.lock(); + emit addToBeginningOfList(itemCount, testFunctionResult, tag); + m_waitCondition.wait(&m_mutex); + m_mutex.unlock(); + if (m_doExit) return; + msleep(SleepTimeBetweenCases); +} + +void TestThread::removeFromBeginningOfListTest(int itemCount, TestFunctionResult *testFunctionResult, const QString &tag) +{ + if (m_doExit) return; + m_mutex.lock(); + emit removeFromBeginningOfList(itemCount, testFunctionResult, tag); + m_waitCondition.wait(&m_mutex); + m_mutex.unlock(); + if (m_doExit) return; + msleep(SleepTimeBetweenCases); +} + +void TestThread::forceUpdateTest(int updateMaxTime, TestFunctionResult *testFunctionResult, const QString &tag) +{ + if (m_doExit) return; + m_mutex.lock(); + emit forceUpdate(updateMaxTime, testFunctionResult, tag); + m_waitCondition.wait(&m_mutex); + m_mutex.unlock(); + if (m_doExit) return; + msleep(SleepTimeBetweenCases); +} + + +void TestThread::themeChangeTest(int theme, TestFunctionResult *testFunctionResult, const QString &tag) +{ + if (m_doExit) return; + m_mutex.lock(); + emit themeChange(theme, testFunctionResult, tag); + m_waitCondition.wait(&m_mutex); + m_mutex.unlock(); + if (m_doExit) return; + msleep(SleepTimeBetweenCases); +} + + +void TestThread::setSubtreeCache(const bool enabled) +{ + controller()->setSubtreeCache(enabled); +}