diff -r 56cd8111b7f7 -r 41300fa6a67c tests/benchmarks/uimodels/GraphicsViewBenchmark/testautom/testcontroller.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/tests/benchmarks/uimodels/GraphicsViewBenchmark/testautom/testcontroller.cpp	Tue Feb 02 00:43:10 2010 +0200
@@ -0,0 +1,953 @@
+/****************************************************************************
+**
+** 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 <QDebug>
+#include <QMutex>
+#include <QWaitCondition>
+#include <QApplication>
+#include <QDir>
+#include <QPluginLoader>
+
+#include "testcontroller.h"
+#include "itemrecyclinglist.h"
+#include "simplelist.h"
+#include "scrollbar.h"
+#include "mainview.h"
+#include "theme.h"
+#include "themeevent.h"
+#include "filllists.h"
+
+static const int EmitDoneTimeout = 1000;
+
+Q_DECLARE_METATYPE(TestController*)
+
+TestController::TestController(const QString &fname, MainView *mv, ResultLogger::ResultFormat format, QObject *parent)
+    : QObject(parent),
+    mMainView(mv),
+    mCurrentSimpleList(0),
+    mCurrentRecyclingList(0),
+    mTestDuration(),
+    mMaxTestDurationTime(0),
+    mScrollDirection(1),
+    mFileName(fname),
+    mResultFormat(format),
+    mDataGenerator(),
+    mResMon(0),
+    mSubtreeCacheEnabled(false),
+    mScrollStep(36),
+    mCpuMemLogging(true),
+    mLastElapsed(0)
+{
+    qRegisterMetaType<TestController*>();    
+    connect(QApplication::instance(), SIGNAL(aboutToQuit()), this, SLOT(aboutToQuit()));
+
+    if(loadPlugin()) {
+        //qDebug() << "Loaded plugin!";
+        if (mResMon->Prepare("tst_GraphicsViewBenchmark")) {
+        }
+    }
+    else {
+        qDebug() << "Failed to load plugin!";
+    }
+}
+
+
+TestController::~TestController()
+{
+    delete mResMon;
+}
+
+void TestController::printResourceLoad()
+{
+#if defined Q_OS_LINUX
+    if (mResMon) {
+        ResourceMonitorInterface::CpuUsage usage = mResMon->CPULoad();
+        ResourceMonitorInterface::MemoryAllocation allocation = mResMon->MemoryLoad();
+        qDebug() << "CPULoad: total" << usage.systemUsage << "(%), app" << usage.appTreadUsage << "(%)";
+        qDebug() << "MemoryLoad: occupied by app chunks" << allocation.allocatedInAppThread << "(bytes), number of free app chunks" << allocation.numberOfAllocatedCellsInAppThread << ", avaliable in app heap" << allocation.availableMemoryInAppThreadHeap <<"(bytes), total memory" << allocation.totalMemoryInSystem << "(bytes), free memory" << allocation.availableMemoryInSystem << "(bytes)";
+    }
+#endif
+}
+
+QString TestController::resultFileName()
+{
+    return mFileName;
+}
+
+ResultLogger::ResultFormat TestController::resultFileFormat()
+{
+    return mResultFormat;
+}
+
+void TestController::setSubtreeCache(const bool enabled)
+{
+    mSubtreeCacheEnabled = enabled;
+}
+bool TestController::subtreeCache() const
+{
+    return mSubtreeCacheEnabled;
+}
+
+void TestController::setScrollStep(const int step)
+{
+    mScrollStep = step;
+}
+int TestController::scrollStep() const
+{
+    return mScrollStep;
+}
+
+void TestController::rotateMainWindow(const int angle)
+{
+    if (mMainView)
+        mMainView->rotateContent(angle);
+    QTimer::singleShot(EmitDoneTimeout, this, SLOT(testIsDone()));
+}
+
+int TestController::mainWindowRotationAngle() const
+{
+    if (mMainView)
+        return mMainView->rotationAngle();
+    return 0;
+}
+
+void TestController::setCpuMemLogging(const bool enabled)
+{
+    mCpuMemLogging = enabled;
+}
+
+void TestController::aboutToQuit()
+{
+    testIsDone();
+    emit stop();
+}
+
+void TestController::changeTheme(Theme::Themes theme)
+{
+    Theme::p()->setTheme(theme);
+}
+
+void TestController::testIsDone()
+{
+    mScrollDirection = 1;    
+    mCurrentRecyclingList = 0;
+    mCurrentSimpleList = 0;
+    mMaxTestDurationTime = 0;
+    if (mMainView)
+        mMainView->fpsReset();
+
+    emit testDone();
+}
+
+void TestController::fillList(int itemCount, Benchmark::ListType listType,
+                              TestFunctionResult *testFunctionResult,  const QString &tag)
+{
+    if (!mMainView) {
+        QTimer::singleShot(EmitDoneTimeout, this, SLOT(testIsDone()));
+        return;
+    }
+
+    Benchmark *b = testFunctionResult->createBenchmark();
+    b->setRotation(mainWindowRotationAngle());
+    b->setListSize(itemCount);
+    b->setUseListItemCache(mSubtreeCacheEnabled);
+    b->setImageBasedRendering(mMainView->imageBasedRendering());
+    b->setTheme(Theme::p()->currentThemeName());
+    b->setListType(listType);
+    b->setTag(tag);
+
+    if (listType==Benchmark::RecyclingListType){
+        if(mResMon && mCpuMemLogging) {
+            //CPU/MEM begin
+            mResMon->BeginMeasureCPULoad(); 
+            mResMon->BeginMeasureMemoryLoad();
+        }
+        
+        QTime t;
+        t.start();
+        ItemRecyclingList *list = new ItemRecyclingList();
+
+        list->setListItemCaching(mSubtreeCacheEnabled);
+
+        mMainView->setTestWidget(list);
+
+        mDataGenerator.Reset();
+
+        fillRecyclingList(mDataGenerator, itemCount, list);
+
+        int took = t.elapsed();
+
+        b->setValue(took);
+        if(mResMon && mCpuMemLogging) {
+            //CPU/MEM end
+            createCpuBenchmark(testFunctionResult, tag, itemCount, listType,Theme::p()->currentThemeName(), mResMon->EndMeasureCPULoad());
+            createMemoryBenchmark(testFunctionResult, tag, itemCount, listType,Theme::p()->currentThemeName(), mResMon->EndMeasureMemoryLoad());
+        }
+    }
+    else {
+        if(mResMon && mCpuMemLogging) {
+            //CPU/MEM begin
+            mResMon->BeginMeasureCPULoad(); 
+            mResMon->BeginMeasureMemoryLoad();
+        }
+        
+        QTime t;
+        t.start();
+        SimpleList *list = new SimpleList();
+        list->setListItemCaching(mSubtreeCacheEnabled);
+        mMainView->setTestWidget(list);
+
+        mDataGenerator.Reset();
+
+        fillSimpleList(mDataGenerator, itemCount, list);
+
+        int took = t.elapsed();
+        b->setValue(took);
+        
+        if(mResMon && mCpuMemLogging) {
+            //CPU/MEM end
+            createCpuBenchmark(testFunctionResult, tag, itemCount, listType,Theme::p()->currentThemeName(), mResMon->EndMeasureCPULoad());
+            createMemoryBenchmark(testFunctionResult, tag, itemCount, listType,Theme::p()->currentThemeName(), mResMon->EndMeasureMemoryLoad());
+        }
+    }
+
+    // Make sure we record the correct view size
+    b->setWidth(mMainView->size().width());
+    b->setHeight(mMainView->size().height());
+
+    QTimer::singleShot(EmitDoneTimeout, this, SLOT(testIsDone()));
+}
+
+void TestController::scrollList(int maxTimeMs, TestFunctionResult *testFunctionResult, const QString &tag)
+{
+    if (!mMainView) {
+        QTimer::singleShot(EmitDoneTimeout, this, SLOT(testIsDone()));
+        return;
+    }
+
+    mMaxTestDurationTime = maxTimeMs;
+
+    QGraphicsWidget *tw = mMainView->testWidget();
+    ItemRecyclingList *list = dynamic_cast<ItemRecyclingList *>(tw);    
+    if (list) {
+        if (mMainView)
+            mMainView->fpsReset();
+        mTestDuration.start();
+        mLastElapsed = 0;
+        mCurrentRecyclingList = list;
+        connect(this, SIGNAL(doScrollRecyclingList(TestFunctionResult*, const QString &)),
+                this, SLOT(scrollRecyclingList(TestFunctionResult*, const QString &)), Qt::QueuedConnection);
+        
+        if(mResMon && mCpuMemLogging) {
+            //CPU/MEM begin
+            mResMon->BeginMeasureCPULoad(); 
+            mResMon->BeginMeasureMemoryLoad();
+        }
+        
+        emit doScrollRecyclingList(testFunctionResult, tag);
+    }
+    else {
+        SimpleList *list = dynamic_cast<SimpleList*>(tw);
+        if (list) {
+            if (mMainView)
+                mMainView->fpsReset();
+            mTestDuration.start();
+            mLastElapsed = 0;
+            mCurrentSimpleList = list;
+            connect(this, SIGNAL(doScrollSimpleList(TestFunctionResult*, const QString &)),
+                    this, SLOT(scrollSimpleList(TestFunctionResult*, const QString &)), Qt::QueuedConnection);
+            
+            if(mResMon && mCpuMemLogging) {
+                //CPU/MEM begin        
+                mResMon->BeginMeasureCPULoad(); 
+                mResMon->BeginMeasureMemoryLoad();
+            }
+            
+            emit doScrollSimpleList(testFunctionResult, tag);
+        }
+        else {
+            QTimer::singleShot(EmitDoneTimeout, this, SLOT(testIsDone()));
+        }
+   }
+}
+
+void TestController::addToBeginningOfList(int itemCount, TestFunctionResult *testFunctionResult, const QString &tag)
+{
+    if (!mMainView) {
+        QTimer::singleShot(EmitDoneTimeout, this, SLOT(testIsDone()));
+        return;
+    }
+
+    Benchmark *b = testFunctionResult->createBenchmark();
+    b->setTag(tag);
+    b->setRotation(mainWindowRotationAngle());
+    b->setListSize(itemCount);
+    b->setUseListItemCache(mSubtreeCacheEnabled);
+    b->setImageBasedRendering(mMainView->imageBasedRendering());
+    b->setTheme(Theme::p()->currentThemeName());
+    b->setWidth(mMainView->size().width());
+    b->setHeight(mMainView->size().height());
+
+    QGraphicsWidget *tw = mMainView->testWidget();
+    ItemRecyclingList *list = dynamic_cast<ItemRecyclingList *>(tw);
+
+    if (list) {
+        QString type = list->objectName();
+        
+        if(mResMon && mCpuMemLogging) {
+            //CPU/MEM begin
+            mResMon->BeginMeasureCPULoad(); 
+            mResMon->BeginMeasureMemoryLoad();
+        }
+        
+        QTime t;
+        t.start();
+        for (int i=0; i<itemCount; ++i )
+            list->insertItem(0, newRecyclingListItem(mDataGenerator, i));
+        int took = t.elapsed();
+        
+        if(mResMon && mCpuMemLogging) {
+            //CPU/MEM end
+            createCpuBenchmark(testFunctionResult, tag, itemCount, Benchmark::RecyclingListType,Theme::p()->currentThemeName(), mResMon->EndMeasureCPULoad());
+            createMemoryBenchmark(testFunctionResult, tag, itemCount, Benchmark::RecyclingListType,Theme::p()->currentThemeName(), mResMon->EndMeasureMemoryLoad());
+        }
+        
+        b->setValue(took);
+        b->setListType(Benchmark::RecyclingListType);
+    }
+    else {
+        SimpleList *list = dynamic_cast<SimpleList*>(tw);
+        if (list) {
+            QString type = list->objectName();
+            
+            if(mResMon && mCpuMemLogging) {
+                //CPU/MEM begin
+                mResMon->BeginMeasureCPULoad(); 
+                mResMon->BeginMeasureMemoryLoad();
+            }
+            
+            QTime t;
+            t.start();
+            for (int i=0; i<itemCount; ++i )
+                list->insertItem(0,newSimpleListItem(mDataGenerator, i));
+            int took = t.elapsed();
+
+            if(mResMon && mCpuMemLogging) {
+                //CPU/MEM end
+                createCpuBenchmark(testFunctionResult, tag, itemCount, Benchmark::SimpleListType, Theme::p()->currentThemeName(), mResMon->EndMeasureCPULoad());
+                createMemoryBenchmark(testFunctionResult, tag, itemCount, Benchmark::SimpleListType, Theme::p()->currentThemeName(), mResMon->EndMeasureMemoryLoad());
+            }
+            
+            b->setValue(took);
+            b->setListType(Benchmark::SimpleListType);
+        }
+   }
+
+   QTimer::singleShot(EmitDoneTimeout, this, SLOT(testIsDone()));
+}
+
+void TestController::removeFromBeginningOfList(int itemCount, TestFunctionResult *testFunctionResult, const QString &tag)
+{
+    if (!mMainView) {
+        QTimer::singleShot(EmitDoneTimeout, this, SLOT(testIsDone()));
+        return;
+    }
+
+    Benchmark *b = testFunctionResult->createBenchmark();
+    b->setTag(tag);
+    b->setRotation(mainWindowRotationAngle());
+    b->setListSize(itemCount);
+    b->setUseListItemCache(mSubtreeCacheEnabled);
+    b->setImageBasedRendering(mMainView->imageBasedRendering());
+    b->setTheme(Theme::p()->currentThemeName());
+    b->setWidth(mMainView->size().width());
+    b->setHeight(mMainView->size().height());
+
+    QGraphicsWidget *tw = mMainView->testWidget();
+    ItemRecyclingList *list = dynamic_cast<ItemRecyclingList *>(tw);
+
+    if (list) {
+        QString type = list->objectName();
+        
+        if(mResMon && mCpuMemLogging) {
+            //CPU/MEM begin
+            mResMon->BeginMeasureCPULoad(); 
+            mResMon->BeginMeasureMemoryLoad();
+        }
+        
+        QTime t;
+        t.start();
+
+        for (int i=0; i<itemCount; ++i)
+           delete list->takeItem(0);
+
+        int took = t.elapsed();
+        
+        if(mResMon && mCpuMemLogging) {
+            //CPU/MEM end
+            createCpuBenchmark(testFunctionResult, tag, itemCount, Benchmark::RecyclingListType,Theme::p()->currentThemeName(), mResMon->EndMeasureCPULoad());
+            createMemoryBenchmark(testFunctionResult, tag, itemCount, Benchmark::RecyclingListType, Theme::p()->currentThemeName(), mResMon->EndMeasureMemoryLoad());
+        }
+        
+        b->setValue(took);
+        b->setListType(Benchmark::RecyclingListType);
+    }
+    else {
+        SimpleList *list = dynamic_cast<SimpleList*>(tw);
+        if (list) {
+            QString type = list->objectName();
+            
+            if(mResMon && mCpuMemLogging) {
+                //CPU/MEM begin
+                mResMon->BeginMeasureCPULoad(); 
+                mResMon->BeginMeasureMemoryLoad();
+            }
+            
+            QTime t;
+            t.start();
+
+            for (int i=0; i<itemCount; ++i)
+                delete list->takeItem(0);
+
+            int took = t.elapsed();
+            
+            if(mResMon && mCpuMemLogging) {
+                //CPU/MEM end
+                createCpuBenchmark(testFunctionResult, tag, itemCount, Benchmark::SimpleListType, Theme::p()->currentThemeName(), mResMon->EndMeasureCPULoad());
+                createMemoryBenchmark(testFunctionResult, tag, itemCount, Benchmark::SimpleListType,Theme::p()->currentThemeName(), mResMon->EndMeasureMemoryLoad());
+            }
+            
+            b->setValue(took);
+            b->setListType(Benchmark::SimpleListType);
+        }
+    }
+
+    QTimer::singleShot(EmitDoneTimeout, this, SLOT(testIsDone()));
+}
+
+
+
+void TestController::themeChange(int theme, TestFunctionResult *testFunctionResult, const QString &tag)
+{
+    if (!mMainView) {
+        QTimer::singleShot(EmitDoneTimeout, this, SLOT(testIsDone()));
+        return;
+    }
+
+    QString listName = "";
+    int itemCount = 0;
+    Benchmark::ListType type = Benchmark::ListTypeNone;
+
+    QGraphicsWidget *tw = mMainView->testWidget();
+    ItemRecyclingList *list = dynamic_cast<ItemRecyclingList *>(tw);
+    if (list) {
+        type = Benchmark::RecyclingListType;
+        itemCount = list->indexCount();
+    }
+    else {
+        SimpleList *list = dynamic_cast<SimpleList*>(tw);
+        if (list) {
+            type = Benchmark::SimpleListType;
+            itemCount = list->itemCount();
+        }
+        else {
+            QTimer::singleShot(EmitDoneTimeout, this, SLOT(testIsDone()));
+            return;
+        }
+    }
+
+    Benchmark *b = testFunctionResult->createBenchmark();
+    b->setTag(tag);
+    b->setTheme(Theme::p()->currentThemeName());
+
+    //CPU/MEM begin
+    QString currentTheme = Theme::p()->currentThemeName();
+    if(mResMon && mCpuMemLogging) {
+        mResMon->BeginMeasureCPULoad(); 
+        mResMon->BeginMeasureMemoryLoad();
+    }
+    
+    QTime t;
+    t.start();
+    Theme::p()->setTheme(Theme::Themes(theme));
+    int took = t.elapsed();
+    b->setValue(took);
+    b->setRotation(mainWindowRotationAngle());
+    b->setListType(type);
+    b->setListSize(itemCount);
+    b->setUseListItemCache(mSubtreeCacheEnabled);
+    b->setImageBasedRendering(mMainView->imageBasedRendering());
+    b->setWidth(mMainView->size().width());
+    b->setHeight(mMainView->size().height());
+
+    if(mResMon && mCpuMemLogging) {
+        //CPU/MEM end
+        createCpuBenchmark(testFunctionResult, tag, itemCount, type, currentTheme, mResMon->EndMeasureCPULoad());
+        createMemoryBenchmark(testFunctionResult, tag, itemCount, type,currentTheme, mResMon->EndMeasureMemoryLoad());
+    }
+    
+    QTimer::singleShot(EmitDoneTimeout, this, SLOT(testIsDone()));
+}
+
+void TestController::forceUpdate(int maxTimeMs, TestFunctionResult *testFunctionResult, const QString &tag)
+{
+    if (!mMainView) {
+        QTimer::singleShot(EmitDoneTimeout, this, SLOT(testIsDone()));
+        return;
+    }
+
+    QGraphicsWidget *tw = mMainView->testWidget();
+    ItemRecyclingList *list = dynamic_cast<ItemRecyclingList *>(tw);
+    if (list) {
+        mCurrentRecyclingList = list;
+    }
+    else {
+        SimpleList *list = dynamic_cast<SimpleList*>(tw);
+        if (list) {
+            mCurrentSimpleList = list;
+        }
+        else {
+            QTimer::singleShot(EmitDoneTimeout, this, SLOT(testIsDone()));
+        }
+    }
+    connect(this, SIGNAL(doForceUpdate(TestFunctionResult*, const QString &)),
+            this, SLOT(doForceUpdateViewport(TestFunctionResult*, const QString &)), Qt::QueuedConnection);
+    mMaxTestDurationTime = maxTimeMs;
+    mMainView->fpsReset();
+    mTestDuration.start();
+
+    emit doForceUpdate(testFunctionResult, tag);
+}
+
+void TestController::applicationExit()
+{
+    QApplication::exit();
+}
+
+void TestController::deleteList(TestFunctionResult *testFunctionResult, const QString &tag)
+{
+    Benchmark *b = testFunctionResult->createBenchmark();
+    b->setTag(tag);
+    b->setRotation(mainWindowRotationAngle());
+    b->setUseListItemCache(mSubtreeCacheEnabled);
+    b->setImageBasedRendering(mMainView->imageBasedRendering());
+    b->setTheme(Theme::p()->currentThemeName());
+    b->setWidth(mMainView->size().width());
+    b->setHeight(mMainView->size().height());
+
+    int itemCount = 0;
+    QGraphicsWidget *tw = mMainView->takeTestWidget();
+    ItemRecyclingList *list = dynamic_cast<ItemRecyclingList *>(tw);
+    if (list) {
+        itemCount = list->indexCount();
+        
+        if(mResMon && mCpuMemLogging) {
+            //CPU/MEM begin
+            mResMon->BeginMeasureCPULoad(); 
+            mResMon->BeginMeasureMemoryLoad();
+        }
+        
+        QTime t;
+        t.start();
+        delete list;
+        int took = t.elapsed();
+        b->setValue(took);
+        b->setListSize(itemCount);
+        b->setListType(Benchmark::RecyclingListType);
+        
+        if(mResMon && mCpuMemLogging) {
+            //CPU/MEM end
+            createCpuBenchmark(testFunctionResult, tag, itemCount, Benchmark::RecyclingListType,Theme::p()->currentThemeName(), mResMon->EndMeasureCPULoad());
+            createMemoryBenchmark(testFunctionResult, tag, itemCount, Benchmark::RecyclingListType,Theme::p()->currentThemeName(), mResMon->EndMeasureMemoryLoad());
+        }
+        
+    }
+    else {
+        SimpleList *list = dynamic_cast<SimpleList*>(tw);
+        if (list) {
+            itemCount = list->itemCount();
+            
+            if(mResMon && mCpuMemLogging) {
+                //CPU/MEM begin
+                mResMon->BeginMeasureCPULoad(); 
+                mResMon->BeginMeasureMemoryLoad();
+            }
+            
+            QTime t;
+            t.start();
+            delete list;
+            int took = t.elapsed();
+            b->setValue(took);
+            b->setListSize(itemCount);
+            b->setListType(Benchmark::SimpleListType);
+            
+            if(mResMon && mCpuMemLogging) {
+                //CPU/MEM end
+                createCpuBenchmark(testFunctionResult, tag, itemCount, Benchmark::SimpleListType,Theme::p()->currentThemeName(), mResMon->EndMeasureCPULoad());
+                createMemoryBenchmark(testFunctionResult, tag, itemCount, Benchmark::SimpleListType,Theme::p()->currentThemeName(), mResMon->EndMeasureMemoryLoad());
+            }
+        }
+    }
+
+    QTimer::singleShot(EmitDoneTimeout, this, SLOT(testIsDone()));
+}
+
+void TestController::scrollSimpleList(TestFunctionResult *testFunctionResult, const QString &tag)
+{
+    int elapsed = mTestDuration.elapsed();
+    if(!mCurrentSimpleList ||
+       elapsed > mMaxTestDurationTime) {
+        if (mMainView) {
+            qreal fps = mMainView->fps();
+
+            Benchmark *b = testFunctionResult->createBenchmark();
+            b->setTag(tag);
+            b->setValue(fps);
+            if (mCurrentSimpleList)
+                b->setListSize(mCurrentSimpleList->itemCount());
+            b->setRotation(mainWindowRotationAngle());
+            b->setImageBasedRendering(mMainView->imageBasedRendering());
+            b->setTheme(Theme::p()->currentThemeName());
+            b->setUseListItemCache(mSubtreeCacheEnabled);
+            b->setListType(Benchmark::SimpleListType);
+            b->setWidth(mMainView->size().width());
+            b->setHeight(mMainView->size().height());
+
+            if(mResMon && mCpuMemLogging) {
+                //CPU/MEM end
+                createCpuBenchmark(testFunctionResult, tag, mCurrentSimpleList->itemCount(), Benchmark::SimpleListType,Theme::p()->currentThemeName(), mResMon->EndMeasureCPULoad());
+               createMemoryBenchmark(testFunctionResult, tag, mCurrentSimpleList->itemCount(), Benchmark::SimpleListType,Theme::p()->currentThemeName(), mResMon->EndMeasureMemoryLoad());
+            }
+        }
+        disconnect(SIGNAL(doScrollSimpleList(TestFunctionResult*, const QString &)),
+                   this, SLOT(scrollSimpleList(TestFunctionResult*, const QString &)));
+
+        if (mCurrentSimpleList) { // Scroll to begin before next case.
+            ScrollBar *sb = mCurrentSimpleList->verticalScrollBar();
+
+            if (sb) {
+                sb->setSliderPosition(0);
+            }
+        }
+        QTimer::singleShot(EmitDoneTimeout, this, SLOT(testIsDone()));
+        return;
+    }
+
+    ScrollBar *sb = mCurrentSimpleList->verticalScrollBar();
+
+    if (sb) {
+        int sinceLast = elapsed - mLastElapsed;
+        qreal sliderSize = sb->sliderSize();
+        qreal currentVal = sb->sliderPosition();
+        qreal increment = (mScrollDirection*mScrollStep*sinceLast)/16.6666; // Targeting 1.0 = 1 per 60FPS frame
+        qreal target = currentVal + increment;
+        while (target<0.0 || target>sliderSize) {
+            if (target < 0.0) {
+                target = -target; // Reflect
+                mScrollDirection = -1*mScrollDirection;
+            }
+            else if (target > sliderSize) {
+                target = sliderSize - (target-sliderSize); // Reflect
+                mScrollDirection = -1*mScrollDirection;
+            }
+        }
+
+        sb->setSliderPosition(target);
+    }
+
+    mLastElapsed = elapsed;
+
+    emit doScrollSimpleList(testFunctionResult, tag);
+}
+
+void TestController::scrollRecyclingList(TestFunctionResult *testFunctionResult, const QString &tag)
+{
+    int elapsed = mTestDuration.elapsed();
+    if(!mCurrentRecyclingList ||
+       elapsed > mMaxTestDurationTime) {
+       if (mMainView) {
+            qreal fps = mMainView->fps();
+
+            Benchmark *b = testFunctionResult->createBenchmark();
+            b->setTag(tag);
+            b->setValue(fps);
+            if (mCurrentRecyclingList)
+                b->setListSize(mCurrentRecyclingList->indexCount());
+            b->setRotation(mainWindowRotationAngle());
+            b->setImageBasedRendering(mMainView->imageBasedRendering());
+            b->setTheme(Theme::p()->currentThemeName());
+            b->setUseListItemCache(mSubtreeCacheEnabled);            
+            b->setListType(Benchmark::RecyclingListType);
+            b->setWidth(mMainView->size().width());
+            b->setHeight(mMainView->size().height());
+
+            if(mResMon && mCpuMemLogging) {
+                //CPU/MEM end
+                createCpuBenchmark(testFunctionResult, tag, mCurrentRecyclingList->indexCount(), Benchmark::RecyclingListType,Theme::p()->currentThemeName(), mResMon->EndMeasureCPULoad());
+                createMemoryBenchmark(testFunctionResult, tag, mCurrentRecyclingList->indexCount(), Benchmark::RecyclingListType,Theme::p()->currentThemeName(), mResMon->EndMeasureMemoryLoad());
+            }
+                    
+        }
+        disconnect(SIGNAL(doScrollRecyclingList(TestFunctionResult*, const QString &)),
+                  this, SLOT(scrollRecyclingList(TestFunctionResult*, const QString &)));
+
+         if (mCurrentRecyclingList) { // Scroll to begin before next case.
+            ScrollBar *sb = mCurrentRecyclingList->verticalScrollBar();
+
+            if (sb) {
+                sb->setSliderPosition(0);
+            }
+        }
+        QTimer::singleShot(EmitDoneTimeout, this, SLOT(testIsDone()));
+        return;
+    }
+
+    ScrollBar *sb = mCurrentRecyclingList->verticalScrollBar();
+
+    if (sb) {
+        int sinceLast = elapsed - mLastElapsed;
+        qreal sliderSize = sb->sliderSize();
+        qreal currentVal = sb->sliderPosition();
+        qreal increment = (mScrollDirection*mScrollStep*sinceLast)/16.6666; // Targeting 1.0 = 1 per 60FPS frame
+        qreal target = currentVal + increment;
+        while (target<0.0 || target>sliderSize) {
+            if (target < 0.0) {
+                target = -target; // Reflect
+                mScrollDirection = -1*mScrollDirection;
+            }
+            else if (target > sliderSize) {
+                target = sliderSize - (target-sliderSize); // Reflect
+                mScrollDirection = -1*mScrollDirection;
+            }
+        }
+
+        sb->setSliderPosition(target);
+    }
+
+    mLastElapsed = elapsed;
+
+    emit doScrollRecyclingList(testFunctionResult, tag);
+}
+
+void TestController::doForceUpdateViewport(TestFunctionResult *testFunctionResult, const QString &tag)
+{
+    if (mTestDuration.elapsed() > mMaxTestDurationTime) {
+       if (mMainView) {
+            qreal fps = mMainView->fps();
+            Benchmark::ListType type = Benchmark::ListTypeNone;
+            int items = 0;
+
+            QGraphicsWidget *tw = mMainView->testWidget();
+            ItemRecyclingList *list = dynamic_cast<ItemRecyclingList *>(tw);
+            if (list) {
+                type = Benchmark::RecyclingListType;
+                items = list->indexCount();
+            }
+            else {
+                SimpleList *list = dynamic_cast<SimpleList*>(tw);
+                if (list) {
+                    type = Benchmark::SimpleListType;
+                    items = list->itemCount();
+                }
+            }
+            Benchmark *b = testFunctionResult->createBenchmark();
+            b->setTag(tag);
+            b->setValue(fps);
+            b->setRotation(mainWindowRotationAngle());
+            b->setListSize(items);
+            b->setImageBasedRendering(mMainView->imageBasedRendering());
+            b->setTheme(Theme::p()->currentThemeName());
+            b->setUseListItemCache(mSubtreeCacheEnabled);
+            b->setListType(type);
+            b->setWidth(mMainView->size().width());
+            b->setHeight(mMainView->size().height());
+
+            mMainView->fpsReset();
+        }
+       disconnect(SIGNAL(doForceUpdate(TestFunctionResult*, const QString &)),
+                  this, SLOT(doForceUpdateViewport(TestFunctionResult*, const QString &)));
+       QTimer::singleShot(EmitDoneTimeout, this, SLOT(testIsDone()));
+        return;
+    }
+    else if (mMainView) {
+        mMainView->viewport()->update();
+        emit doForceUpdate(testFunctionResult, tag);
+        return;
+    }
+    else {
+        mMainView->fpsReset();
+        QTimer::singleShot(EmitDoneTimeout, this, SLOT(testIsDone()));
+        return;
+    }
+}
+
+void TestController::setImageBasedRendering(const bool imageBasedRendering)
+{
+    if (mMainView)
+        mMainView->setImageBasedRendering(imageBasedRendering);
+}
+bool TestController::imageBasedRendering() const
+{
+    if (mMainView)
+        return mMainView->imageBasedRendering();
+    return false;
+}
+
+void TestController::setTwoColumns(const bool twoCols)
+{
+    QGraphicsWidget *tw = mMainView->testWidget();
+    ItemRecyclingList *list = dynamic_cast<ItemRecyclingList *>(tw);
+    if (list) {
+        list->setTwoColumns(twoCols);
+    }
+    else {
+        SimpleList *list = dynamic_cast<SimpleList*>(tw);
+        if (list) {
+            list->setTwoColumns(twoCols);
+        }
+    }
+
+    QTimer::singleShot(EmitDoneTimeout, this, SLOT(testIsDone()));
+}
+
+bool TestController::twoColumns() const
+{
+    QGraphicsWidget *tw = mMainView->takeTestWidget();
+    ItemRecyclingList *list = dynamic_cast<ItemRecyclingList *>(tw);
+    if (list) {
+        return list->twoColumns();
+    }
+    else {
+        SimpleList *list = dynamic_cast<SimpleList*>(tw);
+        if (list)
+            return list->twoColumns();
+    }
+    return false;
+}
+
+bool TestController::loadPlugin()
+{
+    QDir pluginsDir(qApp->applicationDirPath());
+#if defined Q_OS_LINUX
+    pluginsDir.cdUp();
+    pluginsDir.cd("plugins");
+#endif
+    foreach (QString fileName, pluginsDir.entryList(QDir::Files)) {
+        QPluginLoader pluginLoader(pluginsDir.absoluteFilePath(fileName));
+        QObject *plugin = pluginLoader.instance();
+        if (plugin) {
+            mResMon = qobject_cast<ResourceMonitorInterface *>(plugin);
+            if (mResMon) 
+                return true;
+        }
+        else {
+            qDebug() << "Error while loading plugin: "
+                    << pluginsDir.absoluteFilePath(fileName)
+                    << ". Error: " << pluginLoader.errorString();
+        }
+    }
+    return false;
+}
+
+void TestController::createCpuBenchmark(TestFunctionResult *testFunctionResult, const QString &tag, int listItems,  Benchmark::ListType type, const QString &theme, ResourceMonitorInterface::CpuUsage cpuUsage)
+{
+    Benchmark* bThread = testFunctionResult->createBenchmark();
+    Benchmark* bSystem = testFunctionResult->createBenchmark();
+    
+    bThread->setTag(QString("CPU AppThread " + tag));
+    bThread->setRotation(mainWindowRotationAngle());
+    bThread->setListSize(listItems);
+    bThread->setListType(type);
+    bThread->setTheme(theme);
+    bThread->setValue(cpuUsage.appTreadUsage);
+    bThread->setWidth(mMainView->size().width());
+    bThread->setHeight(mMainView->size().height());
+    bSystem->setTag(QString("CPU System " + tag));
+    bSystem->setRotation(mainWindowRotationAngle());
+    bSystem->setListSize(listItems);
+    bSystem->setListType(type);
+    bSystem->setTheme(theme);
+    bSystem->setValue(cpuUsage.systemUsage);
+    bSystem->setWidth(mMainView->size().width());
+    bSystem->setHeight(mMainView->size().height());
+}
+
+void TestController::createMemoryBenchmark(TestFunctionResult *testFunctionResult, const QString &tag, int listItems,  Benchmark::ListType type, const QString &theme, ResourceMonitorInterface::MemoryAllocation allocation)
+{
+    Benchmark* bAllocated = testFunctionResult->createBenchmark();
+    Benchmark* bAppHeap = testFunctionResult->createBenchmark();
+    Benchmark* bAvailableSystem = testFunctionResult->createBenchmark();
+    
+    bAllocated->setTag(QString("Memory AppAllocInCells " + tag));
+    bAllocated->setRotation(mainWindowRotationAngle());
+    bAllocated->setListSize(listItems);
+    bAllocated->setListType(type);
+    bAllocated->setTheme(theme);
+    bAllocated->setUseListItemCache(mSubtreeCacheEnabled);
+    if (mMainView)
+        bAllocated->setImageBasedRendering(mMainView->imageBasedRendering());
+    bAllocated->setValue(allocation.allocatedInAppThread);
+    bAllocated->setWidth(mMainView->size().width());
+    bAllocated->setHeight(mMainView->size().height());
+    bAppHeap->setTag(QString("Memory AvailAppHeap " + tag));
+    bAppHeap->setRotation(mainWindowRotationAngle());
+    bAppHeap->setListSize(listItems);
+    bAppHeap->setListType(type);
+    bAppHeap->setTheme(theme);
+    bAppHeap->setUseListItemCache(mSubtreeCacheEnabled);
+    if (mMainView)
+        bAppHeap->setImageBasedRendering(mMainView->imageBasedRendering());
+    bAppHeap->setValue(allocation.availableMemoryInAppThreadHeap);
+    bAppHeap->setWidth(mMainView->size().width());
+    bAppHeap->setHeight(mMainView->size().height());
+    bAvailableSystem->setTag(QString("Memory AvailSystem " + tag));
+    bAvailableSystem->setRotation(mainWindowRotationAngle());
+    bAvailableSystem->setListSize(listItems);
+    bAvailableSystem->setListType(type);
+    bAvailableSystem->setTheme(theme);
+    bAvailableSystem->setUseListItemCache(mSubtreeCacheEnabled);
+    if (mMainView)
+        bAvailableSystem->setImageBasedRendering(mMainView->imageBasedRendering());
+    bAvailableSystem->setValue(allocation.availableMemoryInSystem);
+    bAvailableSystem->setWidth(mMainView->size().width());
+    bAvailableSystem->setHeight(mMainView->size().height());
+}
+