activityfw/testapplications/newtestappset/acttestbenchmark/hbmeasuretest.cpp
changeset 117 c63ee96dbe5f
equal deleted inserted replaced
115:3ab5c078b490 117:c63ee96dbe5f
       
     1 /*
       
     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
       
     3 * All rights reserved.
       
     4 * This component and the accompanying materials are made available
       
     5 * under the terms of "Eclipse Public License v1.0"
       
     6 * which accompanies this distribution, and is available
       
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     8 *
       
     9 * Initial Contributors:
       
    10 * Nokia Corporation - initial contribution.
       
    11 *
       
    12 * Contributors:
       
    13 *
       
    14 * Description:
       
    15 *
       
    16 */
       
    17 
       
    18 #include "hbmeasuretest.h"
       
    19 
       
    20 #include <QGridLayout>
       
    21 #include <HbLabel>
       
    22 #include <HbPushButton>
       
    23 #include <QCoreApplication>
       
    24 #include <QSignalMapper>
       
    25 #include <QVariant>
       
    26 #include <QList>
       
    27 #include <QVariantHash>
       
    28 #include <HbComboBox>
       
    29 #include <QBrush>
       
    30 #include <QPalette>
       
    31 #include <QGraphicsGridLayout>
       
    32 #include <QTimer>
       
    33 #include <QFile>
       
    34 #include <QTextStream>
       
    35 #include <e32std.h>
       
    36 #include <HbInstance>
       
    37 #include <qservicemanager.h>
       
    38 #include <HbScrollArea>
       
    39 #include <afactivitystorage.h>
       
    40 #include <afactivation.h>
       
    41 #include "afstorageglobals.h"
       
    42 #include <HbCheckBox>
       
    43 
       
    44 
       
    45 QTM_USE_NAMESPACE
       
    46 
       
    47 MeasureTest::MeasureTest(QGraphicsItem *parent) : HbView(parent), mByteArray(NULL)
       
    48 
       
    49 {
       
    50     mFile = new QFile("c:\\actbenchmark.txt");    
       
    51     mFile->open(QIODevice::Append | QIODevice::Text);
       
    52     mStream = new QTextStream(mFile);
       
    53     
       
    54     mThumbwait = 0;
       
    55     mThumbnull = 0;
       
    56     mThumbcurrent = 0;
       
    57     QServiceManager serviceManager;
       
    58     serviceManager.addService(":/activityserviceplugin.xml");
       
    59     
       
    60     mActivityManager = serviceManager.loadInterface("com.nokia.qt.activities.ActivityManager");
       
    61     if (!mActivityManager) {
       
    62         qFatal("Cannot initialize critical com.nokia.qt.activities.ActivityManager service.");
       
    63         }
       
    64         
       
    65     mThumbwait = 0;
       
    66     mThumbnull = 0;
       
    67     mThumbcurrent = 0;
       
    68     mActivityStorage = new AfActivityStorage;
       
    69     mActivation = new AfActivation;
       
    70         
       
    71     HbWidget* widget = new HbWidget;
       
    72     HbScrollArea* scrollArea = new HbScrollArea; 
       
    73 	
       
    74     mResultLabel = new HbLabel();
       
    75     mItemLabel = new HbLabel();
       
    76     mTimesLabel = new HbLabel("Times");
       
    77     mBytesLabel = new HbLabel("Bytes");
       
    78     mPixmapLabel = new HbLabel("Pixmap");  	  
       
    79     mSizeLabel = new HbLabel("Size(WxH)");
       
    80 
       
    81     mPixmap = new QPixmap(":/images/wolf.bmp");
       
    82     mEmptyPixmap = new QPixmap();
       
    83 
       
    84 
       
    85     mTimesCombo = new HbComboBox();
       
    86     mLengthCombo = new HbComboBox();
       
    87     mPixmapCombo = new HbComboBox();
       
    88     mWidthCombo = new HbComboBox();
       
    89     mHeightCombo = new HbComboBox();
       
    90 
       
    91     mTimesCombo->addItem("1");
       
    92     mTimesCombo->addItem("2");	
       
    93     mTimesCombo->addItem("4");
       
    94     mTimesCombo->addItem("5");
       
    95     mTimesCombo->addItem("10");
       
    96     mTimesCombo->addItem("20");
       
    97     mTimesCombo->addItem("40");
       
    98     mTimesCombo->addItem("60");
       
    99 
       
   100     QVariant variant;
       
   101     variant = 10;
       
   102     mLengthCombo->addItem("10 B", variant);
       
   103     variant = 100;
       
   104     mLengthCombo->addItem("100 B", variant);
       
   105     variant = 1024;
       
   106     mLengthCombo->addItem("1 KB", variant);
       
   107     variant = 10240;
       
   108     mLengthCombo->addItem("10 KB", variant);
       
   109     variant = 102400;
       
   110     mLengthCombo->addItem("100 KB", variant);
       
   111     variant = 1024*1024;
       
   112     mLengthCombo->addItem("1 MB", variant);
       
   113     
       
   114     mWidthCombo->addItem("360");
       
   115     mWidthCombo->addItem("180");
       
   116     mWidthCombo->addItem("128");
       
   117     mWidthCombo->addItem("90");
       
   118     
       
   119     mHeightCombo->addItem("640");
       
   120     mHeightCombo->addItem("320");
       
   121     mHeightCombo->addItem("160");
       
   122     mHeightCombo->addItem("128");
       
   123     
       
   124 
       
   125     mPixmapCombo->addItem("no");
       
   126     mPixmapCombo->addItem("yes");
       
   127     mPixmapCombo->addItem("grab");
       
   128 
       
   129     mSaveButton = new HbPushButton("Save activities");
       
   130     mGetButton = new HbPushButton("Get activities");
       
   131     mDelButton = new HbPushButton("Delete activities");
       
   132     mGetDataButton = new HbPushButton("Get activities data");
       
   133     mUpdateButton = new HbPushButton("Reserved");
       
   134     mThumbButton = new HbPushButton("Get act with thumb");
       
   135     mGetDataTimesButton = new HbPushButton("Get data times");
       
   136     mSaveTimesButton = new HbPushButton("Add act times");
       
   137     mSave10TimesButton = new HbPushButton("Add 10 act times");;
       
   138 
       
   139     mSaveDekCheckBox = new HbCheckBox("Delete before Save");
       
   140     mSaveDekCheckBox->setCheckState(Qt::Checked);
       
   141 
       
   142     mLayout  = new QGraphicsGridLayout();
       
   143     mLayout->addItem(mSizeLabel, 2, 0, 1, 2);
       
   144     mLayout->addItem(mWidthCombo, 2, 2, 1, 2);
       
   145     mLayout->addItem(mHeightCombo, 2, 4, 1, 2);
       
   146     mLayout->addItem(mTimesLabel, 3, 0, 1, 2);
       
   147     mLayout->addItem(mBytesLabel, 3, 2, 1, 2);
       
   148     mLayout->addItem(mPixmapLabel, 3, 4, 1, 2);
       
   149     mLayout->addItem(mTimesCombo, 4, 0, 1, 2);
       
   150     mLayout->addItem(mLengthCombo, 4, 2, 1, 2);
       
   151     mLayout->addItem(mPixmapCombo, 4, 4, 1, 2);
       
   152     mLayout->addItem(mSaveButton, 5, 0, 1, 6);
       
   153     mLayout->addItem(mGetButton, 6, 0, 1, 6);
       
   154     mLayout->addItem(mDelButton, 7, 0, 1, 6);
       
   155     mLayout->addItem(mGetDataButton, 8, 0, 1, 6);
       
   156     mLayout->addItem(mUpdateButton, 9, 0, 1, 6);
       
   157     mLayout->addItem(mThumbButton, 10, 0, 1, 6);
       
   158     mLayout->addItem(mSaveTimesButton, 11, 0, 1, 6);
       
   159     mLayout->addItem(mSave10TimesButton, 12, 0, 1, 6);
       
   160     mLayout->addItem(mGetDataTimesButton, 13, 0, 1, 6);
       
   161     mLayout->addItem(mSaveDekCheckBox, 14, 0, 1, 6);
       
   162     widget->setLayout(mLayout);
       
   163     
       
   164     scrollArea->setContentWidget(widget);
       
   165     scrollArea->setScrollDirections(Qt::Vertical);
       
   166     scrollArea->setVerticalScrollBarPolicy(HbScrollArea::ScrollBarAlwaysOff);
       
   167     connect(mSaveButton, SIGNAL(released()), this, SLOT(saveActivity()));
       
   168     connect(mGetButton, SIGNAL(released()), this, SLOT(getActivity()));
       
   169     connect(mDelButton, SIGNAL(released()), this, SLOT(deleteActivity()));
       
   170     connect(mGetDataButton, SIGNAL(released()), this, SLOT(getActivityData()));
       
   171     connect(mUpdateButton, SIGNAL(released()), this, SLOT(updateActivity()));
       
   172     connect(mThumbButton, SIGNAL(released()), this, SLOT(getActivityThumb()));
       
   173     connect(mGetDataTimesButton, SIGNAL(released()), this, SLOT(getTimesActivityData()));
       
   174     connect(mSaveTimesButton, SIGNAL(released()), this, SLOT(saveTimes()));
       
   175     connect(mSave10TimesButton, SIGNAL(released()), this, SLOT(save10actTimes()));
       
   176 
       
   177     QGraphicsGridLayout* mainLayout = new QGraphicsGridLayout;
       
   178     mainLayout->addItem(mResultLabel, 0, 0, 1, 6);
       
   179     mainLayout->addItem(mItemLabel, 1, 0, 1, 6);
       
   180     mainLayout->addItem(scrollArea, 2, 0, 1, 6);    
       
   181     setLayout(mainLayout);
       
   182 
       
   183 }
       
   184 
       
   185 MeasureTest::~MeasureTest()
       
   186 {
       
   187     delete mFile;
       
   188     delete mStream;
       
   189     delete mEmptyPixmap;
       
   190     delete mPixmap;    
       
   191     delete mActivityManager;
       
   192     delete mActivityStorage;
       
   193     delete mActivation;
       
   194 }
       
   195 
       
   196 
       
   197 void MeasureTest::Before()
       
   198 {
       
   199     TTime time;
       
   200     time.HomeTime();
       
   201     iBefore = time.Int64();
       
   202 }
       
   203 
       
   204 void MeasureTest::After()
       
   205 {
       
   206     TTime time;
       
   207     time.HomeTime();
       
   208     iAfter = time.Int64();
       
   209 }
       
   210 
       
   211 void MeasureTest::Result()
       
   212 {
       
   213     TInt64 res(0);
       
   214     res = iAfter-iBefore;
       
   215     res = res/1000;
       
   216     iResult = res;
       
   217 }
       
   218 
       
   219 void  MeasureTest::deleteActivity()
       
   220 {
       
   221     QStringList activities = mActivityStorage->allActivities();    
       
   222     QString name;
       
   223     Before();
       
   224     bool ok = false;
       
   225     for (int i=0; i<activities.count(); i++) {
       
   226         ok = mActivityStorage->removeActivity(activities.at(i));        
       
   227         if (!ok) {
       
   228             break;
       
   229         }
       
   230     }
       
   231     After();
       
   232     Result();
       
   233     
       
   234     mItemMessage.clear();
       
   235     mResultMessage.clear();
       
   236 
       
   237     if (!ok) {
       
   238         mItemMessage = (tr("invoke error"));
       
   239         mResultMessage = (tr("invoke error"));
       
   240     } else {
       
   241         mItemMessage = (tr("items: %1")).arg(activities.count());
       
   242         mResultMessage = (tr("time: %1 ms")).arg(iResult);
       
   243     }
       
   244     mItemLabel->setPlainText(mItemMessage);
       
   245     mResultLabel->setPlainText(mResultMessage);
       
   246 }
       
   247 
       
   248 void  MeasureTest::getActivity()
       
   249 {
       
   250     QStringList activities;
       
   251     Before();
       
   252     activities = mActivityStorage->allActivities(); 
       
   253     After();
       
   254     Result();
       
   255     int count = activities.count();
       
   256     mItemMessage.clear();
       
   257     mResultMessage.clear();
       
   258 
       
   259     mItemMessage = (tr("items: %1")).arg(count);
       
   260     mResultMessage = (tr("time: %1 ms")).arg(iResult);
       
   261 
       
   262     mItemLabel->setPlainText(mItemMessage);
       
   263     mResultLabel->setPlainText(mResultMessage);
       
   264 }
       
   265 
       
   266 void  MeasureTest::getActivityThumb()
       
   267 {
       
   268     disconnect( mActivityManager, SIGNAL(thumbnailReady(QPixmap, void *)), this, SLOT(thumbnailReady(QPixmap, void *)) );
       
   269     connect( mActivityManager, SIGNAL(thumbnailReady(QPixmap, void *)), this, SLOT(thumbnailReady(QPixmap, void *)) );
       
   270     mThumbwait = 0;
       
   271     mThumbnull = 0;
       
   272     mThumbcurrent = 0;
       
   273     bool ok = false;
       
   274     QStringList activities;
       
   275     Before();
       
   276     activities = mActivityStorage->allActivities();   
       
   277     mThumbwait = activities.count();
       
   278     int width = mWidthCombo->currentText().toInt();
       
   279     int height = mHeightCombo->currentText().toInt();
       
   280     QSize pixSize(width, height);
       
   281     for ( int i=0; i<activities.count(); i++)
       
   282         {
       
   283         QString pixfile = mActivityStorage->activityMetaData(activities.at(i)).value(ActivityScreenshotKeyword).toString();
       
   284         ok = QMetaObject::invokeMethod(mActivityManager, "getThumbnail", Q_ARG(QSize, pixSize), Q_ARG(QString, pixfile), Q_ARG(void*, NULL));        
       
   285         if ( !ok )
       
   286             {
       
   287             break;
       
   288             }        
       
   289         }
       
   290 
       
   291     int count = activities.count();
       
   292     mItemMessage.clear();
       
   293     mResultMessage.clear();
       
   294     if (!ok) {
       
   295         mItemMessage = (tr("invoke error"));
       
   296         mResultMessage = (tr("invoke error"));
       
   297         mItemLabel->setPlainText(mItemMessage);
       
   298         mResultLabel->setPlainText(mResultMessage);
       
   299     } else {
       
   300         
       
   301     }    
       
   302 }
       
   303 
       
   304 void MeasureTest::saveActivity()
       
   305 {
       
   306     int bytes = mLengthCombo->itemData(mLengthCombo->currentIndex()).toInt();
       
   307     delete mByteArray;
       
   308     mByteArray = NULL;
       
   309     mByteArray = new QByteArray(bytes, 'a');
       
   310     QVariant variant;
       
   311     variant = *mByteArray;
       
   312     QPixmap *pixmap = NULL;
       
   313     QPixmap screenshot;
       
   314     if (mPixmapCombo->currentText() == "yes") {
       
   315         pixmap = mPixmap;
       
   316     }
       
   317     else if ( mPixmapCombo->currentText() == "grab" )
       
   318     {
       
   319         HbMainWindow *mainWindow = hbInstance->allMainWindows().first();
       
   320         screenshot = QPixmap::grabWidget(mainWindow, mainWindow->rect());
       
   321         pixmap = &screenshot;
       
   322     }
       
   323     else
       
   324     {
       
   325         pixmap = mEmptyPixmap;
       
   326     }
       
   327     QVariantHash metadata;
       
   328     metadata.insert(ActivityScreenshotKeyword, *pixmap);
       
   329     int times = 0;
       
   330     times = mTimesCombo->currentText().toInt();
       
   331     bool ok = false;    
       
   332     Before();
       
   333     for (int i=0; i<times; i++) {
       
   334         QString name;
       
   335         name.setNum(i);
       
   336         ok = mActivityStorage->saveActivity(name, variant, metadata);
       
   337         if (!ok) {
       
   338             break;
       
   339         }
       
   340     }
       
   341     After();
       
   342     Result();
       
   343     mItemMessage.clear();
       
   344     mResultMessage.clear();
       
   345     if (!ok) {
       
   346         mItemMessage = (tr("invoke error"));
       
   347         mResultMessage = (tr("invoke error"));
       
   348     } else {
       
   349         mResultMessage = (tr("time: %1 ms")).arg(iResult);
       
   350     }
       
   351     mItemLabel->setPlainText(mItemMessage);
       
   352     mResultLabel->setPlainText(mResultMessage);
       
   353 }
       
   354 
       
   355 void MeasureTest::updateActivity()
       
   356 {
       
   357  
       
   358 }
       
   359 
       
   360 void MeasureTest::getActivityData()
       
   361 {
       
   362     QStringList activities = mActivityStorage->allActivities();    
       
   363 
       
   364     QString name;
       
   365     QVariant data;
       
   366     Before();
       
   367     for (int i=0; i<activities.count(); i++) {
       
   368         data = mActivityStorage->activityData(activities.at(i));
       
   369     }
       
   370     After();
       
   371     Result();
       
   372 
       
   373     mItemMessage.clear();
       
   374     mResultMessage.clear();
       
   375 
       
   376     mItemMessage = (tr("items: %1")).arg(activities.count());
       
   377     mResultMessage = (tr("time: %1 ms")).arg(iResult);
       
   378 
       
   379     mItemLabel->setPlainText(mItemMessage);
       
   380     mResultLabel->setPlainText(mResultMessage);
       
   381 }
       
   382 
       
   383 void MeasureTest::thumbnailReady(QPixmap pix, void * ptr)
       
   384     {
       
   385     if ( pix.isNull() )
       
   386         {
       
   387         mThumbnull++;
       
   388         }    
       
   389     mThumbcurrent++;
       
   390     mItemMessage = (tr("items: %1 from %2, but null %3")).arg(mThumbcurrent).arg(mThumbwait).arg(mThumbnull);
       
   391     mItemLabel->setPlainText(mItemMessage);
       
   392     mResultMessage = "";
       
   393     mResultLabel->setPlainText(mResultMessage);
       
   394     if (mThumbcurrent == mThumbwait)
       
   395         {
       
   396         After();
       
   397         Result();
       
   398         disconnect( mActivityManager, SIGNAL(thumbnailReady(QPixmap, void *)), this, SLOT(thumbnailReady(QPixmap, void *)) );
       
   399         mResultMessage = (tr("time: %1 ms")).arg(iResult);
       
   400         mResultLabel->setPlainText(mResultMessage);
       
   401         }
       
   402     }
       
   403 void MeasureTest::saveTimes()
       
   404 {
       
   405     *mStream<<"save Times\n";
       
   406     QList<int> trymeasure;
       
   407     int bytes = mLengthCombo->itemData(mLengthCombo->currentIndex()).toInt();
       
   408     delete mByteArray;
       
   409     mByteArray = NULL;
       
   410     mByteArray = new QByteArray(bytes, 'a');
       
   411     QVariant variant;
       
   412     variant = *mByteArray;
       
   413     QPixmap *pixmap = NULL;
       
   414     QPixmap screenshot;
       
   415     if (mPixmapCombo->currentText() == "yes") {
       
   416         pixmap = mPixmap;
       
   417     }
       
   418     else if ( mPixmapCombo->currentText() == "grab" )
       
   419     {
       
   420         HbMainWindow *mainWindow = hbInstance->allMainWindows().first();
       
   421         screenshot = QPixmap::grabWidget(mainWindow, mainWindow->rect());
       
   422         pixmap = &screenshot;
       
   423     }
       
   424     else
       
   425     {
       
   426         pixmap = mEmptyPixmap;
       
   427     }
       
   428     QVariantHash metadata;
       
   429     metadata.insert(ActivityScreenshotKeyword, *pixmap);
       
   430     int times = 0;
       
   431     times = mTimesCombo->currentText().toInt();
       
   432     bool ok = false;    
       
   433     QString name("0");
       
   434     bool delBefore = mSaveDekCheckBox->checkState() == Qt::Checked ? true : false;
       
   435     User::After(2000000); //2s
       
   436     for (int i=0; i<times; i++) {
       
   437         Before();
       
   438         ok = mActivityStorage->saveActivity(name, variant, metadata);
       
   439         After();
       
   440         Result();
       
   441         if (!ok) {
       
   442               break;
       
   443           }
       
   444         trymeasure.append(iResult);
       
   445         if (delBefore) {
       
   446             ok = mActivityStorage->removeActivity(name);   
       
   447             if (!ok) {
       
   448                 break;
       
   449             }
       
   450         }
       
   451         User::After(2000000); //2s
       
   452     }
       
   453 
       
   454     mItemMessage.clear();
       
   455     mResultMessage.clear();
       
   456     if (!ok) {
       
   457         mItemMessage = (tr("invoke error"));
       
   458         mResultMessage = (tr("invoke error"));
       
   459         *mStream<<"error\n";
       
   460     } else {
       
   461         int averageint = average(trymeasure);
       
   462         mResultMessage = (tr("time: %1 ms")).arg(averageint);
       
   463         writeResults(trymeasure, averageint);
       
   464     }
       
   465     mStream->flush();
       
   466     mItemLabel->setPlainText(mItemMessage);
       
   467     mResultLabel->setPlainText(mResultMessage);    
       
   468 }
       
   469 
       
   470 void MeasureTest::save10actTimes()
       
   471 {
       
   472     *mStream<<"save 10 act Times\n";
       
   473     QList<int> trymeasure;
       
   474     int bytes = mLengthCombo->itemData(mLengthCombo->currentIndex()).toInt();
       
   475     delete mByteArray;
       
   476     mByteArray = NULL;
       
   477     mByteArray = new QByteArray(bytes, 'a');
       
   478     QVariant variant;
       
   479     variant = *mByteArray;
       
   480     QPixmap *pixmap = NULL;
       
   481     QPixmap screenshot;
       
   482     bool delBefore = mSaveDekCheckBox->checkState() == Qt::Checked ? true : false;
       
   483     if (mPixmapCombo->currentText() == "yes") {
       
   484         pixmap = mPixmap;
       
   485     }
       
   486     else if ( mPixmapCombo->currentText() == "grab" )
       
   487     {
       
   488         HbMainWindow *mainWindow = hbInstance->allMainWindows().first();
       
   489         screenshot = QPixmap::grabWidget(mainWindow, mainWindow->rect());
       
   490         pixmap = &screenshot;
       
   491     }
       
   492     else
       
   493     {
       
   494         pixmap = mEmptyPixmap;
       
   495     }
       
   496     QVariantHash metadata;
       
   497     metadata.insert(ActivityScreenshotKeyword, *pixmap);
       
   498     int times = 0;
       
   499     times = mTimesCombo->currentText().toInt();
       
   500     bool ok = false;
       
   501     QString name;
       
   502     User::After(2000000); //2s
       
   503     for(int i=0; i<times; i++) {
       
   504         Before();
       
   505         for (int i=0; i<10; i++) {
       
   506             
       
   507             name.setNum(i);
       
   508             ok = mActivityStorage->saveActivity(name, variant, metadata);
       
   509             if (!ok) {
       
   510                 break;
       
   511             }            
       
   512         }
       
   513         After();
       
   514         Result();
       
   515         trymeasure.append(iResult);
       
   516         
       
   517         QStringList activities = mActivityStorage->allActivities();      
       
   518     
       
   519         if (delBefore) {
       
   520             for (int i=0; i<activities.count(); i++) {
       
   521                 ok = mActivityStorage->removeActivity(activities.at(i));    
       
   522                 if (!ok) {
       
   523                     break;
       
   524                 }
       
   525             }
       
   526         }
       
   527         User::After(2000000); //2s        
       
   528 
       
   529     }        
       
   530     mItemMessage.clear();
       
   531     mResultMessage.clear();
       
   532     if (!ok) {
       
   533         mItemMessage = (tr("invoke error"));
       
   534         mResultMessage = (tr("invoke error"));
       
   535         *mStream<<"error\n";
       
   536     } else {
       
   537         int averageint = average(trymeasure);
       
   538         mResultMessage = (tr("time: %1 ms")).arg(averageint);
       
   539         writeResults(trymeasure, averageint);
       
   540     }
       
   541     mStream->flush();
       
   542     mItemLabel->setPlainText(mItemMessage);
       
   543     mResultLabel->setPlainText(mResultMessage);    
       
   544     
       
   545 }
       
   546 
       
   547 void MeasureTest::getTimesActivityData()
       
   548 {
       
   549     int times = 0;
       
   550     times = mTimesCombo->currentText().toInt();
       
   551     *mStream<<"get data Times\n";
       
   552     QList<int> trymeasure;
       
   553     
       
   554     QStringList activities = mActivityStorage->allActivities();  
       
   555     User::After(2000000); //2s
       
   556     QString name;
       
   557     QVariant data;        
       
   558     for(int i=0; i<times; i++) {
       
   559         Before();
       
   560         for (int i=0; i<activities.count(); i++) {
       
   561             data = mActivityStorage->activityData(activities.at(i));
       
   562         }
       
   563         After();
       
   564         Result();
       
   565         trymeasure.append(iResult);
       
   566         User::After(2000000); //2s
       
   567     }
       
   568     mItemMessage.clear();
       
   569     mResultMessage.clear();
       
   570 
       
   571 
       
   572     int averageint = average(trymeasure);
       
   573     mResultMessage = (tr("time: %1 ms")).arg(averageint);
       
   574     writeResults(trymeasure, averageint);
       
   575     
       
   576     mStream->flush();
       
   577     mItemLabel->setPlainText(mItemMessage);
       
   578     mResultLabel->setPlainText(mResultMessage);
       
   579 
       
   580 }
       
   581 
       
   582 int MeasureTest::average(const QList<int>& list)
       
   583 {
       
   584     int count = list.count();
       
   585     int sum=0;
       
   586     for(int i=0; i<count; i++) {
       
   587         sum += list.at(i);
       
   588     }
       
   589     sum = (sum+0.5)/count;
       
   590     return sum;
       
   591 }
       
   592 
       
   593 int MeasureTest::writeResults(const QList<int>& list, int average)
       
   594 {
       
   595     for(int i=0; i<list.count(); i++){
       
   596         *mStream<<"|  ";
       
   597         *mStream<<list.at(i);
       
   598         *mStream<<"  |\n";
       
   599     }
       
   600     *mStream<<"|  ";
       
   601     *mStream<<average;
       
   602     *mStream<<"  |\n";
       
   603 }