diff -r 000000000000 -r 876b1a06bc25 tests/benchmarks/messaging/tst_messaging.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/tests/benchmarks/messaging/tst_messaging.cpp	Wed Aug 25 15:49:42 2010 +0300
@@ -0,0 +1,2074 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the Qt Mobility Components.
+**
+** $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 Technology Preview License Agreement accompanying
+** this package.
+**
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#include <QApplication>
+#include <QtTest/QtTest>
+#include <QDebug>
+#include <QEventLoop>
+#include <QTimer>
+
+#include "qmessagemanager.h"
+#include "qmessage.h"
+
+#ifdef Q_OS_SYMBIAN
+#include <msvapi.h>
+#include <msvids.h>  // KMsvGlobalInBoxIndexEntryId
+#include <mtclreg.h>  // CClientMtmRegistry
+#include <smsclnt.h>  // CSmsClientMtm
+#include <smut.h>  // KUidMsgTypeSMS
+#include <txtrich.h>  // CRichText
+#include <cemailaccounts.h>
+#include <mmsconst.h>
+#include <miutmsg.h>
+#include <msvfind.h>  
+#include <impcmtm.h>
+#include <mmsclient.h>
+#include <etelmm.h>
+#include <msvapi.h>
+#include <iapprefs.h>
+#include <smtcmtm.h>
+#include <smuthdr.h>
+#endif
+
+#include <qdebug.h>
+
+QTM_USE_NAMESPACE
+
+class OsNative;
+
+#if defined(Q_OS_SYMBIAN)
+class OsNative : public MMsvSessionObserver {
+public:
+  OsNative()
+  {    
+  };
+
+  void HandleSessionEventL(TMsvSessionEvent aEvent, TAny* aArg1, TAny* aArg2, TAny* aArg3) { };
+  
+  void getFolders(RArray<TMsvId> &folders);
+  
+  int countMessages();
+  void deleteAllMessages();
+  void createMailAccountL();
+  void printAccounts();
+  void deleteAccounts();
+  void deleteAllFolders();
+  TInt createFolder(TPtrC name);
+  
+  TMsvId makeSMS(TMsvId folder);
+  TMsvId makeIMAP4(TMsvId folder);
+  
+  CMsvSession *iSession;
+  CClientMtmRegistry *iMtmRegistry;
+  CSmsClientMtm *iSmsMtm;
+  CImap4ClientMtm *iImap4Mtm;
+  CSmtpClientMtm *iSmtpMtm;
+  CMmsClientMtm *iMmsMtm;
+   
+  RArray<TMsvId> iFolders;
+  RArray<TMsvId> iNewMsgs;
+  TMsvId iMsvImapService;
+  TMsvId iMsvSmtpService;
+
+};
+
+TMsvId OsNative::makeSMS(TMsvId folder){    
+    TBuf<10> aAddress(_L("Nokia"));
+    TBuf<20> aDescription(_L("Important Message"));
+ 
+    _LIT(KTxt1,"Hi phone owner, how r u?");
+ 
+    TBuf<150> iMessage; 
+    iMessage.Copy(KTxt1);
+  
+    iSmsMtm->SwitchCurrentEntryL(folder); //inbox
+// Clean phones without a SIM doesn't have a default service
+//    TMsvId serviceId;
+//    TRAPD(err, serviceId = iSmsMtm->DefaultServiceL());
+//    if(err) {
+//      qDebug() << "No default service";
+//      return 0;
+//    }
+      
+    
+    TRAPD(err1, iSmsMtm->SwitchCurrentEntryL( folder ));
+    if(err1){
+        qDebug() << "Failed to create SMS1: " << err1;
+        return 0;
+    }
+
+    TRAPD(err, iSmsMtm->CreateMessageL( iSmsMtm->ServiceId() )); 
+    
+    //TRAPD(err, iSmsMtm->CreateMessageL(KMsvLocalServiceIndexEntryId));
+    if(err){
+        qDebug() << "Failed to create SMS: " << err;
+        return 0;
+    }
+    
+    CSmsHeader& iHeader = iSmsMtm->SmsHeader();
+    TRAP(err, iHeader.SetFromAddressL(aAddress));
+    if(err)
+      qDebug() << "Failed to set from address: " << err;    
+ 
+    CRichText& body = iSmsMtm->Body();
+    body.Reset();
+    TRAP(err, body.InsertL(0, iMessage));
+    if(err)
+      qDebug() << "Failed to add body: " << err;
+ 
+    TMsvEntry entry = iSmsMtm->Entry().Entry();
+    entry.SetInPreparation(EFalse);
+    entry.SetVisible(ETrue);
+    entry.iDate.HomeTime();
+    entry.iDescription.Set(aDescription);
+    entry.iDetails.Set(aAddress);
+    entry.SetUnread(ETrue);
+ 
+    TRAP(err,
+        iSmsMtm->Entry().ChangeL(entry);
+        iSmsMtm->SaveMessageL();
+        );
+    if(err)
+      qDebug() << "Failed to save changes: " << err;
+    
+   return entry.Id();
+}
+
+void OsNative::printAccounts(){
+  RArray<TPopAccount> aPop;
+  RArray<TImapAccount> aImap;
+  RArray<TSmtpAccount> aSmtp;
+  CEmailAccounts* account = CEmailAccounts::NewLC();
+  TRAPD(err, 
+      account->GetPopAccountsL(aPop);
+      account->GetImapAccountsL(aImap);
+      account->GetSmtpAccountsL(aSmtp);
+      );
+  if(err){
+    qDebug()<< "Can't get all accounts";
+  }
+  
+  for(int i = 0; i < aPop.Count(); i++){
+    QString name  = QString::fromUtf16(aPop[i].iPopAccountName.Ptr(), aPop[i].iPopAccountName.Length());
+    qDebug() << "Pop account: " << name << hex << " SMTP: " << aPop[i].iSmtpService;
+//    account->DeletePopAccountL(aPop[i]);
+  }
+  for(int i = 0; i < aImap.Count(); i++){
+    QString name  = QString::fromUtf16(aImap[i].iImapAccountName.Ptr(), aImap[i].iImapAccountName.Length());
+    qDebug() << "Imap account: " << name << hex << " SMTP: " << aImap[i].iSmtpService;
+//    account->DeleteImapAccountL(aImap[i]);
+  }
+  for(int i = 0; i < aSmtp.Count(); i++){
+    QString name  = QString::fromUtf16(aSmtp[i].iSmtpAccountName.Ptr(), aSmtp[i].iSmtpAccountName.Length());
+    qDebug() << "SMTP account: " << name << hex << " Related: " << aSmtp[i].iRelatedService;
+//    account->DeleteSmtpAccountL(aSmtp[i]);
+  }
+  aPop.Close();
+  aSmtp.Close();
+  aImap.Close();
+  CleanupStack::PopAndDestroy(account);
+}
+
+void OsNative::deleteAccounts(){
+  RArray<TPopAccount> aPop;
+  RArray<TImapAccount> aImap;
+  RArray<TSmtpAccount> aSmtp;
+  CEmailAccounts* account = CEmailAccounts::NewLC();
+  TRAPD(err, 
+      account->GetPopAccountsL(aPop);
+      account->GetImapAccountsL(aImap);
+      account->GetSmtpAccountsL(aSmtp);
+      );
+  if(err){
+    qDebug()<< "Can't get all accounts";
+  }
+  
+  for(int i = 0; i < aPop.Count(); i++){
+    QString name  = QString::fromUtf16(aPop[i].iPopAccountName.Ptr(), aPop[i].iPopAccountName.Size());
+    if(name.startsWith("BMTestAccount"))
+      account->DeletePopAccountL(aPop[i]);
+  }
+  for(int i = 0; i < aImap.Count(); i++){
+    QString name  = QString::fromUtf16(aImap[i].iImapAccountName.Ptr(), aImap[i].iImapAccountName.Size());
+    if(name.startsWith("BMTestAccount"))
+      account->DeleteImapAccountL(aImap[i]);
+
+  }
+  for(int i = 0; i < aSmtp.Count(); i++){
+    QString name  = QString::fromUtf16(aSmtp[i].iSmtpAccountName.Ptr(), aSmtp[i].iSmtpAccountName.Size());
+    if(name.startsWith("BMTestAccount"))
+      account->DeleteSmtpAccountL(aSmtp[i]);
+  }
+  aPop.Close();
+  aSmtp.Close();
+  aImap.Close();
+  CleanupStack::PopAndDestroy(account);
+}
+
+TMsvId OsNative::makeIMAP4(TMsvId folder){
+
+  // create a new object to access an existing entry
+  CMsvEntry* msvEntry = CMsvEntry::NewL(*iSession, KMsvGlobalInBoxIndexEntryId, TMsvSelectionOrdering());
+  CleanupStack::PushL(msvEntry); // 1
+              
+  msvEntry->SetEntryL(folder);
+  
+  // mtm takes ownership of entry context     
+  CleanupStack::Pop(msvEntry); // 0
+  iSmtpMtm->SetCurrentEntryL(msvEntry);
+  
+  // create a new message
+  TMsvId defaultServiceId(0);
+  defaultServiceId = iSmtpMtm->DefaultServiceL();
+  CMsvEntry *pE = iSession->GetEntryL(defaultServiceId);
+  CleanupStack::PushL(pE);  
+  QString name = QString::fromUtf16(pE->Entry().iDetails.Ptr(), pE->Entry().iDetails.Length());
+  CleanupStack::PopAndDestroy(pE);
+  iSmtpMtm->CreateMessageL(defaultServiceId);
+  
+  // set subject
+  iSmtpMtm->SetSubjectL( _L("Test Message") );
+  // set body
+  iSmtpMtm->Body().Reset();
+  iSmtpMtm->Body().InsertL(0, _L("This is the text body")); 
+
+  // get the entry of the message
+  TMsvEntry messageEntry = iSmtpMtm->Entry().Entry();
+//      AddSenderToMtmAddresseeL(*iSmtpMtm, parameters, ETrue );
+//      SetSenderToEntryDetails(messageEntry, parameters, ETrue);
+  messageEntry.iMtm = KUidMsgTypeIMAP4;  // or any other than KUidMsgTypeSMTP to display 'from' field instead of 'to' field 
+
+  // set the description field same as the message subject
+  messageEntry.iDescription.Set( _L("test") );  
+  messageEntry.iDetails.Set( _L("test subject") );
+
+  // save the changes done above
+  iSmtpMtm->Entry().ChangeL(messageEntry);
+  // get an access to the message store
+  CMsvStore* store = msvEntry->EditStoreL();
+  CleanupStack::PushL(store); // 1
+  
+  // save the attachments
+
+  // save the changes made to the message store
+  store->CommitL();
+  CleanupStack::PopAndDestroy(store); // 0 
+  // save the message      
+  iSmtpMtm->SaveMessageL();
+  // final fine tuning
+  TMsvEmailEntry temailEntry = static_cast<TMsvEmailEntry>(messageEntry);
+  temailEntry.SetMessageFolderType(EFolderTypeUnknown);
+  temailEntry.SetDisconnectedOperation(ENoDisconnectedOperations);
+  temailEntry.SetEncrypted(EFalse);
+  temailEntry.SetSigned(EFalse);
+  temailEntry.SetVCard(EFalse);
+  temailEntry.SetVCalendar(EFalse);
+  temailEntry.SetReceipt(EFalse);
+  temailEntry.SetMHTMLEmail(EFalse);
+  temailEntry.SetBodyTextComplete(ETrue);
+  
+  temailEntry.SetAttachment(EFalse);
+      
+  temailEntry.iDate.HomeTime();
+  temailEntry.SetVisible(ETrue);
+  temailEntry.SetInPreparation(EFalse);
+  temailEntry.SetUnread(ETrue);
+  temailEntry.SetNew(ETrue);
+
+  temailEntry.SetComplete(ETrue);
+  temailEntry.iServiceId = iMsvSmtpService;
+  temailEntry.iRelatedId = 0;
+  
+  iSmtpMtm->Entry().ChangeL(temailEntry);
+
+  // reset email headers
+  CImHeader* header = CImHeader::NewLC(); // 1
+  CMsvStore* msvStore = msvEntry->EditStoreL();
+  CleanupStack::PushL(msvStore); // 2
+  header->RestoreL(*msvStore);
+  header->SetSubjectL( _L("test email") );
+  header->SetFromL( _L("blah@blah.com") );
+  header->SetReceiptAddressL( _L("Foo@bar.com") );
+  header->StoreL( *msvStore );
+  msvStore->CommitL();
+  CleanupStack::PopAndDestroy(2); // msvStore, header // 0
+  
+  // id has been generated, store it for being able to delete
+  // only entries created with Creator
+  TMsvId id = messageEntry.Id();
+  return id;
+}
+
+
+void OsNative::deleteAllFolders() {
+
+    RArray<TMsvId> aFolders;
+    
+    TRAP_IGNORE(getFolders(aFolders));   
+    
+    TMsvSelectionOrdering sort;
+    sort.SetSorting(EMsvSortByNone);
+    sort.SetShowInvisibleEntries(ETrue);
+
+    for(int i = 0; i < aFolders.Count(); i++) {
+        CMsvEntry* inboxContext = CMsvEntry::NewL(*iSession, aFolders[i], sort);                
+        CleanupStack::PushL(inboxContext);
+    
+        // Get all entries in the folder
+        CMsvEntrySelection* entries = inboxContext->ChildrenL();
+        CleanupStack::PushL(entries);
+        QString desc = QString::fromUtf16(inboxContext->Entry().iDetails.Ptr(), inboxContext->Entry().iDetails.Length());
+        
+        for (TInt j = 0; j < entries->Count(); j++) {
+            CMsvEntry* pEntry = CMsvEntry::NewL(*iSession, entries->At(j), sort);
+            CleanupStack::PushL(pEntry);
+            QString desc2 = QString::fromUtf16(pEntry->Entry().iDetails.Ptr(), pEntry->Entry().iDetails.Length());
+
+            const TMsvEntry &entry = pEntry->Entry();            
+            if((desc != "My folders" || desc2 == "Templates")) {
+              CleanupStack::PopAndDestroy(pEntry);
+              continue;
+            }
+                        
+            CleanupStack::PopAndDestroy(pEntry);
+            
+            TMsvId id = entries->At(j);
+            qDebug() << "Deleting: " << desc << "/" << desc2;
+            TRAPD(ierr, iSession->RemoveEntry(id)); // works
+            if(ierr){
+                qDebug() << "Failed to delete: " << ierr << " " << hex << entries->At(j);
+            }            
+        }        
+        CleanupStack::PopAndDestroy(2, inboxContext);
+    }
+}
+
+void OsNative::createMailAccountL() {
+  CImIAPPreferences* outgoingIAPSet = CImIAPPreferences::NewLC(); // 1
+  CImIAPPreferences* incomingIAPSet = CImIAPPreferences::NewLC(); // 2
+  CEmailAccounts* account = CEmailAccounts::NewLC(); // 3
+
+  CImImap4Settings* imap4Set = new(ELeave) CImImap4Settings;
+  CleanupStack::PushL(imap4Set); // 4
+  CImSmtpSettings* smtpSet = new(ELeave) CImSmtpSettings;
+  CleanupStack::PushL(smtpSet); // 5
+
+  account->PopulateDefaultSmtpSettingsL(*smtpSet, *outgoingIAPSet);
+  account->PopulateDefaultImapSettingsL(*imap4Set, *outgoingIAPSet);
+  
+ imap4Set->SetDisconnectedUserMode(ETrue);
+ imap4Set->SetSynchronise(EUseLocal);
+ imap4Set->SetSubscribe(EUpdateNeither);
+ imap4Set->SetAutoSendOnConnect(EFalse);
+ imap4Set->SetGetMailOptions(EGetImap4EmailBodyText);
+ imap4Set->SetUpdatingSeenFlags(ETrue);
+ imap4Set->SetServerAddressL(_L("test.sdfsdf.wer.sadazsdsddf.com"));
+
+ TImapAccount imapAccountId = account->CreateImapAccountL(_L("BMTestAccount"), *imap4Set, *incomingIAPSet, EFalse);
+ TSmtpAccount smtpAccountId = account->CreateSmtpAccountL(imapAccountId, *smtpSet, *outgoingIAPSet, EFalse);
+ account->SetDefaultSmtpAccountL(smtpAccountId);
+
+ iMsvImapService = imapAccountId.iImapService;
+ iMsvSmtpService = smtpAccountId.iSmtpAccountId;
+ 
+ // Fails with NotSupported 
+ //iImap4Mtm->ChangeDefaultServiceL(iMsvImapService);
+ // Failed with invalid arg
+ // iSmtpMtm->ChangeDefaultServiceL(iMsvSmtpService);
+ CleanupStack::PopAndDestroy(5);
+ 
+}
+
+int OsNative::countMessages() {
+
+    RArray<TMsvId> aFolders;
+    int total = 0;
+
+    TRAPD(err, getFolders(aFolders));
+    if(err){
+        qDebug() << "getFodlers faield: " << err;
+        return 0;
+    }
+
+    for(int i = 0; i < aFolders.Count(); i++){
+        TMsvSelectionOrdering sort;
+        sort.SetSorting(EMsvSortByNone);
+        sort.SetShowInvisibleEntries(ETrue);
+        CMsvEntry* inboxContext = CMsvEntry::NewL(*iSession, 
+                aFolders[i], sort);                
+        CleanupStack::PushL(inboxContext); // 1
+    
+        // Get all entries in the Inbox
+        CMsvEntrySelection* entries = inboxContext->ChildrenL();
+        CleanupStack::PushL(entries); // 2
+        for (TInt i = 0; i < entries->Count(); i++) {              
+    
+            TMsvId entryID = entries->At(i);
+        
+            const TUid mtm = inboxContext->ChildDataL(entryID).iMtm;
+            if (mtm == KUidMsgTypeSMS) {
+                total++;
+            }
+            else if ((mtm == KUidMsgTypeIMAP4) || (mtm == KUidMsgTypeSMTP)) {
+                total++;                
+            }
+            else {
+            }           
+        }
+        CleanupStack::PopAndDestroy(2, inboxContext);
+    }
+    return total;
+}
+
+void OsNative::deleteAllMessages() {
+
+    RArray<TMsvId> aFolders;    
+
+    TRAPD(err, getFolders(aFolders));
+    if(err){
+        qDebug() << "getFodlers faield: " << err;
+        return;
+    }
+
+    for(int i = 0; i < aFolders.Count(); i++){
+        TMsvSelectionOrdering sort;
+        CMsvEntry* inboxContext = CMsvEntry::NewL(*iSession, aFolders[i], sort);                
+        CleanupStack::PushL(inboxContext); // 1
+    
+        // Get all entries in the Inbox
+        CMsvEntrySelection* entries = inboxContext->ChildrenL();
+        CleanupStack::PushL(entries); // 2
+        for (TInt i = 0; i < entries->Count(); i++) {              
+    
+            TMsvId entryID = entries->At(i);        
+            const TUid mtm = inboxContext->ChildDataL(entryID).iMtm;
+            
+            if ((mtm == KUidMsgTypeSMS) || (mtm == KUidMsgTypeIMAP4) || (mtm == KUidMsgTypeSMTP)) {
+                iSession->RemoveEntry(entryID);                
+            }
+        }
+        CleanupStack::PopAndDestroy(2, inboxContext);
+    }
+}
+
+
+#define KMsvMyFoldersEntryIdValue 0x1008
+const TMsvId KMsvMyFoldersEntryId=KMsvMyFoldersEntryIdValue;
+
+TInt OsNative::createFolder(TPtrC name){
+    TMsvId msvServId;                                                                       
+    CMsvEntry *entry1 = NULL;                                                                
+    CMsvEntry * rootEntry = NULL;                                                           
+    CMsvEntry *entryRootService = NULL;                                                     
+     
+    TInt newFldrID = 0;                                                                     
+     
+    //Get the entry (whatever is passed in)                                                    
+    entry1 = iSession->GetEntryL(KMsvMyFoldersEntryIdValue);   
+    CleanupStack::PushL(entry1);                                                             
+     
+    if (entry1)                                                                              
+    {                          
+        msvServId = entry1->OwningService();                                                    
+     
+        entryRootService = iSession->GetEntryL(msvServId);                            
+        CleanupStack::PushL(entryRootService);                                                 
+     
+        rootEntry = iSession->GetEntryL(msvServId);                                   
+        CleanupStack::PushL(rootEntry);                                                        
+     
+        rootEntry->SetEntryL(KMsvMyFoldersEntryIdValue); // set to parent
+     
+        TMsvEntry newServiceEntry;                                                             
+
+        newServiceEntry.iDate.HomeTime();
+        newServiceEntry.iSize = 0;
+        newServiceEntry.iType = KUidMsvFolderEntry;                                            
+        newServiceEntry.iMtm = KUidMsvLocalServiceMtm;
+//        newServiceEntry.iServiceId = iSmsMtm->ServiceId();
+//        newServiceEntry.iServiceId = KMsvLocalServiceIndexEntryId;
+        newServiceEntry.iServiceId = iMsvImapService;
+        newServiceEntry.iDetails.Set(name);                                             
+        newServiceEntry.iDescription.Set(KNullDesC);
+        newServiceEntry.SetVisible(ETrue);        
+
+        TRAPD(err, rootEntry->CreateL(newServiceEntry));
+        if(err){
+            QString n = QString::fromUtf16(name.Ptr(), name.Size());
+            qDebug() << "Failed to create folder "<< n << ": " << err;
+            User::Panic(_L("Fail"), err);            
+        }
+//        qDebug() << "iError: " << newServiceEntry.iError << " complete: " << newServiceEntry.Complete() << " prot: " << newServiceEntry.DeleteProtected();
+//        newFldrID = newServiceEntry.Id();                                                      
+        CleanupStack::PopAndDestroy();                                                         
+        CleanupStack::PopAndDestroy();                                                         
+    }
+    CleanupStack::PopAndDestroy(entry1);
+    
+    return newFldrID;
+}
+
+
+#else
+    class OsNative {
+      
+    };
+#endif
+    
+
+
+    
+//Q_DECLARE_METATYPE(QSystemInfo::Feature);
+
+class tst_messaging : public QObject
+{
+    Q_OBJECT
+
+public:
+    enum platform {
+        QMessaging = 0,
+        Native = 1
+    };
+    
+    enum bases {
+      Accounts = 0,
+      AccountsImap,
+      AccountsPop,
+      AccountsSmtp,
+      Folders,
+      FoldersEmail,
+      FoldersSMS,
+      FoldersMMS,
+      Messages,
+      MessagesAlt,
+      
+    };
+
+    enum filter {
+      Id = 0,
+      Type,
+      Sender,
+      Recipients,
+      Subject,
+      TimeStamp,
+      Status,
+      Priority,
+      Size,
+      AllId,
+      AllSender
+    };
+    
+    enum types {
+      Sms = 0,
+      Mms,
+      Email          
+    };
+
+    
+private slots:
+    void initTestCase();
+    void cleanupTestCase();
+                
+    void tst_createTime_data();
+    void tst_createTime();
+
+    void tst_counts_data();
+    void tst_counts();
+
+    void tst_query_data();
+    void tst_query();
+
+    void tst_fetch_data();
+    void tst_fetch();
+
+    void tst_fetchAll_data();
+    void tst_fetchAll();
+
+    void tst_fetchFilter_data();
+    void tst_fetchFilter();
+
+    void tst_addMessage_data();
+    void tst_addMessage();
+
+    void tst_removeMessage_data();
+    void tst_removeMessage();
+    
+    void tst_removeAllMessage_data();
+    void tst_removeAllMessage();
+    
+private:
+    QMessage *createMessage();
+    QMessage *messageTemplate();
+    QMessageId addMessage(QMessage *);     
+
+    void clearMessages();
+    int countMessages();
+
+    QMessageManager *m_mgr;
+    
+    QMessageIdList msg_list;
+    
+    QMessageAccount m_act;
+    //QMessageFolder m_fol;
+    
+
+    OsNative *m_native;
+};
+
+Q_DECLARE_METATYPE(tst_messaging::platform);
+Q_DECLARE_METATYPE(tst_messaging::bases);
+Q_DECLARE_METATYPE(tst_messaging::filter);
+Q_DECLARE_METATYPE(tst_messaging::types);
+
+void tst_messaging::initTestCase()
+{
+
+#if defined(Q_WS_MAEMO_6)
+    QFAIL("Maemo 6 not supported by tst_messaging");
+#elif defined(Q_WS_MAEMO_5)
+    QFAIL("Maemo 5 does not support tst_messageing");
+#elif defined(Q_OS_SYMBIAN)
+    
+#else
+    QFAIL("Platform not supported");
+#endif
+
+
+//    QMessageFolderIdList flist = m_mgr->queryFolders();
+//    while(!flist.empty()) {      
+//      QMessageFolder fol = m_mgr->folder(flist.takeFirst());
+//      qDebug() << "Folder: " << fol.name();
+//#if defined(Q_OS_SYMBIAN)      
+//      if(fol.name() == "Inbox"){
+//        m_fol = fol;
+//        break;
+//      }     
+//#endif      
+//    }
+    
+#if defined(Q_OS_SYMBIAN)
+    // define/init native features we need native
+    m_native = new OsNative;
+    m_native->iSession = CMsvSession::OpenSyncL(*m_native);
+    m_native->iMtmRegistry = CClientMtmRegistry::NewL(*m_native->iSession);
+    m_native->iSmsMtm = STATIC_CAST(CSmsClientMtm*, m_native->iMtmRegistry->NewMtmL(KUidMsgTypeSMS));
+    m_native->iImap4Mtm = STATIC_CAST(CImap4ClientMtm*, m_native->iMtmRegistry->NewMtmL(KUidMsgTypeIMAP4));
+    m_native->iMmsMtm = STATIC_CAST(CMmsClientMtm*, m_native->iMtmRegistry->NewMtmL(KUidMsgTypeMultimedia));
+    m_native->iSmtpMtm = STATIC_CAST(CSmtpClientMtm*,(m_native->iMtmRegistry->NewMtmL(KUidMsgTypeSMTP)));  
+
+    qDebug() << "Print accounts";
+    m_native->printAccounts();
+    qDebug() << "Delete accounts";
+    m_native->deleteAccounts();
+    qDebug() << "Delete all folders and messages";
+    m_native->deleteAllFolders();
+    m_native->deleteAllMessages();
+    qDebug() << "Create accounts";
+    TRAPD(err, m_native->createMailAccountL());
+    if(err)
+      qDebug() << "Account create failed: " << err;
+    qDebug() << "Oustanding ops: " << m_native->iSession->OutstandingOperationsL();
+    m_native->printAccounts();
+    qDebug() << "Create 3 folders";
+    m_native->createFolder(_L("Test1"));    
+    m_native->createFolder(_L("Test2"));
+    m_native->createFolder(_L("Test3"));
+    
+// Created messages with QMF, our symbian messages aren't very good    
+//    qDebug() << "Create 15 emails";
+//    for(int count = 0; count < 15; count++){
+//      TRAP(err, TMsvId id = m_native->makeIMAP4(KMsvGlobalInBoxIndexEntryId);
+//      m_native->iNewMsgs.Append(id));
+//      if(err){
+//        qDebug() << "Error: " << err;
+//      }
+//    }
+    
+   
+// Can't create SMS messages on a phone with no msg center
+//    qDebug() << "Create 15 SMS: " << m_native->iNewMsgs.Count();
+//    TRAPD(err, 
+//    for(int count = 0; count < 15; count++){
+//        TMsvId id = m_native->makeSMS(KMsvDraftEntryId); 
+//        m_native->iNewMsgs.Append(id);
+//    }
+//    );    
+    qDebug() << "Initial state is set: " << m_native->iNewMsgs.Count();
+    RArray<TMsvId> folders;
+    m_native->getFolders(folders);
+    qDebug() << "Number of folders: " << folders.Count();
+    folders.Close();    
+    qDebug() << "Number of messages: " << m_native->countMessages();    
+#else
+// this doesn't really create testable messages on symbian
+    for(int i = 0; i < 30; i++)
+      createMessage();
+#endif
+
+    m_mgr = new QMessageManager();
+    
+    QMessageAccountIdList list;
+    list = m_mgr->queryAccounts();
+    while(!list.empty()) {      
+      QMessageAccount act = m_mgr->account(list.takeFirst());
+      qDebug() << "Account: " << act.name();
+#if defined(Q_OS_SYMBIAN)           
+      if(act.name() == "BMTestAccount"){
+        qDebug() << "Using this account";
+        m_act = act;        
+        break;
+      }     
+#endif      
+    }
+
+    
+    for(int i = 0; i < 30; i++)
+      createMessage();
+}
+
+void tst_messaging::cleanupTestCase()
+{
+  
+  clearMessages();
+  
+#if defined(Q_OS_SYMBIAN)
+  qDebug() << "Delete: Oustanding ops: " << m_native->iSession->OutstandingOperationsL() << " outstanding messages: " << m_native->countMessages();
+  m_native->deleteAccounts();
+  m_native->deleteAllFolders();
+  m_native->deleteAllMessages();
+  m_native->iSession->RemoveEntry(m_native->iMsvImapService);
+  m_native->iSession->RemoveEntry(m_native->iMsvSmtpService);
+  delete m_native->iMmsMtm;
+  delete m_native->iImap4Mtm;
+  delete m_native->iSmsMtm;
+  delete m_native->iMtmRegistry;
+  delete m_native->iSession;
+  delete m_native;
+#endif
+    
+  delete m_mgr;
+
+
+}
+
+
+void tst_messaging::tst_createTime_data()
+{
+    QTest::addColumn<tst_messaging::platform>("platform");
+
+    QTest::newRow("Qt-Create") << tst_messaging::QMessaging;
+    QTest::newRow("Native-Create") << tst_messaging::Native;
+}
+
+
+void tst_messaging::tst_createTime()
+{
+    QFETCH(tst_messaging::platform, platform);
+    
+    //qDebug() << "Platform: " << platform;
+    
+    if(platform == tst_messaging::QMessaging){
+      QMessageManager *mgr = 0x0;
+      
+      QBENCHMARK {
+        mgr = new QMessageManager();        
+      }
+      
+      delete mgr;
+        
+    }
+    else if(platform == tst_messaging::Native){
+#ifdef Q_OS_SYMBIAN
+      
+      __UHEAP_MARK;
+      
+      if(m_native){
+        delete m_native->iSmtpMtm;
+        delete m_native->iMmsMtm;
+        delete m_native->iImap4Mtm;
+        delete m_native->iSmsMtm;
+        delete m_native->iMtmRegistry;
+        delete m_native->iSession;
+        delete m_native;
+      }
+
+      QBENCHMARK {
+        // define/init native features we need native
+        m_native = new OsNative;
+        m_native->iSession = CMsvSession::OpenSyncL(*m_native);
+        m_native->iMtmRegistry = CClientMtmRegistry::NewL(*m_native->iSession);
+        m_native->iSmsMtm = STATIC_CAST(CSmsClientMtm*, m_native->iMtmRegistry->NewMtmL(KUidMsgTypeSMS));
+        m_native->iImap4Mtm = STATIC_CAST(CImap4ClientMtm*, m_native->iMtmRegistry->NewMtmL(KUidMsgTypeIMAP4));
+        m_native->iMmsMtm = STATIC_CAST(CMmsClientMtm*, m_native->iMtmRegistry->NewMtmL(KUidMsgTypeMultimedia));
+        m_native->iSmtpMtm = STATIC_CAST(CSmtpClientMtm*, m_native->iMtmRegistry->NewMtmL(KUidMsgTypeSMTP));
+      }
+      
+      __UHEAP_MARKEND;
+#endif
+    }
+
+}
+
+void tst_messaging::tst_counts_data()
+{
+    QTest::addColumn<tst_messaging::platform>("platform");
+    QTest::addColumn<tst_messaging::bases>("base");
+
+    QTest::newRow("Qt-Accounts") << tst_messaging::QMessaging << tst_messaging::Accounts;
+//    QTest::newRow("Native-Accounts") << tst_messaging::Native << tst_messaging::Accounts;
+    QTest::newRow("Qt-Folders") << tst_messaging::QMessaging << tst_messaging::Folders;
+    QTest::newRow("Native-Folders") << tst_messaging::Native << tst_messaging::Folders;
+    QTest::newRow("Qt-Messages") << tst_messaging::QMessaging << tst_messaging::Messages;
+    QTest::newRow("Qt-MessagesAlt") << tst_messaging::QMessaging << tst_messaging::MessagesAlt;
+    QTest::newRow("Native-Messages") << tst_messaging::Native << tst_messaging::Messages;
+
+}
+
+void tst_messaging::tst_counts()
+{
+    QFETCH(tst_messaging::platform, platform);
+    QFETCH(tst_messaging::bases, base);
+    
+    if(platform == tst_messaging::QMessaging){
+      int cnt;
+      Q_UNUSED(cnt);
+      if(base == tst_messaging::Accounts){
+        QBENCHMARK {
+          cnt = m_mgr->countAccounts();
+        }
+      }
+      else if(base == tst_messaging::Folders){
+        QBENCHMARK {
+          cnt = m_mgr->countFolders();
+        }
+      }
+      else if(base == tst_messaging::Messages){
+        QBENCHMARK {
+          cnt = m_mgr->countMessages();
+        }        
+      }
+      else if(base == tst_messaging::MessagesAlt){
+        QMessageIdList list;
+        QBENCHMARK {
+          list = m_mgr->queryMessages();
+          cnt = list.count();
+        }        
+      }
+      //qDebug() << "Got cnt: " << cnt;      
+    }
+    else if(platform == tst_messaging::Native){
+#ifdef Q_OS_SYMBIAN
+      QBENCHMARK {
+        // Access the Inbox
+        TMsvSelectionOrdering sort;
+        CMsvEntry* inboxContext = CMsvEntry::NewL(*m_native->iSession, KMsvGlobalInBoxIndexEntryId, sort);
+        CleanupStack::PushL(inboxContext);
+
+        // Get all entries in the Inbox
+        CMsvEntrySelection* entries = inboxContext->ChildrenL();
+        CleanupStack::PushL(entries);
+
+
+        TInt messages = entries->Count();
+
+        CleanupStack::PopAndDestroy(2, inboxContext);
+      }           
+#endif
+    }
+
+}
+
+void tst_messaging::tst_query_data()
+{
+    QTest::addColumn<tst_messaging::platform>("platform");
+    QTest::addColumn<tst_messaging::bases>("base");
+
+    QTest::newRow("Qt-Accounts") << tst_messaging::QMessaging << tst_messaging::Accounts;    
+//    QTest::newRow("Qt-Folders") << tst_messaging::QMessaging << tst_messaging::Folders;    
+    QTest::newRow("Qt-Messages") << tst_messaging::QMessaging << tst_messaging::Messages;
+    
+    QTest::newRow("Native-Accounts") << tst_messaging::Native << tst_messaging::Accounts;
+    QTest::newRow("Native-Accounts-Imap") << tst_messaging::Native << tst_messaging::AccountsImap;
+    QTest::newRow("Native-Accounts-Pop") << tst_messaging::Native << tst_messaging::AccountsPop;
+    QTest::newRow("Native-Accounts-Smtp") << tst_messaging::Native << tst_messaging::AccountsSmtp;
+    QTest::newRow("Native-Folders") << tst_messaging::Native << tst_messaging::Folders;
+//    QTest::newRow("Native-Folders") << tst_messaging::Native << tst_messaging::FoldersEmail;
+//    QTest::newRow("Native-Folders") << tst_messaging::Native << tst_messaging::FoldersSMS;
+//    QTest::newRow("Native-Folders") << tst_messaging::Native << tst_messaging::FoldersMMS;
+    QTest::newRow("Native-Messages") << tst_messaging::Native << tst_messaging::Messages;
+
+}
+
+void tst_messaging::tst_query()
+{
+    QFETCH(tst_messaging::platform, platform);
+    QFETCH(tst_messaging::bases, base);
+    
+    if(platform == tst_messaging::QMessaging){
+//      int cnt;
+      if(base == tst_messaging::Accounts){
+        QMessageAccountIdList list;
+        QBENCHMARK {
+          list = m_mgr->queryAccounts();
+        }
+      }
+      else if(base == tst_messaging::Folders){
+        QMessageFolderIdList list;
+        QBENCHMARK {
+          list = m_mgr->queryFolders();
+        }
+//        XXX The library returns inbox/drafts/sent for all default accounts and greatly exagerates the number of folders
+//        qDebug() << "Number of folders: " << list.count();
+//        while(!list.empty()){
+//          QMessageFolder f(list.takeFirst());
+//          qDebug() << "Folder: " << f.name(); 
+//        }
+      }
+      else if(base == tst_messaging::Messages){
+        QMessageIdList list;
+        QBENCHMARK {
+          list = m_mgr->queryMessages();
+        }        
+      }
+      //qDebug() << "Got cnt: " << cnt;      
+    }
+    else if(platform == tst_messaging::Native){
+#ifdef Q_OS_SYMBIAN
+      if(base == tst_messaging::Accounts){
+        CEmailAccounts *email = CEmailAccounts::NewLC();
+        RArray<TPopAccount> aPop;
+        RArray<TImapAccount> aImap;
+        RArray<TSmtpAccount> aSmtp;
+        
+        QBENCHMARK {
+          email->GetPopAccountsL(aPop);
+          email->GetImapAccountsL(aImap);
+          email->GetSmtpAccountsL(aSmtp);
+        }
+        CleanupStack::PopAndDestroy(email);        
+      }
+      else if(base == tst_messaging::AccountsImap) {
+        CEmailAccounts *email = CEmailAccounts::NewLC();
+        RArray<TImapAccount> aImap;        
+        
+        QBENCHMARK {          
+          email->GetImapAccountsL(aImap);          
+        }
+        CleanupStack::PopAndDestroy(email);        
+        
+      }
+      else if(base == tst_messaging::AccountsPop) {
+        CEmailAccounts *email = CEmailAccounts::NewLC();
+        RArray<TPopAccount> aPop;
+        
+        QBENCHMARK {
+          email->GetPopAccountsL(aPop);
+        }
+        CleanupStack::PopAndDestroy(email);        
+        
+      }
+      else if(base == tst_messaging::AccountsSmtp) {
+        CEmailAccounts *email = CEmailAccounts::NewLC();
+        RArray<TSmtpAccount> aSmtp;
+        
+        QBENCHMARK {
+          email->GetSmtpAccountsL(aSmtp);
+        }
+        CleanupStack::PopAndDestroy(email);        
+        
+      }
+      else if(base == tst_messaging::Folders){
+          RArray<TMsvId> aFolders;
+          QBENCHMARK {
+              m_native->getFolders(aFolders);
+              aFolders.Close();              
+          }
+      }
+      else if(base == tst_messaging::Messages) {
+        
+        RArray<TMsvId> aFolders;
+        
+//        aFolders.Append(KMsvGlobalInBoxIndexEntryId);
+//        aFolders.Append(KMsvGlobalOutBoxIndexEntryId);
+//        aFolders.Append(KMsvDraftEntryId);
+//        aFolders.Append(KMsvSentEntryId);
+//        for(int i = 0; i < m_native->iFolders.Count(); i++)
+//          aFolders.Append(m_native->iFolders[i]);
+        m_native->getFolders(aFolders);
+
+        // Access the Inbox
+        QBENCHMARK {
+
+          for(int i = 0; i < aFolders.Count(); i++){
+            TMsvSelectionOrdering sort;
+            CMsvEntry* inboxContext = CMsvEntry::NewL(*m_native->iSession, aFolders[i], sort);
+            CleanupStack::PushL(inboxContext);
+
+            // Get all entries in the Inbox
+            CMsvEntrySelection* entries = inboxContext->ChildrenL();
+            CleanupStack::PushL(entries);
+
+            TInt messages = entries->Count();
+            for (TInt i = 0; i < messages; i++) {
+              TMsvId entryID = entries->At(i);
+              m_native->iSmsMtm->SwitchCurrentEntryL(entryID);
+
+              CMsvEntry* entry;
+
+              entry = m_native->iSession->GetEntryL((*entries)[i]);
+
+              delete entry;
+
+            }
+
+            CleanupStack::PopAndDestroy(2, inboxContext);
+          }
+        }
+      }
+#endif
+    }
+
+}
+
+void tst_messaging::tst_fetch_data()
+{
+  //qDebug() << "Start fetch_data";
+    QTest::addColumn<tst_messaging::platform>("platform");
+    QTest::addColumn<tst_messaging::bases>("base");
+
+    QTest::newRow("Qt-Accounts") << tst_messaging::QMessaging << tst_messaging::Accounts;
+    QTest::newRow("Native-Accounts") << tst_messaging::Native << tst_messaging::Accounts;
+    QTest::newRow("Qt-Folders") << tst_messaging::QMessaging << tst_messaging::Folders;
+    QTest::newRow("Native-Folders") << tst_messaging::Native << tst_messaging::Folders;
+    QTest::newRow("Qt-Messages") << tst_messaging::QMessaging << tst_messaging::Messages;
+    QTest::newRow("Native-Messages") << tst_messaging::Native << tst_messaging::Messages;
+}
+
+void tst_messaging::tst_fetch()
+{
+  
+    QFETCH(tst_messaging::platform, platform);
+    QFETCH(tst_messaging::bases, base);
+    
+    //qDebug() << "Start fetch" << platform << " base: " << base;  
+    if(platform == tst_messaging::QMessaging){
+      int cnt;
+      Q_UNUSED(cnt);
+      if(base == tst_messaging::Accounts){
+        QMessageAccountIdList list;
+        QMessageAccount acc;
+        list = m_mgr->queryAccounts();
+
+        if(!list.empty()){
+          QBENCHMARK_ONCE { // XXX Maybe a bug here, if you call account a lot system crashes        
+            acc = m_mgr->account(list.takeFirst());
+          }
+        }
+        if(m_mgr->error()){
+          QFAIL(QString("Failed fetching accounts: %1").arg(m_mgr->error()).toAscii());
+        }
+      }
+      else if(base == tst_messaging::Folders){
+        QMessageFolderIdList list;
+        QMessageFolder fol;
+        list = m_mgr->queryFolders();
+
+        if(!list.empty()) {
+          QBENCHMARK {          
+            fol = m_mgr->folder(list.takeFirst());          
+          }
+        }        
+      }
+      else if(base == tst_messaging::Messages){
+        QMessageIdList list;
+        QMessage msg;
+        list = m_mgr->queryMessages();
+        
+        if(!list.empty()){
+          QBENCHMARK {
+            msg = m_mgr->message(list.takeFirst());
+          }        
+        }
+      }
+      //qDebug() << "Got cnt: " << cnt;      
+    }
+    else if(platform == tst_messaging::Native){
+#ifdef Q_OS_SYMBIAN
+      if(base == tst_messaging::Messages){
+        __UHEAP_MARK;
+        // Access the Inbox
+        QBENCHMARK {
+          TMsvSelectionOrdering sort;
+          sort.SetSorting(EMsvSortByDateReverse);
+          sort.SetShowInvisibleEntries(ETrue);
+
+          CMsvEntry* inboxContext = CMsvEntry::NewL(*m_native->iSession, 
+                  KMsvDraftEntryIdValue /*KMsvGlobalInBoxIndexEntryId*/, sort);                
+          CleanupStack::PushL(inboxContext);
+
+          // Get all entries in the Inbox
+          CMsvEntrySelection* entries = inboxContext->ChildrenL();
+          CleanupStack::PushL(entries);
+
+          if(entries->Count() == 0){
+              CleanupStack::PopAndDestroy(2, inboxContext);
+              QSKIP("No messages on device to list", SkipAll);              
+          }
+          TMsvId entryID = entries->At(0);
+          const TUid mtm = inboxContext->ChildDataL(entryID).iMtm;
+
+          if (mtm == KUidMsgTypeSMS) {
+            m_native->iSmsMtm->SwitchCurrentEntryL(entryID);
+            TRAPD(err, m_native->iSmsMtm->LoadMessageL());
+            if(err){
+              qDebug() << "LoadMessageL failed: " << err;
+              continue;
+            }
+            CSmsHeader& header = m_native->iSmsMtm->SmsHeader();
+          }
+          else if (mtm == KUidMsgTypeMultimedia) {
+            // TODO None of these have a data store...skip until it can be fixed
+            QFAIL("MMS message handeling is broken, change setup to use non-MMS type");
+          }
+          else if (mtm == KUidMsgTypeIMAP4) {
+            m_native->iImap4Mtm->SwitchCurrentEntryL(entryID);
+            m_native->iImap4Mtm->LoadMessageL();            
+          }
+          else if (mtm == KUidMsgTypeSMTP){
+            m_native->iSmtpMtm->SwitchCurrentEntryL(entryID);
+            m_native->iSmtpMtm->LoadMessageL();
+          }
+          else {
+            qDebug() << "Got Type: " << hex << mtm.iUid;
+          }
+          CleanupStack::PopAndDestroy(2, inboxContext);
+        }
+        __UHEAP_MARKEND;
+      }
+
+#endif
+    }
+//qDebug() <<"End fetch";
+}
+
+void tst_messaging::tst_fetchAll_data()
+{
+    QTest::addColumn<tst_messaging::platform>("platform");
+    QTest::addColumn<tst_messaging::bases>("base");
+
+    QTest::newRow("Qt-Accounts") << tst_messaging::QMessaging << tst_messaging::Accounts;
+    QTest::newRow("Native-Accounts") << tst_messaging::Native << tst_messaging::Accounts;
+//    QTest::newRow("Qt-Folders") << tst_messaging::QMessaging << tst_messaging::Folders;
+    QTest::newRow("Native-Folders") << tst_messaging::Native << tst_messaging::Folders;
+    QTest::newRow("Qt-Messages") << tst_messaging::QMessaging << tst_messaging::Messages;
+    QTest::newRow("Native-Messages") << tst_messaging::Native << tst_messaging::Messages;
+
+}
+
+
+void tst_messaging::tst_fetchAll()
+{
+    QFETCH(tst_messaging::platform, platform);
+    QFETCH(tst_messaging::bases, base);
+    
+    if(platform == tst_messaging::QMessaging){      
+      if(base == tst_messaging::Accounts){
+        QMessageAccountIdList list;
+        QMessageAccount acc;
+        list = m_mgr->queryAccounts();
+
+        QBENCHMARK {        
+          while(!list.empty())
+            acc = m_mgr->account(list.takeFirst());
+        }
+      }
+      else if(base == tst_messaging::Folders){
+        QMessageFolderIdList list;
+        QMessageFolder fol;
+        list = m_mgr->queryFolders();
+
+        QBENCHMARK {
+          while(!list.empty())
+            fol = m_mgr->folder(list.takeFirst());          
+        }
+      }
+      else if(base == tst_messaging::Messages){
+        QMessageIdList list;
+        QMessage msg;
+        list = m_mgr->queryMessages();
+        if(list.count() == 0)
+          QFAIL("No messages to fetch");
+
+        qDebug() << "Total fetched messages: " << list.count(); 
+        QBENCHMARK {
+          while(!list.empty())
+            msg = m_mgr->message(list.takeFirst());
+        }        
+      }
+      //qDebug() << "Got cnt: " << cnt;      
+    }
+    else if(platform == tst_messaging::Native){
+#ifdef Q_OS_SYMBIAN
+      if(base == tst_messaging::Messages){
+        
+        __UHEAP_MARK;
+        
+        RArray<TMsvId> aFolders;
+        int total = 0;
+        int skipped = 0;
+        
+        m_native->getFolders(aFolders);
+
+        // Access the Inbox
+        QBENCHMARK {
+
+          for(int i = 0; i < aFolders.Count(); i++){
+            TMsvSelectionOrdering sort;
+            //sort.SetSorting(EMsvSortByDateReverse);
+            sort.SetSorting(EMsvSortByNone);
+            sort.SetShowInvisibleEntries(ETrue);
+            
+            CMsvEntry* inboxContext = CMsvEntry::NewL(*m_native->iSession, 
+                aFolders[i], sort);                
+            CleanupStack::PushL(inboxContext);
+
+            // Get all entries in the Inbox
+            CMsvEntrySelection* entries = inboxContext->ChildrenL();
+            CleanupStack::PushL(entries);
+            
+            for (TInt i = 0; i < entries->Count(); i++) {              
+              
+              TMsvId entryID = entries->At(i);
+              
+              const TUid mtm = inboxContext->ChildDataL(entryID).iMtm;
+              
+//              qDebug() << "Entry: " << i << " mtm: " << hex << mtm.iUid;
+              
+              if (mtm == KUidMsgTypeSMS) {
+
+                TRAP_IGNORE(m_native->iSmsMtm->SwitchCurrentEntryL(entryID));                
+                TRAPD(err, m_native->iSmsMtm->LoadMessageL());
+                if(err){
+                  qDebug() << "LoadMessageL failed: " << err;
+                  continue;
+                }                
+                //CSmsHeader& header = m_native->iSmsMtm->SmsHeader();                
+                total++;
+              }
+              else if (mtm == KUidMsgTypeMultimedia) {
+
+                // TODO None of these have a data store...skip until it can be fixed 
+                
+//                                 CMsvEntry* pEntry = NULL;        
+//                                 pEntry = m_native->iSession->GetEntryL(entryID);        
+//                                 const TMsvEntry& entry = pEntry->Entry();    
+//                                 
+//                                 QString details = QString::fromUtf16(entry.iDetails.Ptr(),entry.iDetails.Length());
+//                                 QString desc = QString::fromUtf16(entry.iDescription.Ptr(),entry.iDescription.Length());
+//                                 qDebug() << "Nothing returned for entry: " << entryID << "/" << entry.Id() << " " << details << " - " << desc << " Has store: " << pEntry->HasStoreL();
+////                                 m_native->iImap4Mtm->SwitchCurrentEntryL(entry.Id());
+
+                
+//                m_native->iMmsMtm->SwitchCurrentEntryL(entryID);
+//                TRAPD(err, m_native->iMmsMtm->LoadMessageL());
+//                if(err){
+//                  qDebug() << "LoadMessageL failed: " << err << "entryId/mtm" << entryID << "/" << mtm.iUid;
+//                  continue;
+//                }
+                skipped++;
+              }
+              else if (mtm == KUidMsgTypeIMAP4 || mtm == KUidMsgTypeSMTP) {                 
+                 CMsvEntry* pEntry = NULL;        
+                 pEntry = m_native->iSession->GetEntryL(entryID);
+
+                 CImEmailMessage *pMsg = CImEmailMessage::NewLC(*pEntry);                 
+
+                 CMsvStore *store = 0x0;
+                 TRAPD(err, store = pEntry->ReadStoreL());
+                 if(err){
+//                   TPtrC sub;
+//                   m_native->iImap4Mtm->SwitchCurrentEntryL(entryID);
+//                   m_native->iImap4Mtm->LoadMessageL();                   
+//                   TRAP(err,sub.Set(m_native->iImap4Mtm->SubjectL()));
+//                   if(err){
+//                     qDebug() << "No subject either: " << err;                     
+//                   }                   
+//                   qDebug() << "Can't read store: " << err << hex << entryID << " Details: " << QString::fromUtf16(sub.Ptr(), sub.Length());
+                   skipped++;
+                   CleanupStack::PopAndDestroy(pMsg);
+                   continue;
+                 }
+                 CleanupStack::PushL(store);
+                 
+                 CImHeader* header = CImHeader::NewLC();                 
+                 header->RestoreL(*store);
+                 
+                 //subject buffer contains the "subject" of the mail.
+                 TBuf<50> subject = header->Subject();
+                  
+                 //header buffer contains the "header" of the mail.
+                 TBuf<50> from = header->From();
+
+                 CleanupStack::PopAndDestroy(header);
+                 CleanupStack::PopAndDestroy(store);
+                 CleanupStack::PopAndDestroy(pMsg);
+                                  
+                 total++;
+               }              
+              else {
+//                qDebug() << "Got Type: " << mtm.iUid;
+              }              
+            }
+            CleanupStack::PopAndDestroy(2, inboxContext);           
+          }          
+        }
+//        qDebug() << "Total messages fetched: " << total << " skipped: " << skipped;
+        __UHEAP_MARKEND;
+      }            
+#endif
+    }
+
+}
+
+
+
+void tst_messaging::tst_fetchFilter_data()
+{
+  QTest::addColumn<tst_messaging::platform>("platform");
+  QTest::addColumn<tst_messaging::filter>("filter");
+  
+  QTest::newRow("Qt-Id") << tst_messaging::QMessaging << tst_messaging::Id;
+  QTest::newRow("Qt-Type") << tst_messaging::QMessaging << tst_messaging::Type;
+  QTest::newRow("Qt-Sender") << tst_messaging::QMessaging << tst_messaging::Sender;
+  QTest::newRow("Qt-Subject") << tst_messaging::QMessaging << tst_messaging::Subject;
+  QTest::newRow("Qt-TimeStamp") << tst_messaging::QMessaging << tst_messaging::TimeStamp;
+  QTest::newRow("Qt-Status") << tst_messaging::QMessaging << tst_messaging::Status;
+  QTest::newRow("Qt-Priority") << tst_messaging::QMessaging << tst_messaging::Priority;
+  QTest::newRow("Qt-Size") << tst_messaging::QMessaging << tst_messaging::Size;
+  // XXX Test is broken, User::Panic(47) on symbian
+//  QTest::newRow("Qt-AllId") << tst_messaging::QMessaging << tst_messaging::AllId;
+  QTest::newRow("Qt-AllSender") << tst_messaging::QMessaging << tst_messaging::AllSender;
+  
+  QTest::newRow("Native-Id") << tst_messaging::Native << tst_messaging::Id;
+  QTest::newRow("Native-Type") << tst_messaging::Native << tst_messaging::Type;
+  QTest::newRow("Native-Sender") << tst_messaging::Native << tst_messaging::Sender;
+  QTest::newRow("Native-Subject") << tst_messaging::Native << tst_messaging::Subject;
+  QTest::newRow("Native-TimeStamp") << tst_messaging::Native << tst_messaging::TimeStamp;
+  QTest::newRow("Native-Status") << tst_messaging::Native << tst_messaging::Status;
+  QTest::newRow("Native-Priority") << tst_messaging::Native << tst_messaging::Priority;
+  QTest::newRow("Native-Size") << tst_messaging::Native << tst_messaging::Size;  
+  QTest::newRow("Native-AllId") << tst_messaging::Native << tst_messaging::AllId;
+  QTest::newRow("Native-AllSender") << tst_messaging::Native << tst_messaging::AllSender;
+  
+  // QTest::newRow("Native-Size") << tst_messaging::Native << tst_messaging::Size;
+}
+
+void tst_messaging::tst_fetchFilter()
+{
+  QFETCH(tst_messaging::platform, platform);
+  QFETCH(tst_messaging::filter, filter);
+  
+  if(platform == tst_messaging::QMessaging){
+
+    QMessageId msgId;
+    QMessageFilter mf;
+    QMessageId id;
+    // let's assume we want equal tests for all the filters.
+    // So let's try and filter out 1 message from each filter request.    
+    if(filter == tst_messaging::Id){
+      id = msg_list.takeFirst();
+        mf = QMessageFilter::byId(id);
+        msg_list.push_back(id);        
+    }
+    else if(filter == tst_messaging::Type){      
+        QMessage *msg = messageTemplate();
+        
+        msgId = addMessage(msg);       
+        mf = QMessageFilter::byType(QMessage::Sms);
+        
+    }  
+    else if(filter == tst_messaging::Sender){
+        QString email = "singletst@boo.com";
+        QMessage *msg = messageTemplate();
+        QMessageAddress addr;
+        addr.setAddressee(email);
+        msg->setFrom(addr);
+        msgId = addMessage(msg);
+
+        id = msg_list.takeFirst();
+        mf = QMessageFilter::bySender(email);
+    }
+    else if(filter == tst_messaging::TimeStamp){
+        QMessage *msg = messageTemplate();
+        QDateTime dt = QDateTime::currentDateTime();
+        dt.addDays(1);
+        msg->setReceivedDate(dt);
+        msg->setDate(dt);
+        msgId = addMessage(msg);
+        
+        mf = QMessageFilter::byTimeStamp(dt, QMessageDataComparator::Equal);
+    }
+    else if(filter == tst_messaging::Status){
+        QMessage *msg = messageTemplate();
+        msg->setStatus(QMessage::Incoming);
+        msgId = addMessage(msg);
+
+        mf = QMessageFilter::byStatus(QMessage::Incoming);
+    }
+    else if(filter == tst_messaging::Subject){
+      QMessage *msg = messageTemplate();
+      QString subject = "skdflkdsjfl sdfklke  werewr";
+      msg->setSubject(subject);
+      msgId = addMessage(msg);
+      
+      mf = QMessageFilter::bySubject(subject);
+    }
+    else if(filter == tst_messaging::Priority){
+        QMessage *msg = messageTemplate();
+        msg->setPriority(QMessage::LowPriority);
+        msgId = addMessage(msg);
+
+        mf = QMessageFilter::byPriority(QMessage::LowPriority);
+    }
+    else if(filter == tst_messaging::Size){
+        QString body;
+        body.fill('x', 5120);
+        QMessage *msg = messageTemplate();
+        msg->setBody(body);
+        msgId = addMessage(msg);
+
+        mf = QMessageFilter::bySize(5000, QMessageDataComparator::GreaterThan);
+    }
+    else if(filter == tst_messaging::AllId){
+//      mf = QMessageFilter::byId(msg_list.mid(0, 2)); works, mid(0,15) fails...
+      mf = QMessageFilter::byId(msg_list);
+    }
+    else if(filter == tst_messaging::AllSender){
+      id = msg_list.takeFirst();      
+      msg_list.push_back(id);   
+      QMessage msg = m_mgr->message(id);
+      
+      mf = QMessageFilter::bySender(msg.from().addressee());
+    }
+    if(!mf.isSupported()){
+        QFAIL("QMessage filter returned unsupported");
+    }
+    else if(mf.isEmpty()){
+      QFAIL("Empty filter provided");
+    }
+    else {
+        QMessageIdList list;
+        QMessageSortOrder sortOrder(QMessageSortOrder::byReceptionTimeStamp(Qt::DescendingOrder));
+        QBENCHMARK {          
+            list = m_mgr->queryMessages(mf, sortOrder, 100);
+        }
+        if(list.count() != 1 && filter != tst_messaging::AllId && filter != tst_messaging::AllSender)
+            qDebug() << "Wanted 1 message got: " << list.count();
+    }
+
+    if(msgId.isValid()){
+        m_mgr->removeMessage(msgId);
+    }
+  }
+  else if(platform == tst_messaging::Native){
+#ifdef Q_OS_SYMBIAN
+    if(filter == tst_messaging::Id){
+      // Access the Inbox
+      QBENCHMARK {
+        TMsvSelectionOrdering sort;
+        //sort.SetSorting(EMsvSortByDateReverse);
+        sort.SetSorting(EMsvSortById);
+        sort.SetShowInvisibleEntries(ETrue);
+          
+        CMsvEntry* inboxContext = CMsvEntry::NewL(*m_native->iSession, 
+                KMsvDraftEntryIdValue /*KMsvGlobalInBoxIndexEntryId*/, sort);                
+        CleanupStack::PushL(inboxContext); // 1
+
+        // Get all entries in the Inbox
+        CMsvEntrySelection* entries = inboxContext->ChildrenL();
+        CleanupStack::PushL(entries); // 2
+        if(entries->Count() == 0){
+            CleanupStack::PopAndDestroy(2, inboxContext);
+            QSKIP("No messages on device to list", SkipAll);                        
+        }
+        
+        TMsvId entryID = entries->At(0);
+
+        const TUid mtm = inboxContext->ChildDataL(entryID).iMtm;
+      
+        CleanupStack::PopAndDestroy(2, inboxContext);
+      }
+    }
+    else if(filter == tst_messaging::Type){ // look for SMS messages
+      // Access the Inbox
+      RArray<TMsvId> msvids;
+      RArray<TMsvId> aFolders;
+    
+      m_native->getFolders(aFolders);
+      
+      //qDebug() << "Total folders: " << aFolders.Count();
+    
+      QBENCHMARK {
+        msvids.Close(); // zero it out
+        for(int i = 0; i < aFolders.Count(); i++){
+
+          TMsvSelectionOrdering sort;
+          //sort.SetSorting(EMsvSortByDateReverse);
+          sort.SetSorting(EMsvSortByNone);
+          sort.SetShowInvisibleEntries(ETrue);
+
+          CMsvEntry* inboxContext = CMsvEntry::NewL(*m_native->iSession, 
+              aFolders[i], sort);                
+          CleanupStack::PushL(inboxContext);
+
+          // Get all entries in the Inbox
+          CMsvEntrySelection* entries = inboxContext->ChildrenL();
+          CleanupStack::PushL(entries);
+
+          for (TInt j = 0; j < entries->Count(); j++) {
+            TMsvId entryID = entries->At(j);
+            const TUid mtm = inboxContext->ChildDataL(entryID).iMtm;
+
+            if (mtm == KUidMsgTypeSMS) {
+              msvids.AppendL(entryID);
+            }
+          }      
+          CleanupStack::PopAndDestroy(2, inboxContext);
+        }
+      }
+      msvids.Close();
+    }
+    else if(filter == tst_messaging::Sender || 
+        filter == tst_messaging::Subject ||
+        filter == tst_messaging::TimeStamp){
+      // Access the Inbox
+        
+      TMsvPartList part = KMsvMessagePartDescription;
+      TPtrC text = _L("tst");
+      
+      if(filter == tst_messaging::Sender){
+        part = KMsvMessagePartOriginator;
+        text.Set(_L("Millicent"));
+      }
+      else if(filter == tst_messaging::Subject){
+        part = KMsvMessagePartDescription;
+        text.Set(_L("Free Bottle"));
+      }
+      else if(filter == tst_messaging::TimeStamp){
+        part = KMsvMessagePartDate;
+        text.Set(_L("Sep"));
+      }
+
+      CMsvOperationActiveSchedulerWait* waiter=CMsvOperationActiveSchedulerWait::NewLC();
+      
+      CMsvFindOperation *finder = CMsvFindOperation::FindInChildrenL(*m_native->iSession, text, KMsvRootIndexEntryId, part, waiter->iStatus);
+      CleanupStack::PushL(finder);
+
+      QBENCHMARK {      
+        waiter->Start();
+      }
+      if(finder->GetFindResult().Count() != 1)
+        qDebug() << "Wanted 1 message, got: " << finder->GetFindResult().Count(); 
+      
+//      qDebug() << "Status: " << finder->GetFindResult().Count();
+//      for(int i = 0; i < finder->GetFindResult().Count(); i++){
+//        CMsvEntry *pEntry;
+//        TRAPD(err, pEntry = m_native->iSession->GetEntryL(finder->GetFindResult().At(i).iId));
+//        if(err){
+//          qDebug() << "Failed to fetch: " << i << " - " << finder->GetFindResult().At(i).iId;
+//          continue;
+//        }
+//        CleanupStack::PushL(pEntry);
+//        TMsvEntry entry = pEntry->Entry();
+//        QString details = QString::fromUtf16(entry.iDetails.Ptr(),entry.iDetails.Length());
+//        QString desc = QString::fromUtf16(entry.iDescription.Ptr(),entry.iDescription.Length());
+//        qDebug() << "Got entry: " << details << " - " << desc;
+//        CleanupStack::PopAndDestroy(1); //
+//      }
+       
+      CleanupStack::PopAndDestroy(2, waiter); 
+      
+    }
+    else if(filter == tst_messaging::Priority) {
+      RArray<TMsvId> msvids;
+
+      CMsvOperationActiveSchedulerWait* waiter=CMsvOperationActiveSchedulerWait::NewLC();
+      
+      TBufC<10> null(_L(" "));
+      CMsvFindOperation *finder = CMsvFindOperation::FindInChildrenL(*m_native->iSession, null, KMsvRootIndexEntryId, KMsvMessagePartDescription, waiter->iStatus);
+      CleanupStack::PushL(finder);
+
+      QBENCHMARK {      
+        waiter->Start();
+        
+        const CMsvFindResultSelection &res = finder->GetFindResult();
+        
+        for(int i = 0; i < res.Count(); i++){          
+          CMsvEntry *pEntry = 0x0;
+          TRAPD(err, pEntry = m_native->iSession->GetEntryL(res.At(i).iId));
+          if(err){
+            qDebug() << "Failed to fetch: " << i << " - " << res.At(i).iId;
+            continue;
+          }
+          CleanupStack::PushL(pEntry);
+          TMsvEntry entry = pEntry->Entry();
+
+          if(entry.Priority() == EMsvLowPriority) 
+            msvids.Append(entry.Id());
+          
+          CleanupStack::PopAndDestroy(1); //
+        }
+      }
+      msvids.Close();
+      CleanupStack::PopAndDestroy(2, waiter);
+    }
+    else if(filter == tst_messaging::Size){
+      RArray<TMsvId> msvids;
+
+      CMsvOperationActiveSchedulerWait* waiter=CMsvOperationActiveSchedulerWait::NewLC();
+      
+      TBufC<10> null(_L(" "));
+      CMsvFindOperation *finder = CMsvFindOperation::FindInChildrenL(*m_native->iSession, null, KMsvRootIndexEntryId, KMsvMessagePartDescription, waiter->iStatus);
+      CleanupStack::PushL(finder);
+
+      QBENCHMARK {      
+        waiter->Start();
+        
+        const CMsvFindResultSelection &res = finder->GetFindResult();
+        
+        for(int i = 0; i < res.Count(); i++){          
+          CMsvEntry *pEntry = 0x0;
+          TRAPD(err, pEntry = m_native->iSession->GetEntryL(res.At(i).iId));
+          if(err){
+            qDebug() << "Failed to fetch: " << i << " - " << res.At(i).iId;
+            continue;
+          }
+          CleanupStack::PushL(pEntry);
+          TMsvEntry entry = pEntry->Entry();
+
+          if(entry.iSize == 550)
+            msvids.Append(entry.Id());          
+          
+          CleanupStack::PopAndDestroy(1); //
+        }
+      }
+      msvids.Close();
+      CleanupStack::PopAndDestroy(2, waiter);      
+    }
+    if(filter == tst_messaging::AllId){
+      // Access the Inbox
+      QBENCHMARK {
+        RArray<TMsvId> msvids;
+        
+        TMsvSelectionOrdering sort;
+        //sort.SetSorting(EMsvSortByDateReverse);
+        sort.SetSorting(EMsvSortById);
+        sort.SetShowInvisibleEntries(ETrue);
+          
+        CMsvEntry* inboxContext = CMsvEntry::NewL(*m_native->iSession, 
+            KMsvGlobalInBoxIndexEntryId, sort);                
+        CleanupStack::PushL(inboxContext);
+
+        // Get all entries in the Inbox
+        CMsvEntrySelection* entries = inboxContext->ChildrenL();
+        CleanupStack::PushL(entries);
+        
+        for(int i = 0; i < entries->Count(); i++){
+          msvids.Append(entries->At(i));
+        }
+
+        msvids.Close();       
+        
+        CleanupStack::PopAndDestroy(2, inboxContext);
+      }
+    }
+    else if(filter == tst_messaging::AllSender){
+      RArray<TMsvId> msvids;
+
+      CMsvOperationActiveSchedulerWait* waiter=CMsvOperationActiveSchedulerWait::NewLC();
+      
+      TBufC<10> null(_L("@"));
+      CMsvFindOperation *finder = CMsvFindOperation::FindInChildrenL(*m_native->iSession, null, KMsvRootIndexEntryId, KMsvMessagePartOriginator, waiter->iStatus);
+      CleanupStack::PushL(finder);
+
+      QBENCHMARK {      
+        waiter->Start();
+        
+        const CMsvFindResultSelection &res = finder->GetFindResult();        
+        TMsvSelectionOrdering order;
+        
+        CMsvEntry *pEntry = CMsvEntry::NewL(*m_native->iSession, KMsvRootIndexEntryId, TMsvSelectionOrdering(KMsvNoGrouping, EMsvSortByNone));
+        CleanupStack::PushL(pEntry);
+        
+        for(int i = 0; i < res.Count(); i++){
+          TRAPD(err, pEntry->SetEntryL(res.At(i).iId));          
+          if(err){
+            qDebug() << "Failed to fetch: " << i << " - " << res.At(i).iId;
+            continue;
+          }
+          TMsvEntry entry = pEntry->Entry();
+          
+          msvids.Append(entry.Id());          
+                  
+        }
+        
+        CleanupStack::PopAndDestroy(pEntry);
+      }
+      msvids.Close();
+      CleanupStack::PopAndDestroy(2, waiter);          
+    }
+#endif
+  }      
+}
+
+void tst_messaging::clearMessages()
+{
+  QMessageId id;
+  int num = 0;
+  qDebug() << "Start QtMessaging removal";
+  while(!msg_list.empty())
+    m_mgr->removeMessage(msg_list.takeFirst()), num++;
+  qDebug() << "Start Native removal";
+#ifdef Q_OS_SYMBIAN
+  while(m_native->iNewMsgs.Count())
+    m_native->iSession->RemoveEntry(m_native->iNewMsgs[0]), m_native->iNewMsgs.Remove(0), num++;
+#endif
+
+  qDebug() << "Cleanup Removed: " << num;
+}
+
+QMessage *tst_messaging::messageTemplate()
+{
+  QMessage *msg = new QMessage;
+  
+  msg->setType(QMessage::Email);
+  msg->setDate(QDateTime::currentDateTime());
+  msg->setSubject("test");
+  QMessageAddress addr;
+  addr.setAddressee("abr@foo.com");
+  addr.setType(QMessageAddress::Email);
+  msg->setTo(addr);
+  addr.setAddressee("from@bar.com");
+  addr.setType(QMessageAddress::Email);
+  msg->setFrom(addr);
+  
+  return msg;
+}
+
+QMessageId tst_messaging::addMessage(QMessage *msg)
+{
+  if(!m_mgr->addMessage(msg))
+    qDebug() << "Failed to add message: " << m_mgr->error();  
+
+  msg_list.append(msg->id());
+
+  //qDebug() << "id: " << msg->id().toString();
+  
+  return msg->id();
+}
+
+QMessage *tst_messaging::createMessage()
+{
+    QMessage *msg = messageTemplate();
+    addMessage(msg);
+    return msg;
+}
+
+int tst_messaging::countMessages()
+{
+  QMessageIdList list;
+  list = m_mgr->queryMessages();
+  return list.count();
+}
+
+void tst_messaging::tst_addMessage_data()
+{
+    QTest::addColumn<tst_messaging::platform>("platform");    
+    QTest::addColumn<tst_messaging::types>("type");
+    
+    QTest::newRow("Qt-Email") << tst_messaging::QMessaging << tst_messaging::Email;
+// XXX SMS broken. On clean devices there is no SMSMC to create messages for.    
+//    QTest::newRow("Native-SMS") << tst_messaging::Native << tst_messaging::Sms; 
+    QTest::newRow("Native-Email") << tst_messaging::Native << tst_messaging::Email;
+   
+}
+
+void tst_messaging::tst_addMessage()
+{
+    QFETCH(tst_messaging::platform, platform);
+    QFETCH(tst_messaging::types, type);
+    
+    if(platform == tst_messaging::QMessaging){
+      QBENCHMARK {
+        QMessage *msg = createMessage();
+        addMessage(msg);
+      }
+    }
+    else if(platform == tst_messaging::Native){
+#ifdef Q_OS_SYMBIAN
+      if(type == tst_messaging::Sms){
+        TMsvId id;
+        QBENCHMARK {
+          TRAPD(err, id = m_native->makeSMS(KMsvGlobalInBoxIndexEntryId));
+          if(err){
+              qDebug() << "Failed to create sms: " << err;
+          }
+        }
+        m_native->iNewMsgs.Append(id);
+      }
+      else if(type == tst_messaging::Email){
+        TMsvId id;
+        QBENCHMARK {
+          TRAPD(err, id = m_native->makeIMAP4(KMsvGlobalInBoxIndexEntryId));
+          if(err){
+              qDebug() << "Failed to create sms: " << err;
+          }
+
+        }
+        m_native->iNewMsgs.Append(id);
+      }
+#else 
+    Q_UNUSED(type);
+#endif
+    }
+
+}
+
+void tst_messaging::tst_removeMessage_data()
+{
+  QTest::addColumn<tst_messaging::platform>("platform");    
+
+  QTest::newRow("Qt-remove") << tst_messaging::QMessaging;
+  QTest::newRow("Native-remove") << tst_messaging::Native;  
+}
+
+void tst_messaging::tst_removeMessage() 
+{
+  QFETCH(tst_messaging::platform, platform);
+
+  if(platform == tst_messaging::QMessaging){
+//#ifdef Q_OS_SYMBIAN
+//      TMsvId id;
+//      id = m_native->makeIMAP4(KMsvDraftEntryIdValue);
+//      QString str;
+//      str.setNum(id);
+//      QMessageId qmid = str;    
+//#else
+      QMessageId qmid = msg_list.takeFirst();
+//#endif
+
+   QBENCHMARK_ONCE {
+          m_mgr->removeMessage(qmid);
+    }
+  }  
+  else if(platform == tst_messaging::Native){
+#ifdef Q_OS_SYMBIAN
+      TMsvId id;
+      id = m_native->makeIMAP4(KMsvDraftEntryIdValue);      
+      CMsvEntry *pEntry = CMsvEntry::NewL(*m_native->iSession, id, TMsvSelectionOrdering());
+      CleanupStack::PushL(pEntry);
+      QBENCHMARK_ONCE {    // We're only guaranteed one entry to delete.  Not a fast process anyways.s
+          TRAPD(err, pEntry->DeleteL(id)); // slightly dangerous since we never want this failing, but it can fail too something, should debug TODO
+          if(err){
+          QFAIL(QString("Message delete failed with error: " + QString::number(err)).toAscii());
+          }
+      }
+      CleanupStack::PopAndDestroy(pEntry);          
+#endif
+  }
+
+}
+
+void tst_messaging::tst_removeAllMessage_data()
+{
+  QTest::addColumn<tst_messaging::platform>("platform");    
+
+  QTest::newRow("Qt-removeAll") << tst_messaging::QMessaging;
+  QTest::newRow("Native-removeAll") << tst_messaging::Native;  
+}
+
+void tst_messaging::tst_removeAllMessage() 
+{
+  QFETCH(tst_messaging::platform, platform);
+
+  if(platform == tst_messaging::QMessaging){
+    QBENCHMARK {
+      while(!msg_list.empty())
+        m_mgr->removeMessage(msg_list.takeFirst());
+    }
+  }
+  else if(platform == tst_messaging::Native){
+#ifdef Q_OS_SYMBIAN
+    // make sure there's enough messages to delete
+    while(m_native->iNewMsgs.Count() < 30) {
+      TMsvId id;
+      id = m_native->makeIMAP4(KMsvDraftEntryIdValue);      
+      m_native->iNewMsgs.Append(id);
+    }
+    
+    QBENCHMARK {      
+      CMsvEntry *pEntry = 0x0;
+      TRAPD(err, pEntry = CMsvEntry::NewL(*m_native->iSession, KMsvRootIndexEntryId, TMsvSelectionOrdering()));
+      if(err){
+        qDebug() << "Failed to init CMsvEntryL " << err;
+        return;
+      }
+      CleanupStack::PushL(pEntry);
+      while(m_native->iNewMsgs.Count() != 0) {
+        TMsvId id = m_native->iNewMsgs[0];
+        m_native->iNewMsgs.Remove(0);    
+        //pEntry->SetEntryL(id);
+        TRAP_IGNORE(pEntry->DeleteL(id));                
+      }
+      CleanupStack::PopAndDestroy(pEntry);
+    }
+#endif
+  }
+
+}
+
+#if defined(Q_OS_SYMBIAN)
+
+void OsNative::getFolders(RArray<TMsvId> &folders) {
+  __UHEAP_MARK;
+
+  CEmailAccounts *email = CEmailAccounts::NewLC();
+  RArray<TPopAccount> aPop;
+  RArray<TImapAccount> aImap;
+  RArray<TSmtpAccount> aSmtp;
+
+#ifndef KDocumentsEntryIdValue
+#define KDocumentsEntryIdValue    0x1008
+#endif
+  
+  folders.Append(KMsvRootIndexEntryId);
+  folders.Append(KMsvLocalServiceIndexEntryId);
+  folders.Append(KMsvGlobalInBoxIndexEntryId);
+  folders.Append(KMsvGlobalOutBoxIndexEntryId);
+  folders.Append(KMsvDraftEntryId);
+  folders.Append(KMsvSentEntryId);
+  folders.Append(KMsvDeletedEntryFolderEntryId);
+  folders.Append(KDocumentsEntryIdValue);
+  folders.Append(KMsvMyFoldersEntryId);
+
+  email->GetPopAccountsL(aPop);
+  email->GetImapAccountsL(aImap);
+  email->GetSmtpAccountsL(aSmtp);
+
+  RArray<TMsvId> aService;
+  
+//  aService.Append(KMsvLocalServiceIndexEntryId);
+//  aService.Append(KMsvRootIndexEntryId);
+
+  for(int i = 0; i < aPop.Count(); i++){
+    aService.Append(aPop[i].iPopService);
+  }
+  for(int i = 0; i < aImap.Count(); i++){
+    aService.Append(aImap[i].iImapService);
+  }
+  for(int i = 0; i < aSmtp.Count(); i++){
+    aService.Append(aSmtp[i].iSmtpService);
+  }
+  
+  TSmtpAccount sacc;
+  if(email->DefaultSmtpAccountL(sacc))
+    aService.Append(sacc.iSmtpService);
+
+  if(aService.Count() > 0) {
+      CMsvEntry* pEntry = NULL;
+      
+      TRAPD(err, pEntry = iSession->GetEntryL(aService[0]));
+      if(!err) {
+          CleanupStack::PushL(pEntry);
+          for(int i = 0; i < aService.Count(); i++){
+              TMsvId msvid = aService[i];
+              
+              TRAP(err, pEntry->SetEntryL(msvid)); // faster to call set, saves .2ms out of 2.7ms.
+              if(err)
+                  continue;
+        
+              const TMsvEntry& entry = pEntry->Entry();
+              CMsvEntryFilter* pFilter = CMsvEntryFilter::NewLC();
+              pFilter->SetService(msvid);
+              pFilter->SetType(KUidMsvFolderEntry);
+              CMsvEntrySelection* pSelection = new(ELeave) CMsvEntrySelection;
+              CleanupStack::PushL(pSelection);
+
+              if (entry.iMtm == KUidMsgTypeSMS || entry.iMtm == KUidMsgTypeMultimedia || entry.iMtm == KUidMsgTypeSMTP) 
+                pEntry->SetEntryL(KDocumentsEntryIdValue);          
+              
+              iSession->GetChildIdsL(msvid, *pFilter, *pSelection);
+              for(TInt i = 0; i < pSelection->Count(); i++) {
+                folders.Append(pSelection->At(i));
+                pEntry->SetEntryL(pSelection->At(i));
+                if(pEntry->Entry().iMtm == KUidMsvFolderEntry){
+                    aService.Append(pSelection->At(i));
+                }            
+              }              
+              CleanupStack::PopAndDestroy(pSelection);
+              CleanupStack::PopAndDestroy(pFilter);
+        
+            }
+          CleanupStack::PopAndDestroy(pEntry);
+        }
+  }
+    aPop.Close();
+    aImap.Close();
+    aSmtp.Close();
+    aService.Close();
+        
+    CleanupStack::PopAndDestroy(email);
+  __UHEAP_MARKEND;
+}
+#endif 
+
+int main(int argc, char **argv){
+
+    QApplication app(argc, argv);
+    
+    tst_messaging test1;
+    QTest::qExec(&test1, argc, argv);
+    
+}
+//QTEST_MAIN(tst_messaging);
+
+
+#include "tst_messaging.moc"
+