1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the Qt Mobility Components.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 #include <QObject>

    42 #include <QTest>

    43 #include <QDebug>

    44 

    45 #include "qmessageservice.h"

    46 #include "../support/support.h"

    47 

    48 #if defined(Q_OS_SYMBIAN) || (defined(Q_OS_WIN) && defined(_WIN32_WCE))

    49 # if defined(TESTDATA_DIR)

    50 #  undef TESTDATA_DIR

    51 # endif

    52 # define TESTDATA_DIR "."

    53 #endif

    54 

    55 // Will try to wait for the condition while allowing event processing

    56 #define QTRY_VERIFY(__expr) \

    57     do { \

    58         const int __step = 50; \

    59         const int __timeout = 90000; \

    60         if (!(__expr)) { \

    61             QTest::qWait(0); \

    62         } \

    63         for (int __i = 0; __i < __timeout && !(__expr); __i+=__step) { \

    64             QTest::qWait(__step); \

    65         } \

    66         QVERIFY(__expr); \

    67     } while(0)

    68 

    69 //TESTED_CLASS=

    70 //TESTED_FILES=

    71 

    72 QTM_USE_NAMESPACE

    73 

    74 class SignalCatcher : public QObject

    75 {

    76     Q_OBJECT

    77 

    78 public:

    79     SignalCatcher(QObject* parent = 0);

    80 

    81     void reset();

    82 

    83 public slots:

    84     void messagesCounted(int count);

    85     void messagesFound(const QMessageIdList& messageList);

    86     void stateChanged(QMessageService::State s);

    87     void progressChanged(int,int);

    88 

    89 public:

    90     QMessageIdList ids;

    91     int count;

    92     QMessageService::State state;

    93     int progressMin, progressMax;

    94 };

    95 

    96 SignalCatcher::SignalCatcher(QObject* parent)

    97 :

    98 QObject(parent)

    99 {

   100     reset();

   101 }

   102 

   103 void SignalCatcher::reset()

   104 {

   105     ids.clear();

   106     count = 0;

   107     progressMin = 0;

   108     progressMax = 0;

   109     state = QMessageService::InactiveState;

   110 }

   111 

   112 void SignalCatcher::messagesCounted(int c)

   113 {

   114     count = c;

   115 }

   116 

   117 void SignalCatcher::messagesFound(const QMessageIdList& results)

   118 {

   119     ids.append(results);

   120 }

   121 

   122 void SignalCatcher::stateChanged(QMessageService::State s)

   123 {

   124     state = s;

   125 }

   126 

   127 void SignalCatcher::progressChanged(int min, int max)

   128 {

   129     progressMin = min; progressMax = max;

   130 }

   131 

   132 class Params

   133 {

   134     QMap<const char*, const char*> _map;

   135 

   136 public:

   137     Params() {}

   138 

   139     Params& operator()(const char* name, const char* value)

   140     {

   141         _map.insert(name, value); return *this;

   142     }

   143 

   144     operator Support::Parameters() const

   145     {

   146         Support::Parameters result;

   147         QMap<const char*, const char*>::const_iterator it = _map.begin(), end = _map.end();

   148         for ( ; it != end; ++it) {

   149             result.insert(it.key(), it.value());

   150         }

   151         return result;

   152     }

   153 };

   154 

   155 /*

   156     Unit test for QMessageService class.

   157 */

   158 class tst_QMessageService : public QObject

   159 {

   160     Q_OBJECT

   161 

   162 public:

   163     tst_QMessageService();

   164     virtual ~tst_QMessageService();

   165 

   166 private slots:

   167 

   168     void init();

   169     void cleanUp();

   170 

   171     void initTestCase();

   172     void cleanupTestCase();

   173 

   174     void testQueryMessages();

   175     void testQueryMessages_data();

   176 

   177     void testCountMessages();

   178     void testCountMessages_data();

   179 

   180     void testSend();

   181 

   182     void testCompose();

   183 

   184     void testRetrieveHeader();

   185 

   186     void testRetrieveBody();

   187 

   188     void testRetrieve();

   189 

   190     void testShow();

   191 

   192     void testExportUpdates();

   193 

   194 private:

   195     void testQueryCountData();

   196 

   197 private:

   198     QMessageService* testService;

   199 

   200     QSet<QMessageFolderId> existingFolderIds;

   201     QMessageFolderIdList folderIds;

   202 

   203     QSet<QMessageAccountId> existingAccountIds;

   204     QMessageAccountIdList accountIds;

   205 

   206     QSet<QMessageId> existingMessageIds;

   207     QMessageIdList messageIds;

   208 

   209     QMessageFilter existingAccountsFilter;

   210 

   211     QList<int> messageSizes;

   212 };

   213 

   214 Q_DECLARE_METATYPE(QMessageAccountIdList)

   215 Q_DECLARE_METATYPE(QMessageAccountFilter)

   216 Q_DECLARE_METATYPE(QMessageAccountSortOrder)

   217 

   218 Q_DECLARE_METATYPE(QMessageFolderIdList)

   219 Q_DECLARE_METATYPE(QMessageFolderFilter)

   220 Q_DECLARE_METATYPE(QMessageFolderSortOrder)

   221 

   222 Q_DECLARE_METATYPE(QMessageIdList)

   223 Q_DECLARE_METATYPE(QMessageFilter)

   224 Q_DECLARE_METATYPE(QMessageSortOrder)

   225 

   226 QTEST_MAIN(tst_QMessageService)

   227 

   228 #include "tst_qmessageservice.moc"

   229 

   230 tst_QMessageService::tst_QMessageService()

   231 {

   232 }

   233 

   234 tst_QMessageService::~tst_QMessageService()

   235 {

   236 }

   237 

   238 void tst_QMessageService::init()

   239 {

   240     testService = new QMessageService(this);

   241 }

   242 

   243 void tst_QMessageService::cleanUp()

   244 {

   245     if(testService) delete testService; testService = 0;

   246 }

   247 

   248 void tst_QMessageService::initTestCase()

   249 {

   250 #if defined(Q_OS_WIN) && !defined(Q_OS_WINCE)

   251     if (!Support::mapiAvailable())

   252         QSKIP("Skipping tests because a MAPI subsystem does not appear to be available", SkipAll);

   253 #endif

   254 

   255     Support::clearMessageStore();

   256 

   257     QMessageManager* manager = new QMessageManager(this);

   258 

   259     existingAccountIds = manager->queryAccounts().toSet();

   260 

   261 

   262     existingAccountsFilter = ~QMessageFilter();

   263     foreach(QMessageAccountId id, existingAccountIds) {

   264         existingAccountsFilter |= QMessageFilter::byParentAccountId(id);

   265     }

   266 

   267     QList<Support::Parameters> accountParams;

   268 

   269     accountParams << Params()("name", "Work")

   270         ("fromAddress", "Important.Person@example.com")

   271         << Params()("name", "Personal")

   272         ("fromAddress", "superstar2000@example.net")

   273         << Params()("name", "Alter Ego")

   274         ("fromAddress", "UltraMegaLightningBabe@superhero.test");

   275 

   276     foreach (const Support::Parameters &params, accountParams) {

   277         accountIds.append(Support::addAccount(params));

   278         QVERIFY(accountIds.last().isValid());

   279     }

   280 

   281     existingFolderIds = manager->queryFolders().toSet();

   282 

   283     QList<Support::Parameters> folderParams;

   284     folderParams << Params()("parentAccountName", "Alter Ego")

   285         ("path", "My messages")

   286         ("name", "My messages")

   287         ("parentFolderPath", "")

   288         << Params()("parentAccountName", "Work")

   289         ("path", "Innbox")

   290         ("name", "Innbox")

   291         ("parentFolderPath", "")

   292 #if !defined(Q_OS_SYMBIAN) && !defined(Q_WS_MAEMO_5) && !defined(Q_WS_MAEMO_6)

   293         << Params()("parentAccountName", "Work")

   294         ("path", "Innbox/X-Announce")

   295         ("name", "X-Announce")

   296         ("parentFolderPath", "Innbox")

   297         << Params()("parentAccountName", "Work")

   298         ("path", "Innbox/X-Announce/X-Archived")

   299         ("name", "X-Archived")

   300         ("parentFolderPath", "Innbox/X-Announce");

   301 #else    

   302     << Params()("parentAccountName", "Work")

   303         ("path", "X-Announce")

   304         ("name", "X-Announce")

   305         ("parentFolderPath", "")

   306         << Params()("parentAccountName", "Work")

   307         ("path", "X-Archived")

   308         ("name", "X-Archived")

   309         ("parentFolderPath", "");

   310 #endif    

   311 

   312     foreach (const Support::Parameters &params, folderParams) {

   313         folderIds.append(Support::addFolder(params));

   314         QVERIFY(folderIds.last().isValid());

   315     }

   316 

   317     existingMessageIds = manager->queryMessages(~existingAccountsFilter).toSet();

   318 

   319     // For windows at least, we can't have HasAttachments set without a real attachment

   320     const char *attachmentPaths = TESTDATA_DIR "/testdata/1.txt";

   321 

   322     QList<Support::Parameters> messageParams;

   323     messageParams << Params()("parentAccountName", "Alter Ego")

   324         ("parentFolderPath", "My messages")

   325 #if (defined(Q_OS_SYMBIAN) || defined(Q_OS_WIN) || defined(Q_WS_MAEMO_5) || defined(Q_WS_MAEMO_6)) // SMS messages must be in SMS store on Windows and on Symbian

   326         ("type", "email")

   327 #else

   328         ("type", "sms")

   329 #endif

   330         ("to", "SuperMegaLightningBabe")

   331         ("from", "Frozone")

   332         ("subject", "Ice to meet you")

   333         ("text", "Shall I compare thee to a summers day")

   334         ("date", "2000-01-01T12:00:00Z")

   335         ("receivedDate", "2000-01-01T12:01:00Z")

   336         ("priority", "")

   337         ("size", "160")

   338         ("status-read", "true")

   339         ("custom-flagged", "true")

   340         << Params()("parentAccountName", "Work")

   341         ("parentFolderPath", "Innbox")

   342         ("type", "email")

   343         ("to", "Important.Person@example.com")

   344         ("from", "Esteemed.Colleague@example.com")

   345         ("subject", "Meeting agenda")

   346         ("date", "2000-01-01T12:00:00Z")

   347         ("receivedDate", "2000-01-01T20:00:00Z")

   348         ("priority", "High")

   349         ("size", "10240")

   350         ("status-hasAttachments", "true")

   351         ("attachments", attachmentPaths)

   352         ("custom-spam", "filter:no")

   353         ("custom-flagged", "true")

   354         << Params()("parentAccountName", "Work")

   355         ("parentFolderPath", "Innbox")

   356         ("type", "email")

   357         ("to", "Important.Person@example.com,Minion@example.com")

   358         ("from", "Big.Boss@example.com")

   359         ("subject", "Motivational message")

   360         ("text", "School's out for summer")

   361         ("date", "2000-01-01T13:00:00Z")

   362         ("receivedDate", "2000-01-01T13:05:00Z")

   363         ("priority", "High")

   364         ("size", "20480")

   365         ("status-hasAttachments", "true")

   366         ("attachments", attachmentPaths)

   367         ("custom-spam", "filter:no")

   368 #if !defined(Q_OS_SYMBIAN) && !defined(Q_WS_MAEMO_5) && !defined(Q_WS_MAEMO_6)

   369         << Params()("parentAccountName", "Work")

   370         ("parentFolderPath", "Innbox/X-Announce")

   371         ("type", "email")

   372         ("to", "announce@example.com,maintenance-log@example.com")

   373         ("from", "sysadmin@example.com")

   374         ("subject", "Scheduled maintenance")

   375         ("date", "2000-01-01T13:00:00Z")

   376         ("receivedDate", "2000-01-01T13:00:01Z")

   377         ("priority", "")

   378         ("size", "1056")

   379         ("status-read", "true")

   380         ("custom-spam", "filter:maybe")

   381         << Params()("parentAccountName", "Work")

   382         ("parentFolderPath", "Innbox/X-Announce/X-Archived")

   383         ("type", "email")

   384         ("to", "announce@example.com")

   385         ("from", "Big.Boss@example.com")

   386         ("subject", "Free beer")

   387         ("date", "1999-04-01T10:30:00Z")

   388         ("receivedDate", "1999-04-01T10:31:00Z")

   389         ("priority", "Low")

   390         ("size", "4096")

   391         ("status-read", "true")

   392         ("status-hasAttachments", "true")

   393         ("attachments", attachmentPaths)

   394         ("custom-spam", "filter:yes");

   395 #else

   396     << Params()("parentAccountName", "Work")

   397         ("parentFolderPath", "X-Announce")

   398         ("type", "email")

   399         ("to", "announce@example.com,maintenance-log@example.com")

   400         ("from", "sysadmin@example.com")

   401         ("subject", "Scheduled maintenance")

   402         ("date", "2000-01-01T13:00:00Z")

   403         ("receivedDate", "2000-01-01T13:00:01Z")

   404         ("priority", "")

   405         ("size", "1056")

   406         ("status-read", "true")

   407         ("custom-spam", "filter:maybe")

   408         << Params()("parentAccountName", "Work")

   409         ("parentFolderPath", "X-Archived")

   410         ("type", "email")

   411         ("to", "announce@example.com")

   412         ("from", "Big.Boss@example.com")

   413         ("subject", "Free beer")

   414         ("date", "1999-04-01T10:30:00Z")

   415         ("receivedDate", "1999-04-01T10:31:00Z")

   416         ("priority", "Low")

   417         ("size", "4096")

   418         ("status-read", "true")

   419         ("status-hasAttachments", "true")

   420         ("attachments", attachmentPaths)

   421         ("custom-spam", "filter:yes");

   422 #endif

   423 

   424     foreach (const Support::Parameters &params, messageParams) {

   425         messageIds.append(Support::addMessage(params));

   426         QVERIFY(messageIds.last().isValid());

   427 

   428         // Use the resultant message sizes in testing - the configured sizes aren't honoured by MAPI

   429         QMessage m(messageIds.last());

   430         messageSizes.append(m.size());

   431     }

   432 }

   433 

   434 void tst_QMessageService::cleanupTestCase()

   435 {

   436 }

   437 

   438 void tst_QMessageService::testQueryMessages()

   439 {

   440     QFETCH(QMessageFilter, filter);

   441     QFETCH(QMessageIdList, ids);

   442     QFETCH(QMessageIdList, negatedIds);

   443     QFETCH(QString, body);

   444 

   445     if (filter.isSupported()) {

   446         QVERIFY(filter == filter);

   447         QCOMPARE(filter != QMessageFilter(), !filter.isEmpty());

   448 

   449         SignalCatcher sc(this);

   450         connect(testService,SIGNAL(messagesFound(const QMessageIdList&)),&sc,SLOT(messagesFound(const QMessageIdList&)));

   451 #if (defined(Q_OS_SYMBIAN) || defined(Q_WS_MAEMO_5) || defined(Q_WS_MAEMO_6))

   452         connect(testService,SIGNAL(stateChanged(QMessageService::State)),&sc,SLOT(stateChanged(QMessageService::State)));

   453 #endif

   454 

   455         // Order is irrelevant for filtering

   456 

   457         if (body.isEmpty()) {

   458             sc.reset();

   459             QCOMPARE(testService->queryMessages(filter&~existingAccountsFilter),true);

   460 #if (defined(Q_OS_SYMBIAN) || defined(Q_WS_MAEMO_5) || defined(Q_WS_MAEMO_6))

   461             QTRY_VERIFY(sc.state == QMessageService::FinishedState);

   462 #else

   463             while(testService->state() == QMessageService::ActiveState)

   464 				QTest::qWait(1000);

   465 #endif

   466             QCOMPARE(sc.ids.toSet().subtract(existingMessageIds),ids.toSet());

   467 

   468             sc.reset();

   469 

   470             QCOMPARE(testService->queryMessages(~filter&~existingAccountsFilter),true);

   471 #if (defined(Q_OS_SYMBIAN) || defined(Q_WS_MAEMO_5) || defined(Q_WS_MAEMO_6))

   472             QTRY_VERIFY(sc.state == QMessageService::FinishedState);

   473 #else

   474             while(testService->state() == QMessageService::ActiveState)

   475                 QTest::qWait(1000);

   476 #endif

   477             QCOMPARE(sc.ids.toSet().subtract(existingMessageIds),negatedIds.toSet());

   478 

   479         } else {

   480 

   481             sc.reset();

   482 

   483             QCOMPARE(testService->queryMessages(filter&~existingAccountsFilter,body),true);

   484 #if (defined(Q_OS_SYMBIAN) || defined(Q_WS_MAEMO_5) || defined(Q_WS_MAEMO_6))

   485             QTRY_VERIFY(sc.state == QMessageService::FinishedState);

   486 #else

   487             while(testService->state() == QMessageService::ActiveState)

   488                 QTest::qWait(1000);

   489 #endif

   490             QCOMPARE(sc.ids.toSet().subtract(existingMessageIds),ids.toSet());

   491 

   492             sc.reset();

   493 

   494             QCOMPARE(testService->queryMessages(~filter&~existingAccountsFilter,body),true);

   495 #if (defined(Q_OS_SYMBIAN) || defined(Q_WS_MAEMO_5) || defined(Q_WS_MAEMO_6))

   496             QTRY_VERIFY(sc.state == QMessageService::FinishedState);

   497 #else

   498             while(testService->state() == QMessageService::ActiveState)

   499                 QTest::qWait(1000);

   500 #endif

   501             QCOMPARE(sc.ids.toSet().subtract(existingMessageIds),negatedIds.toSet());

   502         }

   503     } else {

   504         QSKIP("Unsupported for this configuration", SkipSingle);

   505     }

   506 }

   507 

   508 void tst_QMessageService::testQueryCountData()

   509 {

   510     QTest::addColumn<QMessageFilter>("filter");

   511     QTest::addColumn<QMessageIdList>("ids");

   512     QTest::addColumn<QMessageIdList>("negatedIds");

   513     QTest::addColumn<QString>("body");

   514 

   515 #if !defined(Q_WS_MAEMO_5) && !defined(Q_WS_MAEMO_6)

   516     QTest::newRow("empty filter")

   517         << QMessageFilter() 

   518         << messageIds

   519         << QMessageIdList()

   520         << "";

   521 #endif

   522 

   523     QTest::newRow("id equality 1")

   524         << QMessageFilter::byId(messageIds[0], QMessageDataComparator::Equal) 

   525         << ( QMessageIdList() << messageIds[0] )

   526         << ( QMessageIdList() << messageIds[1] << messageIds[2] << messageIds[3] << messageIds[4] )

   527         << "";

   528 

   529     QTest::newRow("id equality 2")

   530         << QMessageFilter::byId(messageIds[1], QMessageDataComparator::Equal) 

   531         << ( QMessageIdList() << messageIds[1] )

   532         << ( QMessageIdList() << messageIds[0] << messageIds[2] << messageIds[3] << messageIds[4] )

   533         << "";

   534 

   535     QTest::newRow("id equality invalid")

   536         << QMessageFilter::byId(QMessageId(), QMessageDataComparator::Equal) 

   537         << QMessageIdList()

   538         << messageIds

   539         << "";

   540 

   541     QTest::newRow("id inequality 1")

   542         << QMessageFilter::byId(messageIds[0], QMessageDataComparator::NotEqual) 

   543         << ( QMessageIdList() << messageIds[1] << messageIds[2] << messageIds[3] << messageIds[4] )

   544         << ( QMessageIdList() << messageIds[0] )

   545         << "";

   546 

   547     QTest::newRow("id inequality 2")

   548         << QMessageFilter::byId(messageIds[1], QMessageDataComparator::NotEqual) 

   549         << ( QMessageIdList() << messageIds[0] << messageIds[2] << messageIds[3] << messageIds[4] )

   550         << ( QMessageIdList() << messageIds[1] )

   551         << "";

   552 

   553     QTest::newRow("id inequality invalid")

   554         << QMessageFilter::byId(QMessageId(), QMessageDataComparator::NotEqual) 

   555         << messageIds

   556         << QMessageIdList()

   557         << "";

   558 

   559     QTest::newRow("id list inclusion 1")

   560         << QMessageFilter::byId(QMessageIdList() << messageIds[0], QMessageDataComparator::Includes) 

   561         << ( QMessageIdList() << messageIds[0] )

   562         << ( QMessageIdList() << messageIds[1] << messageIds[2] << messageIds[3] << messageIds[4] )

   563         << "";

   564 

   565     QTest::newRow("id list inclusion 2")

   566         << QMessageFilter::byId(QMessageIdList() << messageIds[1], QMessageDataComparator::Includes) 

   567         << ( QMessageIdList() << messageIds[1] )

   568         << ( QMessageIdList() << messageIds[0] << messageIds[2] << messageIds[3] << messageIds[4] )

   569         << "";

   570 

   571     QTest::newRow("id list inclusion 3")

   572         << QMessageFilter::byId(QMessageIdList() << messageIds[0] << messageIds[1], QMessageDataComparator::Includes) 

   573         << ( QMessageIdList() << messageIds[0] << messageIds[1] )

   574         << ( QMessageIdList() << messageIds[2] << messageIds[3] << messageIds[4] )

   575         << "";

   576 

   577 #if !defined(Q_WS_MAEMO_5) && !defined(Q_WS_MAEMO_6)

   578     QTest::newRow("id list inclusion empty")

   579         << QMessageFilter::byId(QMessageIdList(), QMessageDataComparator::Includes) 

   580         << QMessageIdList()

   581         << messageIds

   582         << "";

   583 #endif

   584 

   585     QTest::newRow("id list exclusion 1")

   586         << QMessageFilter::byId(QMessageIdList() << messageIds[0], QMessageDataComparator::Excludes) 

   587         << ( QMessageIdList() << messageIds[1] << messageIds[2] << messageIds[3] << messageIds[4] )

   588         << ( QMessageIdList() << messageIds[0] )

   589         << "";

   590 

   591     QTest::newRow("id list exclusion 2")

   592         << QMessageFilter::byId(QMessageIdList() << messageIds[1], QMessageDataComparator::Excludes) 

   593         << ( QMessageIdList() << messageIds[0] << messageIds[2] << messageIds[3] << messageIds[4] )

   594         << ( QMessageIdList() << messageIds[1] )

   595         << "";

   596 

   597     QTest::newRow("id list exclusion 3")

   598         << QMessageFilter::byId(QMessageIdList() << messageIds[0] << messageIds[1], QMessageDataComparator::Excludes) 

   599         << ( QMessageIdList() << messageIds[2] << messageIds[3] << messageIds[4] )

   600         << ( QMessageIdList() << messageIds[0] << messageIds[1] )

   601         << "";

   602 

   603 #if !defined(Q_WS_MAEMO_5) && !defined(Q_WS_MAEMO_6)

   604     QTest::newRow("id list exclusion empty")

   605         << QMessageFilter::byId(QMessageIdList(), QMessageDataComparator::Excludes) 

   606         << messageIds

   607         << QMessageIdList()

   608         << "";

   609 #endif

   610 

   611 #if !defined(Q_WS_MAEMO_5) && !defined(Q_WS_MAEMO_6)

   612     QTest::newRow("id filter inclusion empty")

   613         << QMessageFilter::byId(QMessageFilter(), QMessageDataComparator::Includes) 

   614         << messageIds

   615         << QMessageIdList()

   616         << "";

   617 

   618     QTest::newRow("id filter inclusion non matching")

   619         << QMessageFilter::byId(~QMessageFilter(), QMessageDataComparator::Includes) 

   620         << QMessageIdList()

   621         << messageIds

   622         << "";

   623 

   624     QTest::newRow("id filter inclusion 1")

   625         << QMessageFilter::byId(QMessageFilter::bySubject("Free beer", QMessageDataComparator::Equal), 

   626                 QMessageDataComparator::Includes)

   627         << ( QMessageIdList() << messageIds[4] )

   628         << ( QMessageIdList() << messageIds[0] << messageIds[1] << messageIds[2] << messageIds[3] )

   629         << "";

   630 #endif

   631 

   632     QTest::newRow("type equality 1")

   633         << QMessageFilter::byType(QMessage::Sms, QMessageDataComparator::Equal) 

   634 #if (defined(Q_OS_SYMBIAN) || defined(Q_OS_WIN) || defined(Q_WS_MAEMO_5) || defined(Q_WS_MAEMO_6))

   635         << QMessageIdList()

   636         << messageIds

   637 #else

   638         << ( QMessageIdList() << messageIds[0] )

   639         << ( QMessageIdList() << messageIds[1] << messageIds[2] << messageIds[3] << messageIds[4] )

   640 #endif

   641         << "";

   642 

   643     QTest::newRow("type equality 2")

   644         << QMessageFilter::byType(QMessage::Email, QMessageDataComparator::Equal) 

   645 #if (defined(Q_OS_SYMBIAN) || defined(Q_OS_WIN) || defined(Q_WS_MAEMO_5) || defined(Q_WS_MAEMO_6))

   646         << messageIds

   647         << QMessageIdList()

   648 #else

   649         << ( QMessageIdList() << messageIds[1] << messageIds[2] << messageIds[3] << messageIds[4] )

   650         << ( QMessageIdList() << messageIds[0] )

   651 #endif

   652         << "";

   653 

   654     QTest::newRow("type equality invalid")

   655         << QMessageFilter::byType(QMessage::NoType, QMessageDataComparator::Equal) 

   656         << QMessageIdList()

   657         << messageIds

   658         << "";

   659 

   660     QTest::newRow("type inequality 1")

   661         << QMessageFilter::byType(QMessage::Sms, QMessageDataComparator::NotEqual) 

   662 #if (defined(Q_OS_SYMBIAN) || defined(Q_OS_WIN) || defined(Q_WS_MAEMO_5) || defined(Q_WS_MAEMO_6))

   663         << messageIds

   664         << QMessageIdList()

   665 #else

   666         << ( QMessageIdList() << messageIds[1] << messageIds[2] << messageIds[3] << messageIds[4] )

   667         << ( QMessageIdList() << messageIds[0] )

   668 #endif

   669         << "";

   670 

   671     QTest::newRow("type inequality 2")

   672         << QMessageFilter::byType(QMessage::Email, QMessageDataComparator::NotEqual) 

   673 #if (defined(Q_OS_SYMBIAN) || defined(Q_OS_WIN) || defined(Q_WS_MAEMO_5) || defined(Q_WS_MAEMO_6))

   674         << QMessageIdList()

   675         << messageIds

   676 #else

   677         << ( QMessageIdList() << messageIds[0] )

   678         << ( QMessageIdList() << messageIds[1] << messageIds[2] << messageIds[3] << messageIds[4] )

   679 #endif

   680         << "";

   681 

   682     QTest::newRow("type inequality invalid")

   683         << QMessageFilter::byType(QMessage::NoType, QMessageDataComparator::NotEqual) 

   684         << messageIds

   685         << QMessageIdList()

   686         << "";

   687 

   688     QTest::newRow("type mask inclusion 1")

   689         << QMessageFilter::byType(QMessage::Sms, QMessageDataComparator::Includes) 

   690 #if (defined(Q_OS_SYMBIAN) || defined(Q_OS_WIN) || defined(Q_WS_MAEMO_5) || defined(Q_WS_MAEMO_6))

   691         << QMessageIdList()

   692         << messageIds

   693 #else

   694         << ( QMessageIdList() << messageIds[0] )

   695         << ( QMessageIdList() << messageIds[1] << messageIds[2] << messageIds[3] << messageIds[4] )

   696 #endif

   697         << "";

   698 

   699     QTest::newRow("type mask inclusion 2")

   700         << QMessageFilter::byType(QMessage::Email, QMessageDataComparator::Includes) 

   701 #if (defined(Q_OS_SYMBIAN) || defined(Q_OS_WIN) || defined(Q_WS_MAEMO_5) || defined(Q_WS_MAEMO_6))

   702         << messageIds

   703         << QMessageIdList()

   704 #else

   705         << ( QMessageIdList() << messageIds[1] << messageIds[2] << messageIds[3] << messageIds[4] )

   706         << ( QMessageIdList() << messageIds[0] )

   707 #endif

   708         << "";

   709 

   710     QTest::newRow("type mask inclusion 3")

   711         << QMessageFilter::byType(QMessage::Sms | QMessage::Email, QMessageDataComparator::Includes) 

   712         << messageIds

   713         << QMessageIdList()

   714         << "";

   715 

   716     QTest::newRow("type mask inclusion empty")

   717         << QMessageFilter::byType(QMessage::NoType, QMessageDataComparator::Includes) 

   718         << QMessageIdList()

   719         << messageIds

   720         << "";

   721 

   722     QTest::newRow("type mask exclusion 1")

   723         << QMessageFilter::byType(QMessage::Sms, QMessageDataComparator::Excludes) 

   724 #if (defined(Q_OS_SYMBIAN) || defined(Q_OS_WIN) || defined(Q_WS_MAEMO_5) || defined(Q_WS_MAEMO_6))

   725         << messageIds

   726         << QMessageIdList()

   727 #else

   728         << ( QMessageIdList() << messageIds[1] << messageIds[2] << messageIds[3] << messageIds[4] )

   729         << ( QMessageIdList() << messageIds[0] )

   730 #endif

   731         << "";

   732 

   733     QTest::newRow("type mask exclusion 2")

   734         << QMessageFilter::byType(QMessage::Email, QMessageDataComparator::Excludes) 

   735 #if (defined(Q_OS_SYMBIAN) || defined(Q_OS_WIN) || defined(Q_WS_MAEMO_5) || defined(Q_WS_MAEMO_6))

   736         << QMessageIdList()

   737         << messageIds

   738 #else

   739         << ( QMessageIdList() << messageIds[0] )

   740         << ( QMessageIdList() << messageIds[1] << messageIds[2] << messageIds[3] << messageIds[4] )

   741 #endif

   742         << "";

   743 

   744     QTest::newRow("type mask exclusion 3")

   745         << QMessageFilter::byType(QMessage::Sms | QMessage::Email, QMessageDataComparator::Excludes) 

   746         << QMessageIdList()

   747         << messageIds

   748         << "";

   749 

   750     QTest::newRow("type mask exclusion empty")

   751         << QMessageFilter::byType(QMessage::NoType, QMessageDataComparator::Excludes) 

   752         << messageIds

   753         << QMessageIdList()

   754         << "";

   755 

   756 #if !defined(Q_WS_MAEMO_5) && !defined(Q_WS_MAEMO_6)

   757     QTest::newRow("sender equality 1")

   758         << QMessageFilter::bySender("Esteemed.Colleague@example.com", QMessageDataComparator::Equal) 

   759         << ( QMessageIdList() << messageIds[1] )

   760         << ( QMessageIdList() << messageIds[0] << messageIds[2] << messageIds[3] << messageIds[4] )

   761         << "";

   762 

   763     QTest::newRow("sender equality 2")

   764         << QMessageFilter::bySender("sysadmin@example.com", QMessageDataComparator::Equal) 

   765         << ( QMessageIdList() << messageIds[3] )

   766         << ( QMessageIdList() << messageIds[0] << messageIds[1] << messageIds[2] << messageIds[4] )

   767         << "";

   768 #endif

   769 

   770     QTest::newRow("sender equality non-matching")

   771         << QMessageFilter::bySender("Nonesuch", QMessageDataComparator::Equal) 

   772         << QMessageIdList()

   773         << messageIds

   774         << "";

   775 

   776     QTest::newRow("sender equality empty")

   777         << QMessageFilter::bySender(QString(), QMessageDataComparator::Equal) 

   778         << QMessageIdList()

   779         << messageIds

   780         << "";

   781 

   782     QTest::newRow("sender equality zero-length")

   783         << QMessageFilter::bySender("", QMessageDataComparator::Equal) 

   784         << QMessageIdList()

   785         << messageIds

   786         << "";

   787 

   788 #if !defined(Q_WS_MAEMO_5) && !defined(Q_WS_MAEMO_6)

   789     QTest::newRow("sender inequality 1")

   790         << QMessageFilter::bySender("Esteemed.Colleague@example.com", QMessageDataComparator::NotEqual) 

   791         << ( QMessageIdList() << messageIds[0] << messageIds[2] << messageIds[3] << messageIds[4] )

   792         << ( QMessageIdList() << messageIds[1] )

   793         << "";

   794 

   795     QTest::newRow("sender inequality 2")

   796         << QMessageFilter::bySender("sysadmin@example.com", QMessageDataComparator::NotEqual) 

   797         << ( QMessageIdList() << messageIds[0] << messageIds[1] << messageIds[2] << messageIds[4] )

   798         << ( QMessageIdList() << messageIds[3] )

   799         << "";

   800 

   801     QTest::newRow("sender inequality non-matching")

   802         << QMessageFilter::bySender("Nonesuch", QMessageDataComparator::NotEqual) 

   803         << messageIds

   804         << QMessageIdList()

   805         << "";

   806 

   807     QTest::newRow("sender inequality empty")

   808         << QMessageFilter::bySender(QString(), QMessageDataComparator::NotEqual) 

   809         << messageIds

   810         << QMessageIdList()

   811         << "";

   812 

   813     QTest::newRow("sender inequality zero-length")

   814         << QMessageFilter::bySender("", QMessageDataComparator::NotEqual) 

   815         << messageIds

   816         << QMessageIdList()

   817         << "";

   818 

   819     QTest::newRow("sender inclusion 1")

   820         << QMessageFilter::bySender("example", QMessageDataComparator::Includes) 

   821         << ( QMessageIdList() << messageIds[1] << messageIds[2] << messageIds[3] << messageIds[4] )

   822         << ( QMessageIdList() << messageIds[0] )

   823         << "";

   824 

   825     QTest::newRow("sender inclusion 2")

   826         << QMessageFilter::bySender("ozone", QMessageDataComparator::Includes) 

   827         << ( QMessageIdList() << messageIds[0] )

   828         << ( QMessageIdList() << messageIds[1] << messageIds[2] << messageIds[3] << messageIds[4] )

   829         << "";

   830 

   831     QTest::newRow("sender inclusion non-matching")

   832         << QMessageFilter::bySender("Nonesuch", QMessageDataComparator::Includes) 

   833         << QMessageIdList()

   834         << messageIds

   835         << "";

   836 

   837     QTest::newRow("sender inclusion empty")

   838         << QMessageFilter::bySender(QString(), QMessageDataComparator::Includes) 

   839         << messageIds

   840         << QMessageIdList()

   841         << "";

   842 

   843     QTest::newRow("sender inclusion zero-length")

   844         << QMessageFilter::bySender("", QMessageDataComparator::Includes) 

   845         << messageIds

   846         << QMessageIdList()

   847         << "";

   848 

   849     QTest::newRow("sender exclusion 1")

   850         << QMessageFilter::bySender("example", QMessageDataComparator::Excludes) 

   851         << ( QMessageIdList() << messageIds[0] )

   852         << ( QMessageIdList() << messageIds[1] << messageIds[2] << messageIds[3] << messageIds[4] )

   853         << "";

   854 

   855     QTest::newRow("sender exclusion 2")

   856         << QMessageFilter::bySender("ozone", QMessageDataComparator::Excludes) 

   857         << ( QMessageIdList() << messageIds[1] << messageIds[2] << messageIds[3] << messageIds[4] )

   858         << ( QMessageIdList() << messageIds[0] )

   859         << "";

   860 

   861     QTest::newRow("sender exclusion non-matching")

   862         << QMessageFilter::bySender("Nonesuch", QMessageDataComparator::Excludes) 

   863         << messageIds

   864         << QMessageIdList()

   865         << "";

   866 

   867     QTest::newRow("sender exclusion empty")

   868         << QMessageFilter::bySender(QString(), QMessageDataComparator::Excludes) 

   869         << QMessageIdList()

   870         << messageIds

   871         << "";

   872 

   873     QTest::newRow("sender exclusion zero-length")

   874         << QMessageFilter::bySender("", QMessageDataComparator::Excludes) 

   875         << QMessageIdList()

   876         << messageIds

   877         << "";

   878 #endif

   879 

   880     QTest::newRow("recipients inclusion 1")

   881         << QMessageFilter::byRecipients("example", QMessageDataComparator::Includes) 

   882         << ( QMessageIdList() << messageIds[1] << messageIds[2] << messageIds[3] << messageIds[4] )

   883         << ( QMessageIdList() << messageIds[0] )

   884         << "";

   885 

   886     QTest::newRow("recipients inclusion 2")

   887         << QMessageFilter::byRecipients("Mega", QMessageDataComparator::Includes) 

   888         << ( QMessageIdList() << messageIds[0] )

   889         << ( QMessageIdList() << messageIds[1] << messageIds[2] << messageIds[3] << messageIds[4] )

   890         << "";

   891 

   892     QTest::newRow("recipients inclusion non-matching")

   893         << QMessageFilter::byRecipients("Nonesuch", QMessageDataComparator::Includes) 

   894         << QMessageIdList()

   895         << messageIds

   896         << "";

   897 

   898     QTest::newRow("recipients inclusion empty")

   899         << QMessageFilter::byRecipients(QString(), QMessageDataComparator::Includes) 

   900         << messageIds

   901         << QMessageIdList()

   902         << "";

   903 

   904     QTest::newRow("recipients inclusion zero-length")

   905         << QMessageFilter::byRecipients("", QMessageDataComparator::Includes) 

   906         << messageIds

   907         << QMessageIdList()

   908         << "";

   909 

   910     QTest::newRow("recipients exclusion 1")

   911         << QMessageFilter::byRecipients("example", QMessageDataComparator::Excludes) 

   912         << ( QMessageIdList() << messageIds[0] )

   913         << ( QMessageIdList() << messageIds[1] << messageIds[2] << messageIds[3] << messageIds[4] )

   914         << "";

   915 

   916     QTest::newRow("recipients exclusion 2")

   917         << QMessageFilter::byRecipients("Mega", QMessageDataComparator::Excludes) 

   918         << ( QMessageIdList() << messageIds[1] << messageIds[2] << messageIds[3] << messageIds[4] )

   919         << ( QMessageIdList() << messageIds[0] )

   920         << "";

   921 

   922     QTest::newRow("recipients exclusion non-matching")

   923         << QMessageFilter::byRecipients("Nonesuch", QMessageDataComparator::Excludes) 

   924         << messageIds

   925         << QMessageIdList()

   926         << "";

   927 

   928     QTest::newRow("recipients exclusion empty")

   929         << QMessageFilter::byRecipients(QString(), QMessageDataComparator::Excludes) 

   930         << QMessageIdList()

   931         << messageIds

   932         << "";

   933 

   934     QTest::newRow("recipients exclusion zero-length")

   935         << QMessageFilter::byRecipients("", QMessageDataComparator::Excludes) 

   936         << QMessageIdList()

   937         << messageIds

   938         << "";

   939 

   940     QTest::newRow("subject equality 1")

   941         << QMessageFilter::bySubject("Free beer", QMessageDataComparator::Equal) 

   942         << ( QMessageIdList() << messageIds[4] )

   943         << ( QMessageIdList() << messageIds[0] << messageIds[1] << messageIds[2] << messageIds[3] )

   944         << "";

   945 

   946     QTest::newRow("subject equality 2")

   947         << QMessageFilter::bySubject("Scheduled maintenance", QMessageDataComparator::Equal) 

   948         << ( QMessageIdList() << messageIds[3] )

   949         << ( QMessageIdList() << messageIds[0] << messageIds[1] << messageIds[2] << messageIds[4] )

   950         << "";

   951 

   952     QTest::newRow("subject equality non-matching")

   953         << QMessageFilter::bySubject("Nonesuch", QMessageDataComparator::Equal) 

   954         << QMessageIdList()

   955         << messageIds

   956         << "";

   957 

   958     QTest::newRow("subject equality empty")

   959         << QMessageFilter::bySubject(QString(), QMessageDataComparator::Equal) 

   960         << QMessageIdList()

   961         << messageIds

   962         << "";

   963 

   964     QTest::newRow("subject equality zero-length")

   965         << QMessageFilter::bySubject("", QMessageDataComparator::Equal) 

   966         << QMessageIdList()

   967         << messageIds

   968         << "";

   969 

   970     QTest::newRow("subject inequality 1")

   971         << QMessageFilter::bySubject("Free beer", QMessageDataComparator::NotEqual) 

   972         << ( QMessageIdList() << messageIds[0] << messageIds[1] << messageIds[2] << messageIds[3] )

   973         << ( QMessageIdList() << messageIds[4] )

   974         << "";

   975 

   976     QTest::newRow("subject inequality 2")

   977         << QMessageFilter::bySubject("Scheduled maintenance", QMessageDataComparator::NotEqual) 

   978         << ( QMessageIdList() << messageIds[0] << messageIds[1] << messageIds[2] << messageIds[4] )

   979         << ( QMessageIdList() << messageIds[3] )

   980         << "";

   981 

   982     QTest::newRow("subject inequality non-matching")

   983         << QMessageFilter::bySubject("Nonesuch", QMessageDataComparator::NotEqual) 

   984         << messageIds

   985         << QMessageIdList()

   986         << "";

   987 

   988     QTest::newRow("subject inequality empty")

   989         << QMessageFilter::bySubject(QString(), QMessageDataComparator::NotEqual) 

   990         << messageIds

   991         << QMessageIdList()

   992         << "";

   993 

   994     QTest::newRow("subject inequality zero-length")

   995         << QMessageFilter::bySubject("", QMessageDataComparator::NotEqual) 

   996         << messageIds

   997         << QMessageIdList()

   998         << "";

   999 

  1000     QTest::newRow("subject inclusion 1")

  1001         << QMessageFilter::bySubject("vation", QMessageDataComparator::Includes) 

  1002         << ( QMessageIdList() << messageIds[2] )

  1003         << ( QMessageIdList() << messageIds[0] << messageIds[1] << messageIds[3] << messageIds[4] )

  1004         << "";

  1005 

  1006     QTest::newRow("subject inclusion 2")

  1007         << QMessageFilter::bySubject(" ", QMessageDataComparator::Includes) 

  1008         << messageIds

  1009         << QMessageIdList()

  1010         << "";

  1011 

  1012     QTest::newRow("subject inclusion non-matching")

  1013         << QMessageFilter::bySubject("Nonesuch", QMessageDataComparator::Includes) 

  1014         << QMessageIdList()

  1015         << messageIds

  1016         << "";

  1017 

  1018     QTest::newRow("subject inclusion empty")

  1019         << QMessageFilter::bySubject(QString(), QMessageDataComparator::Includes) 

  1020         << messageIds

  1021         << QMessageIdList()

  1022         << "";

  1023 

  1024     QTest::newRow("subject inclusion zero-length")

  1025         << QMessageFilter::bySubject("", QMessageDataComparator::Includes) 

  1026         << messageIds

  1027         << QMessageIdList()

  1028         << "";

  1029 

  1030     QTest::newRow("subject exclusion 1")

  1031         << QMessageFilter::bySubject("vation", QMessageDataComparator::Excludes) 

  1032         << ( QMessageIdList() << messageIds[0] << messageIds[1] << messageIds[3] << messageIds[4] )

  1033         << ( QMessageIdList() << messageIds[2] )

  1034         << "";

  1035 

  1036     QTest::newRow("subject exclusion 2")

  1037         << QMessageFilter::bySubject(" ", QMessageDataComparator::Excludes) 

  1038         << QMessageIdList()

  1039         << messageIds

  1040         << "";

  1041 

  1042     QTest::newRow("subject exclusion non-matching")

  1043         << QMessageFilter::bySubject("Nonesuch", QMessageDataComparator::Excludes) 

  1044         << messageIds

  1045         << QMessageIdList()

  1046         << "";

  1047 

  1048     QTest::newRow("subject exclusion empty")

  1049         << QMessageFilter::bySubject(QString(), QMessageDataComparator::Excludes) 

  1050         << QMessageIdList()

  1051         << messageIds

  1052         << "";

  1053 

  1054     QTest::newRow("subject exclusion zero-length")

  1055         << QMessageFilter::bySubject("", QMessageDataComparator::Excludes) 

  1056         << QMessageIdList()

  1057         << messageIds

  1058         << "";

  1059 

  1060 #if !defined(Q_WS_MAEMO_5) && !defined(Q_WS_MAEMO_6)

  1061     QTest::newRow("timeStamp equality 1")

  1062         << QMessageFilter::byTimeStamp(QDateTime::fromString("1999-04-01T10:30:00Z", Qt::ISODate), QMessageDataComparator::Equal) 

  1063         << ( QMessageIdList() << messageIds[4] )

  1064         << ( QMessageIdList() << messageIds[0] << messageIds[1] << messageIds[2] << messageIds[3] )

  1065         << "";

  1066 

  1067     QTest::newRow("timeStamp equality 2")

  1068         << QMessageFilter::byTimeStamp(QDateTime::fromString("2000-01-01T13:00:00Z", Qt::ISODate), QMessageDataComparator::Equal) 

  1069         << ( QMessageIdList() << messageIds[3] << messageIds[2] )

  1070         << ( QMessageIdList() << messageIds[0] << messageIds[1] << messageIds[4] )

  1071         << "";

  1072 

  1073     QTest::newRow("timeStamp equality non-matching")

  1074         << QMessageFilter::byTimeStamp(QDateTime::fromString("1990-01-01T01:00:00Z", Qt::ISODate), QMessageDataComparator::Equal) 

  1075         << QMessageIdList()

  1076         << messageIds

  1077         << "";

  1078 

  1079     QTest::newRow("timeStamp equality empty")

  1080         << QMessageFilter::byTimeStamp(QDateTime(), QMessageDataComparator::Equal) 

  1081         << QMessageIdList()

  1082         << messageIds

  1083         << "";

  1084 

  1085     QTest::newRow("timeStamp inequality 1")

  1086         << QMessageFilter::byTimeStamp(QDateTime::fromString("1999-04-01T10:30:00Z", Qt::ISODate), QMessageDataComparator::NotEqual) 

  1087         << ( QMessageIdList() << messageIds[0] << messageIds[1] << messageIds[2] << messageIds[3] )

  1088         << ( QMessageIdList() << messageIds[4] )

  1089         << "";

  1090 

  1091     QTest::newRow("timeStamp inequality 2")

  1092         << QMessageFilter::byTimeStamp(QDateTime::fromString("2000-01-01T13:00:00Z", Qt::ISODate), QMessageDataComparator::NotEqual) 

  1093         << ( QMessageIdList() << messageIds[0] << messageIds[1] << messageIds[4] )

  1094         << ( QMessageIdList() << messageIds[3] << messageIds[2] )

  1095         << "";

  1096 

  1097     QTest::newRow("timeStamp inequality non-matching")

  1098         << QMessageFilter::byTimeStamp(QDateTime::fromString("1990-01-01T01:00:00Z", Qt::ISODate), QMessageDataComparator::NotEqual) 

  1099         << messageIds

  1100         << QMessageIdList()

  1101         << "";

  1102 

  1103     QTest::newRow("timeStamp inequality empty")

  1104         << QMessageFilter::byTimeStamp(QDateTime(), QMessageDataComparator::NotEqual) 

  1105         << messageIds

  1106         << QMessageIdList()

  1107         << "";

  1108 

  1109     QDateTime epoch(QDateTime::fromString("2000-01-01T12:00:00Z", Qt::ISODate));

  1110 

  1111     QTest::newRow("timeStamp less than")

  1112         << QMessageFilter::byTimeStamp(epoch, QMessageDataComparator::LessThan) 

  1113         << ( QMessageIdList() << messageIds[4] )

  1114         << ( QMessageIdList() << messageIds[0] << messageIds[1] << messageIds[2] << messageIds[3] )

  1115         << "";

  1116 

  1117     QTest::newRow("timeStamp less than equal")

  1118         << QMessageFilter::byTimeStamp(epoch, QMessageDataComparator::LessThanEqual) 

  1119         << ( QMessageIdList() << messageIds[0] << messageIds[1] << messageIds[4] )

  1120         << ( QMessageIdList() << messageIds[2] << messageIds[3] )

  1121         << "";

  1122 

  1123     QTest::newRow("timeStamp greater than")

  1124         << QMessageFilter::byTimeStamp(epoch, QMessageDataComparator::GreaterThan) 

  1125         << ( QMessageIdList() << messageIds[2] << messageIds[3] )

  1126         << ( QMessageIdList() << messageIds[0] << messageIds[1] << messageIds[4] )

  1127         << "";

  1128 

  1129     QTest::newRow("timeStamp greater than equal")

  1130         << QMessageFilter::byTimeStamp(epoch, QMessageDataComparator::GreaterThanEqual) 

  1131         << ( QMessageIdList() << messageIds[0] << messageIds[1] << messageIds[2] << messageIds[3] )

  1132         << ( QMessageIdList() << messageIds[4] )

  1133         << "";

  1134