activityfw/testapplications/newtestappset/actautobenchmark/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 
       
    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 #include <hblineedit.h>
       
    44 #include <f32file.h>
       
    45 
       
    46 QTM_USE_NAMESPACE
       
    47 
       
    48 const int KDefaultTimes = 10;
       
    49 const int KDefaultLoop = 10;
       
    50 const int KDefaultSaveBytes = 10*1024;
       
    51 const int KGet1Bytes = 10*1024;
       
    52 const int KGet2Bytes = 100*1024;
       
    53 const int KGet3Bytes = 1024*1024;
       
    54 const int KDefaultRepeat = 3;
       
    55 
       
    56 MeasureTest::MeasureTest(QGraphicsItem *parent) : HbView(parent), mByteArray(NULL),
       
    57     mActionCounter(0)
       
    58 
       
    59 {
       
    60     mFile = new QFile("c:\\data\\actautobenchmark.txt");    
       
    61     mFile->open(QIODevice::Append | QIODevice::Text);
       
    62     mStream = new QTextStream(mFile);
       
    63         
       
    64     QServiceManager serviceManager;
       
    65     serviceManager.addService(":/activityserviceplugin.xml");
       
    66     
       
    67     mActivityManager = serviceManager.loadInterface("com.nokia.qt.activities.ActivityManager");
       
    68     if (!mActivityManager) {
       
    69         qFatal("Cannot initialize critical com.nokia.qt.activities.ActivityManager service.");
       
    70         }
       
    71         
       
    72 
       
    73     mActivityStorage = new AfActivityStorage;
       
    74     mActivation = new AfActivation;
       
    75              	
       
    76     mResultLabel = new HbLabel();
       
    77     mItemLabel = new HbLabel();
       
    78 
       
    79 
       
    80     mSaveOneButton = new HbPushButton("Save 1 in loop");
       
    81     mSaveMoreButton = new HbPushButton("Save 10 in loop");    
       
    82     mGetButton = new HbPushButton("Get in loop");
       
    83     mAllButton = new HbPushButton("All");
       
    84     
       
    85 
       
    86     mLayout  = new QGraphicsGridLayout();
       
    87     mLayout->addItem(mResultLabel, 0, 0, 1, 6);
       
    88     mLayout->addItem(mItemLabel, 1, 0, 1, 6);
       
    89     mLayout->addItem(mSaveOneButton, 2, 0, 1, 6);
       
    90     mLayout->addItem(mSaveMoreButton, 3, 0, 1, 6);
       
    91     mLayout->addItem(mGetButton, 4, 0, 1, 6);
       
    92     mLayout->addItem(mAllButton, 5, 0, 1, 6);
       
    93     setLayout(mLayout);
       
    94     
       
    95     
       
    96     connect(mSaveOneButton, SIGNAL(released()), this, SLOT(preClear()));    
       
    97     connect(mSaveMoreButton, SIGNAL(released()), this, SLOT(preClear()));
       
    98     connect(mGetButton, SIGNAL(released()), this, SLOT(preClear()));
       
    99     connect(mAllButton, SIGNAL(released()), this, SLOT(preClear()));
       
   100         
       
   101     connect(mSaveOneButton, SIGNAL(released()), this, SLOT(saveOne()));    
       
   102     connect(mSaveMoreButton, SIGNAL(released()), this, SLOT(saveMore()));
       
   103     connect(mGetButton, SIGNAL(released()), this, SLOT(getOne()));
       
   104     connect(mAllButton, SIGNAL(released()), this, SLOT(all()));
       
   105     
       
   106     connect(mSaveOneButton, SIGNAL(released()), this, SLOT(startTimer()));    
       
   107     connect(mSaveMoreButton, SIGNAL(released()), this, SLOT(startTimer()));
       
   108     connect(mGetButton, SIGNAL(released()), this, SLOT(startTimer()));
       
   109     connect(mAllButton, SIGNAL(released()), this, SLOT(startTimer()));
       
   110     
       
   111     mTimer = new QTimer(this);
       
   112     connect(mTimer, SIGNAL(timeout()), this, SLOT(timeout()));
       
   113 
       
   114 }
       
   115 
       
   116 MeasureTest::~MeasureTest()
       
   117 {
       
   118     delete mFile;
       
   119     delete mStream;    
       
   120     delete mActivityManager;
       
   121     delete mActivityStorage;
       
   122     delete mActivation;
       
   123 }
       
   124 
       
   125 
       
   126 void MeasureTest::Before()
       
   127 {
       
   128     TTime time;
       
   129     time.HomeTime();
       
   130     iBefore = time.Int64();
       
   131 }
       
   132 
       
   133 void MeasureTest::After()
       
   134 {
       
   135     TTime time;
       
   136     time.HomeTime();
       
   137     iAfter = time.Int64();
       
   138 }
       
   139 
       
   140 void MeasureTest::Result()
       
   141 {
       
   142     TInt64 res(0);
       
   143     res = iAfter-iBefore;
       
   144     res = res/1000;
       
   145     iResult = res;
       
   146 }
       
   147 
       
   148 
       
   149 int MeasureTest::average(const QList<int>& list)
       
   150 {
       
   151     int count = list.count();
       
   152     int sum=0;
       
   153     for(int i=0; i<count; i++) {
       
   154         sum += list.at(i);
       
   155     }
       
   156     sum = (sum+0.5)/count;
       
   157     return sum;
       
   158 }
       
   159 
       
   160 int MeasureTest::writeResults(const QList<int>& list, int average)
       
   161 {
       
   162     for(int i=0; i<list.count(); i++){
       
   163         *mStream<<"|  ";
       
   164         *mStream<<list.at(i);
       
   165         *mStream<<"  |\n";
       
   166     }
       
   167     *mStream<<"|  ";
       
   168     *mStream<<average;
       
   169     *mStream<<"  |\n";
       
   170 }
       
   171 
       
   172 void MeasureTest::logError(const QString& mess)
       
   173 {
       
   174     *mStream<<"*Fail: "<<mess<<" *\n";
       
   175     mStream->flush();
       
   176 }
       
   177 
       
   178 bool MeasureTest::saveBytes(int bytes)
       
   179 {    
       
   180     delete mByteArray;
       
   181     mByteArray = NULL;
       
   182     mByteArray = new QByteArray(bytes, 'a');
       
   183     QVariant variant;
       
   184     variant = *mByteArray;
       
   185     
       
   186     HbMainWindow *mainWindow = hbInstance->allMainWindows().first();
       
   187     QPixmap screenshot = QPixmap::grabWidget(mainWindow, mainWindow->rect());
       
   188 
       
   189     
       
   190     QVariantHash metadata;
       
   191     metadata.insert(ActivityScreenshotKeyword, screenshot);
       
   192     
       
   193     
       
   194     bool ok = false;
       
   195     QString name("0");
       
   196 
       
   197     ok = mActivityStorage->saveActivity(name, variant, metadata);
       
   198     return ok;
       
   199 }
       
   200 
       
   201 bool MeasureTest::deleteActivities()
       
   202 {
       
   203     QStringList activities = mActivityStorage->allActivities();    
       
   204     QString name;    
       
   205     bool ok = true;
       
   206     for (int i=0; i<activities.count(); i++) {
       
   207         ok = mActivityStorage->removeActivity(activities.at(i));        
       
   208         if (!ok) {
       
   209             break;
       
   210         }
       
   211     }        
       
   212     return ok;
       
   213 }
       
   214 
       
   215 bool MeasureTest::saveOneInLoop(int action)
       
   216 {
       
   217     int bytes = KDefaultSaveBytes;
       
   218     delete mByteArray;
       
   219     mByteArray = NULL;
       
   220     mByteArray = new QByteArray(bytes, 'a');
       
   221     QVariant variant;
       
   222     variant = *mByteArray;
       
   223     
       
   224     HbMainWindow *mainWindow = hbInstance->allMainWindows().first();
       
   225     QPixmap screenshot = QPixmap::grabWidget(mainWindow, mainWindow->rect());
       
   226 
       
   227     
       
   228     QVariantHash metadata;
       
   229     metadata.insert(ActivityScreenshotKeyword, screenshot);
       
   230     
       
   231     int times = KDefaultTimes;    
       
   232     bool ok = false;    
       
   233     QString name("0");
       
   234     ok = deleteActivities();
       
   235     if(!ok) {
       
   236         logError("Remove");
       
   237         return false;
       
   238     }
       
   239     User::After(2000000); //2s
       
   240     
       
   241     for (int i=0; i<times; i++) {
       
   242         Before();
       
   243         ok = mActivityStorage->saveActivity(name, variant, metadata);
       
   244         After();
       
   245         Result();
       
   246         if (!ok) {
       
   247               break;
       
   248           }
       
   249         mResultsList[action].append(iResult);
       
   250         ok = deleteActivities();
       
   251         if(!ok) {
       
   252             logError("Remove");
       
   253             return false;
       
   254         }
       
   255         User::After(2000000); //2s
       
   256     }
       
   257     
       
   258     int averageint = average(mResultsList.at(action));
       
   259     mResultsList[action].append(averageint);
       
   260 
       
   261     if(!ok) {
       
   262         logError("SaveOne");        
       
   263     }
       
   264     
       
   265     return ok;
       
   266     
       
   267 }
       
   268 
       
   269 bool MeasureTest::saveMoreInLoop(int action)
       
   270 {
       
   271     int bytes = KDefaultSaveBytes;
       
   272     delete mByteArray;
       
   273     mByteArray = NULL;
       
   274     mByteArray = new QByteArray(bytes, 'a');
       
   275     QVariant variant;
       
   276     variant = *mByteArray;
       
   277     
       
   278     HbMainWindow *mainWindow = hbInstance->allMainWindows().first();
       
   279     QPixmap screenshot = QPixmap::grabWidget(mainWindow, mainWindow->rect());
       
   280 
       
   281     
       
   282     QVariantHash metadata;
       
   283     metadata.insert(ActivityScreenshotKeyword, screenshot);
       
   284     
       
   285     bool ok = deleteActivities();
       
   286     if(!ok) {
       
   287         logError("Remove");
       
   288         return false;
       
   289     }
       
   290     
       
   291     int times = KDefaultTimes;    
       
   292      
       
   293      
       
   294      ok = false;
       
   295      QString name;
       
   296      
       
   297      User::After(2000000); //2s
       
   298      for(int i=0; i<times; i++) {
       
   299          Before();
       
   300          for (int i=0; i<KDefaultLoop; i++) {
       
   301              
       
   302              name.setNum(i);
       
   303              ok = mActivityStorage->saveActivity(name, variant, metadata);
       
   304              if (!ok) {
       
   305                  break;
       
   306              }            
       
   307          }
       
   308          After();
       
   309          Result();
       
   310          mResultsList[action].append(iResult);
       
   311          
       
   312          QStringList activities = mActivityStorage->allActivities();      
       
   313      
       
   314          ok = deleteActivities();
       
   315          if(!ok) {
       
   316              logError("Remove");
       
   317              return false;
       
   318          }
       
   319          User::After(2000000); //2s        
       
   320 
       
   321      }       
       
   322      
       
   323      int averageint = average(mResultsList.at(action));
       
   324      averageint = (averageint+0.5)/KDefaultLoop;
       
   325      mResultsList[action].append(averageint);
       
   326 
       
   327      if(!ok) {
       
   328          logError("SaveMore");        
       
   329      }
       
   330      
       
   331      return ok;
       
   332 }
       
   333 
       
   334 bool MeasureTest::getOneInLoop(int bytes, int action)
       
   335 {
       
   336     int times = KDefaultTimes;
       
   337     bool ok = deleteActivities();
       
   338     if(!ok) {
       
   339         logError("Remove");
       
   340         return false;
       
   341     }
       
   342     ok = saveBytes(bytes);
       
   343     if(!ok) {
       
   344         logError("SaveBytes");
       
   345         return false;
       
   346     }
       
   347     
       
   348      QStringList activities = mActivityStorage->allActivities();
       
   349      
       
   350      
       
   351      User::After(2000000); //2s
       
   352      QString name;
       
   353      QVariant data;        
       
   354      
       
   355      for(int i=0; i<times; i++) {
       
   356          Before();
       
   357          for (int i=0; i<activities.count(); i++) {
       
   358              data = mActivityStorage->activityData(activities.at(i));
       
   359          }
       
   360          After();
       
   361          Result();
       
   362          mResultsList[action].append(iResult);
       
   363          User::After(2000000); //2s
       
   364      }
       
   365      
       
   366      int averageint = average(mResultsList.at(action));
       
   367      mResultsList[action].append(averageint);
       
   368 
       
   369      if(!ok) {
       
   370          logError("GetOne");        
       
   371      }
       
   372      
       
   373      return ok;
       
   374 }
       
   375 
       
   376 void MeasureTest::saveOne()
       
   377 {
       
   378     QList<int> l;
       
   379     for(int i=0; i<KDefaultRepeat; i++) {
       
   380         mActionsList.append("save1");        
       
   381         mResultsList.append(l);
       
   382     }
       
   383 }
       
   384 
       
   385 void MeasureTest::saveMore()
       
   386 {
       
   387     QList<int> l;
       
   388     for(int i=0; i<KDefaultRepeat; i++) {
       
   389         mActionsList.append("save10");        
       
   390         mResultsList.append(l);
       
   391     }
       
   392 }
       
   393 
       
   394 void MeasureTest::getOne()
       
   395 {
       
   396     QList<int> l;
       
   397     for(int i=0; i<KDefaultRepeat; i++) {
       
   398         mActionsList.append("get1"); 
       
   399         mResultsList.append(l);
       
   400     }
       
   401     for(int i=0; i<KDefaultRepeat; i++) {
       
   402         mActionsList.append("get2"); 
       
   403         mResultsList.append(l);
       
   404     }
       
   405     for(int i=0; i<KDefaultRepeat; i++) {
       
   406         mActionsList.append("get3"); 
       
   407         mResultsList.append(l);
       
   408     }
       
   409 }
       
   410 
       
   411 void MeasureTest::all()
       
   412 {
       
   413     saveOne();
       
   414     saveMore();
       
   415     getOne();
       
   416 }
       
   417 
       
   418 void MeasureTest::timeout()
       
   419 {
       
   420     if(mActionCounter == mActionsList.count()) {
       
   421         mTimer->stop();
       
   422         logResult();
       
   423         enableControls(true);
       
   424         return;
       
   425     }
       
   426     QString actionName = mActionsList.at(mActionCounter);
       
   427     bool ok = false;
       
   428     
       
   429     if(actionName == "save1") {
       
   430         ok = saveOneInLoop(mActionCounter);
       
   431     }
       
   432     else if(actionName == "save10") {
       
   433         ok = saveMoreInLoop(mActionCounter);
       
   434     }
       
   435     else if(actionName == "get1") {
       
   436         ok = getOneInLoop(KGet1Bytes, mActionCounter);
       
   437     }
       
   438     else if(actionName == "get2") {
       
   439         ok = getOneInLoop(KGet2Bytes, mActionCounter);
       
   440     }
       
   441     else if(actionName == "get3") {
       
   442         ok = getOneInLoop(KGet3Bytes, mActionCounter);
       
   443     }
       
   444     else {
       
   445         ok = false;
       
   446     }
       
   447     
       
   448     mItemMessage.clear();
       
   449     mResultMessage.clear();
       
   450 
       
   451     mItemMessage = (tr("action: %1")).arg(actionName);
       
   452     mResultMessage = (tr("count: %1")).arg(mActionCounter).arg(ok);
       
   453 
       
   454     mItemLabel->setPlainText(mItemMessage);
       
   455     mResultLabel->setPlainText(mResultMessage); 
       
   456     
       
   457     mActionCounter++;
       
   458 }
       
   459 
       
   460 void MeasureTest::preClear()
       
   461 {
       
   462     mResultsList.clear();
       
   463     mActionsList.clear();
       
   464     mActionCounter = 0;
       
   465     enableControls(false);
       
   466 }
       
   467 
       
   468 void MeasureTest::startTimer()
       
   469 {
       
   470     mTimer->start(1);
       
   471 }
       
   472 
       
   473 void MeasureTest::logResult()
       
   474 {
       
   475     QList<int> save1indexes;
       
   476     QList<int> save10indexes;
       
   477     QList<int> get1indexes;
       
   478     QList<int> get2indexes;
       
   479     QList<int> get3indexes;
       
   480     
       
   481     for(int i=0; i<mActionsList.count(); i++) {
       
   482         QString actionName = mActionsList.at(i);
       
   483         if(actionName == "save1") {
       
   484             save1indexes.append(i);
       
   485         }
       
   486         else if(actionName == "save10") {
       
   487             save10indexes.append(i);
       
   488         }
       
   489         else if(actionName == "get1") {
       
   490             get1indexes.append(i);
       
   491         }
       
   492         else if(actionName == "get2") {
       
   493             get2indexes.append(i);
       
   494         }
       
   495         else if(actionName == "get3") {
       
   496             get3indexes.append(i);
       
   497         }
       
   498     }
       
   499     logSaveSummary(save1indexes, save10indexes);
       
   500     logResult(save1indexes, 1, "Save one activity", "save");
       
   501     logResult(save10indexes, 2, "Save 10 activities in loop", "save");
       
   502     
       
   503     logGetSummary(get1indexes, get2indexes, get3indexes);
       
   504     logResult(get1indexes, 1, "Get activities with 10 KB of data", "get");
       
   505     logResult(get2indexes, 2, "Get activities with 100 KB of data", "get");
       
   506     logResult(get3indexes, 3, "Get activities with 1 MB of data", "get");
       
   507     
       
   508 }
       
   509 
       
   510 void MeasureTest::logResult(const QList<int>& indexes, int caseno, const QString& mess, const QString& type)
       
   511 {
       
   512     int indexno = indexes.count();
       
   513     if(indexno == 0) {
       
   514         return;
       
   515     }
       
   516     
       
   517     QString caseness = tr("---+++++ Case %1.\n\n").arg(caseno);
       
   518     *mStream<<caseness;
       
   519     
       
   520     *mStream<<mess<<"\n\n";
       
   521     
       
   522     *mStream<<"|    |";
       
   523     for(int i=0; i<indexno; i++) {
       
   524         QString mess = tr("  *Test %1 [ms]*  |").arg(i);
       
   525         *mStream<<mess;
       
   526     }
       
   527     *mStream<<"\n";
       
   528     QString tempmess;
       
   529     for(int i=0; i<KDefaultTimes+1; i++) {
       
   530         if(i == KDefaultTimes) {
       
   531             tempmess = tr("|  *Average per one %1*  |").arg(type);            
       
   532         }
       
   533         else {
       
   534             tempmess = tr("|  *Sample %1*  |").arg(i);    
       
   535         }
       
   536         *mStream<<tempmess;
       
   537         
       
   538         for(int j=0; j<indexno; j++) {            
       
   539             const QList<int>& reslist = mResultsList.at(indexes.at(j));
       
   540             if(reslist.count()>i) {
       
   541                 int res = reslist.at(i); 
       
   542                 *mStream<<"  "<<res<<"  |";
       
   543             }
       
   544             else {
       
   545                 *mStream<<"  -  |";
       
   546             }
       
   547         }
       
   548         *mStream<<"\n";
       
   549     }
       
   550     *mStream<<"\n\n";
       
   551     mStream->flush();    
       
   552 }
       
   553 
       
   554 QString MeasureTest::middle(const QList<int>& list)
       
   555 {    
       
   556     if(list.count()==0) {
       
   557         return "-";
       
   558     }
       
   559     QList<int> tlist = list;
       
   560     qSort(tlist);
       
   561     int count = tlist.count();
       
   562     QString res;
       
   563     res.setNum(tlist.at(count/2));
       
   564     return res;
       
   565 }
       
   566 
       
   567 void MeasureTest::logSaveSummary(const QList<int>& indexes1, const QList<int>& indexes10)
       
   568 {
       
   569     *mStream<<"---++++ Midle time of save activity - the faster and the slowest result has been rejected.\n\n";
       
   570     
       
   571     QList<int> save1averages;
       
   572     QList<int> save10averages;
       
   573     
       
   574     for(int i=0; i<indexes1.count(); i++) {
       
   575         const QList<int>& reslist = mResultsList.at(indexes1.at(i));
       
   576         if(reslist.count()==KDefaultTimes+1) {
       
   577             int d = reslist.at(KDefaultTimes);
       
   578             save1averages.append(reslist.at(KDefaultTimes));
       
   579         }
       
   580     }
       
   581     
       
   582     for(int i=0; i<indexes10.count(); i++) {
       
   583             const QList<int>& reslist = mResultsList.at(indexes10.at(i));
       
   584             if(reslist.count()==KDefaultTimes+1) {
       
   585                 save10averages.append(reslist.at(KDefaultTimes));
       
   586             }
       
   587         }
       
   588     QString save1middle = middle(save1averages);
       
   589     QString save10middle = middle(save10averages);
       
   590     
       
   591     *mStream<<"|  *Case no.*  |  *no. of saved activity in one measure*  |  *Midle time [ms]*  |\n";
       
   592     *mStream<<"|  1  |  1  |  "<<save1middle<<"  |\n";  
       
   593     *mStream<<"|  2  |  10  |  "<<save10middle<<"  |\n\n";
       
   594     mStream->flush();
       
   595 }
       
   596 
       
   597 void MeasureTest::logGetSummary(const QList<int>& get1, const QList<int>& get2 , const QList<int>& get3)
       
   598 {
       
   599     *mStream<<"---++++ Midle time of get activity - the faster and the slowest result has been rejected.\n\n";
       
   600     
       
   601     QList<int> get1averages;
       
   602     QList<int> get2averages;
       
   603     QList<int> get3averages;
       
   604     
       
   605     for(int i=0; i<get1.count(); i++) {
       
   606         const QList<int>& reslist = mResultsList.at(get1.at(i));
       
   607         if(reslist.count()==KDefaultTimes+1) {
       
   608             get1averages.append(reslist.at(KDefaultTimes));
       
   609         }
       
   610     }
       
   611     
       
   612     for(int i=0; i<get2.count(); i++) {
       
   613             const QList<int>& reslist = mResultsList.at(get2.at(i));
       
   614             if(reslist.count()==KDefaultTimes+1) {
       
   615                 get2averages.append(reslist.at(KDefaultTimes));
       
   616             }
       
   617         }
       
   618     
       
   619     for(int i=0; i<get3.count(); i++) {
       
   620             const QList<int>& reslist = mResultsList.at(get3.at(i));
       
   621             if(reslist.count()==KDefaultTimes+1) {
       
   622                 get3averages.append(reslist.at(KDefaultTimes));
       
   623             }
       
   624         }
       
   625     QString get1middle = middle(get1averages);
       
   626     QString get2middle = middle(get2averages);
       
   627     QString get3middle = middle(get3averages);
       
   628     
       
   629     *mStream<<"|  *Case no.*  |  *Data size [KB]*  |  *Midle time [ms]*  |\n";
       
   630     *mStream<<"|  1  |  10  |  "<<get1middle<<"  |\n";  
       
   631     *mStream<<"|  2  |  100  |  "<<get2middle<<"  |\n";
       
   632     *mStream<<"|  3  |  1024  |  "<<get3middle<<"  |\n\n";
       
   633     mStream->flush();
       
   634 }
       
   635 
       
   636 void MeasureTest::enableControls(bool enable)
       
   637 {
       
   638     mSaveOneButton->setEnabled(enable);
       
   639     mSaveMoreButton->setEnabled(enable);
       
   640     mGetButton->setEnabled(enable);
       
   641     mAllButton->setEnabled(enable);
       
   642 }