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

     2 **

     3 ** Copyright (C) 2009 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 "qtmessaging.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 //TESTED_CLASS=

    56 //TESTED_FILES=

    57 

    58 QTM_USE_NAMESPACE

    59 

    60 /*

    61     Unit test for classes implementing query keys for the QMessageStore class.

    62 */

    63 class tst_QMessageStoreKeys : public QObject

    64 {

    65     Q_OBJECT

    66 

    67 public:

    68     tst_QMessageStoreKeys();

    69     virtual ~tst_QMessageStoreKeys();

    70 

    71 private slots:

    72     void init();

    73     void initTestCase();

    74     void cleanup();

    75     void cleanupTestCase();

    76 

    77     void testAccountFilter_data();

    78     void testAccountFilter();

    79 

    80     void testAccountOrdering_data();

    81     void testAccountOrdering();

    82 

    83     void testFolderFilter_data();

    84     void testFolderFilter();

    85 

    86     void testFolderOrdering_data();

    87     void testFolderOrdering();

    88 

    89     void testMessageFilter_data();

    90     void testMessageFilter();

    91 

    92     void testMessageOrdering_data();

    93     void testMessageOrdering();

    94 

    95 private:

    96     QSet<QMessageAccountId> existingAccountIds;

    97     QMessageAccountIdList accountIds;

    98 

    99     QSet<QMessageFolderId> existingFolderIds;

   100     QMessageFolderIdList folderIds;

   101 

   102     QSet<QMessageId> existingMessageIds;

   103     QMessageFilter existingAccountsFilter;

   104     QMessageIdList messageIds;

   105 

   106     QList<int> messageSizes;

   107 

   108     QMessageManager *manager;

   109 };

   110 

   111 Q_DECLARE_METATYPE(QMessageAccountIdList)

   112 Q_DECLARE_METATYPE(QMessageAccountFilter)

   113 Q_DECLARE_METATYPE(QMessageAccountSortOrder)

   114 

   115 Q_DECLARE_METATYPE(QMessageFolderIdList)

   116 Q_DECLARE_METATYPE(QMessageFolderFilter)

   117 Q_DECLARE_METATYPE(QMessageFolderSortOrder)

   118 

   119 typedef QList<QMessageFolderSortOrder> FolderSortList;

   120 Q_DECLARE_METATYPE(FolderSortList)

   121 

   122 Q_DECLARE_METATYPE(QMessageIdList)

   123 Q_DECLARE_METATYPE(QMessageFilter)

   124 Q_DECLARE_METATYPE(QMessageSortOrder)

   125 

   126 typedef QList<QMessageSortOrder> MessageSortList;

   127 Q_DECLARE_METATYPE(MessageSortList)

   128 

   129 typedef QList<QMessageIdList> MessageListList;

   130 Q_DECLARE_METATYPE(MessageListList)

   131 

   132 QDebug &operator<<(QDebug &dbg, const QMessageAccountId &id)

   133 {

   134     return dbg << id.toString();

   135 }

   136 

   137 QDebug &operator<<(QDebug &dbg, const QMessageFolderId &id)

   138 {

   139     return dbg << id.toString();

   140 }

   141 

   142 QDebug &operator<<(QDebug &dbg, const QMessageId &id)

   143 {

   144     return dbg << id.toString();

   145 }

   146 

   147 QTEST_MAIN(tst_QMessageStoreKeys)

   148 

   149 #include "tst_qmessagestorekeys.moc"

   150 

   151 tst_QMessageStoreKeys::tst_QMessageStoreKeys()

   152     : manager(0)

   153 {

   154 }

   155 

   156 tst_QMessageStoreKeys::~tst_QMessageStoreKeys()

   157 {

   158     delete manager;

   159 }

   160 

   161 class Params

   162 {

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

   164 

   165 public:

   166     Params() {}

   167 

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

   169     {

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

   171     }

   172 

   173     operator Support::Parameters() const

   174     {

   175         Support::Parameters result;

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

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

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

   179         }

   180         return result;

   181     }

   182 };

   183 

   184 void tst_QMessageStoreKeys::init()

   185 {

   186 }

   187 

   188 void tst_QMessageStoreKeys::initTestCase()

   189 {

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

   191     if (!Support::mapiAvailable())

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

   193 #endif

   194 

   195     // Clear any existing data before we instantiate the message manager

   196     Support::clearMessageStore();

   197 

   198     manager = new QMessageManager;

   199 

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

   201     existingAccountsFilter = ~QMessageFilter();

   202     foreach(QMessageAccountId id, existingAccountIds) {

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

   204     }

   205 

   206     QList<Support::Parameters> accountParams;

   207 

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

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

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

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

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

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

   214 

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

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

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

   218     }

   219 

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

   221 

   222     QList<Support::Parameters> folderParams;

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

   224                             ("path", "My messages")

   225                             ("name", "My messages")

   226                             ("parentFolderPath", "")

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

   228                             ("path", "Innbox")

   229                             ("name", "Innbox")

   230                             ("parentFolderPath", "")

   231 #ifndef Q_OS_SYMBIAN

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

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

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

   235                             ("parentFolderPath", "Innbox")

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

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

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

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

   240 #else    

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

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

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

   244                             ("parentFolderPath", "")

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

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

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

   248                             ("parentFolderPath", "");

   249 #endif    

   250 

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

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

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

   254     }

   255 

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

   257 

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

   259 #ifndef Q_OS_SYMBIAN

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

   261 #else

   262     const char *attachmentPaths = TESTDATA_DIR "\\testdata\\1.txt";

   263 #endif

   264 

   265     QList<Support::Parameters> messageParams;

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

   267                              ("parentFolderPath", "My messages")

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

   269                              ("type", "email")

   270 #else

   271                              ("type", "sms")

   272 #endif

   273                              ("to", "SuperMegaLightningBabe")

   274                              ("from", "Frozone")

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

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

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

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

   279                              ("priority", "")

   280                              ("size", "160")

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

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

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

   284                              ("parentFolderPath", "Innbox")

   285                              ("type", "email")

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

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

   288                              ("subject", "Meeting agenda")

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

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

   291                              ("priority", "High")

   292                              ("size", "10240")

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

   294                              ("attachments", attachmentPaths)

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

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

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

   298                              ("parentFolderPath", "Innbox")

   299                              ("type", "email")

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

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

   302                              ("subject", "Motivational message")

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

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

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

   306                              ("priority", "High")

   307                              ("size", "20480")

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

   309                              ("attachments", attachmentPaths)

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

   311 #ifndef Q_OS_SYMBIAN                             

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

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

   314                              ("type", "email")

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

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

   317                              ("subject", "Scheduled maintenance")

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

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

   320                              ("priority", "")

   321                              ("size", "1056")

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

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

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

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

   326                              ("type", "email")

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

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

   329                              ("subject", "Free beer")

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

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

   332                              ("priority", "Low")

   333                              ("size", "4096")

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

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

   336                              ("attachments", attachmentPaths)

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

   338 #else

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

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

   341                              ("type", "email")

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

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

   344                              ("subject", "Scheduled maintenance")

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

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

   347                              ("priority", "")

   348                              ("size", "1056")

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

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

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

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

   353                              ("type", "email")

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

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

   356                              ("subject", "Free beer")

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

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

   359                              ("priority", "Low")

   360                              ("size", "4096")

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

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

   363                              ("attachments", attachmentPaths)

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

   365 #endif

   366 

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

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

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

   370 

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

   372         QMessage m(messageIds.last());

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

   374     }

   375 }

   376 

   377 void tst_QMessageStoreKeys::cleanup()

   378 {

   379 }

   380 

   381 void tst_QMessageStoreKeys::cleanupTestCase()

   382 {

   383 }

   384 

   385 void tst_QMessageStoreKeys::testAccountFilter_data()

   386 {

   387     QTest::addColumn<QMessageAccountFilter>("filter");

   388     QTest::addColumn<QMessageAccountIdList>("ids");

   389     QTest::addColumn<QMessageAccountIdList>("negatedIds");

   390 

   391     QTest::newRow("empty filter")

   392         << QMessageAccountFilter() 

   393         << accountIds

   394         << QMessageAccountIdList();

   395 

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

   397         << QMessageAccountFilter::byId(accountIds[0], QMessageDataComparator::Equal) 

   398         << ( QMessageAccountIdList() << accountIds[0] )

   399         << ( QMessageAccountIdList() << accountIds[1] << accountIds[2] );

   400 

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

   402         << QMessageAccountFilter::byId(accountIds[1], QMessageDataComparator::Equal) 

   403         << ( QMessageAccountIdList() << accountIds[1] )

   404         << ( QMessageAccountIdList() << accountIds[0] << accountIds[2] );

   405 

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

   407         << QMessageAccountFilter::byId(QMessageAccountId(), QMessageDataComparator::Equal) 

   408         << QMessageAccountIdList()

   409         << accountIds;

   410 

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

   412         << QMessageAccountFilter::byId(accountIds[0], QMessageDataComparator::NotEqual) 

   413         << ( QMessageAccountIdList() << accountIds[1] << accountIds[2] )

   414         << ( QMessageAccountIdList() << accountIds[0] );

   415 

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

   417         << QMessageAccountFilter::byId(accountIds[1], QMessageDataComparator::NotEqual) 

   418         << ( QMessageAccountIdList() << accountIds[0] << accountIds[2] )

   419         << ( QMessageAccountIdList() << accountIds[1] );

   420 

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

   422         << QMessageAccountFilter::byId(QMessageAccountId(), QMessageDataComparator::NotEqual) 

   423         << accountIds

   424         << QMessageAccountIdList();

   425 

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

   427         << QMessageAccountFilter::byId(QMessageAccountIdList() << accountIds[0], QMessageDataComparator::Includes) 

   428         << ( QMessageAccountIdList() << accountIds[0] )

   429         << ( QMessageAccountIdList() << accountIds[1] << accountIds[2] );

   430 

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

   432         << QMessageAccountFilter::byId(QMessageAccountIdList() << accountIds[1], QMessageDataComparator::Includes) 

   433         << ( QMessageAccountIdList() << accountIds[1] )

   434         << ( QMessageAccountIdList() << accountIds[0] << accountIds[2] );

   435 

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

   437         << QMessageAccountFilter::byId(QMessageAccountIdList() << accountIds[0] << accountIds[1], QMessageDataComparator::Includes) 

   438         << ( QMessageAccountIdList() << accountIds[0] << accountIds[1] )

   439         << ( QMessageAccountIdList() << accountIds[2] );

   440 

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

   442         << QMessageAccountFilter::byId(QMessageAccountIdList(), QMessageDataComparator::Includes) 

   443         << QMessageAccountIdList()

   444         << accountIds;

   445 

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

   447         << QMessageAccountFilter::byId(QMessageAccountIdList() << accountIds[0], QMessageDataComparator::Excludes) 

   448         << ( QMessageAccountIdList() << accountIds[1] << accountIds[2] )

   449         << ( QMessageAccountIdList() << accountIds[0] );

   450 

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

   452         << QMessageAccountFilter::byId(QMessageAccountIdList() << accountIds[1], QMessageDataComparator::Excludes) 

   453         << ( QMessageAccountIdList() << accountIds[0] << accountIds[2] )

   454         << ( QMessageAccountIdList() << accountIds[1] );

   455 

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

   457         << QMessageAccountFilter::byId(QMessageAccountIdList() << accountIds[0] << accountIds[1], QMessageDataComparator::Excludes) 

   458         << ( QMessageAccountIdList() << accountIds[2] )

   459         << ( QMessageAccountIdList() << accountIds[0] << accountIds[1] );

   460 

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

   462         << QMessageAccountFilter::byId(QMessageAccountIdList(), QMessageDataComparator::Excludes) 

   463         << accountIds

   464         << QMessageAccountIdList();

   465 

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

   467         << QMessageAccountFilter::byId(QMessageAccountFilter::byName("Work", QMessageDataComparator::Equal), QMessageDataComparator::Includes) 

   468         << ( QMessageAccountIdList() << accountIds[0] )

   469         << ( QMessageAccountIdList() << accountIds[1] << accountIds[2] );

   470 

   471     QTest::newRow("id filter inclusion 2")

   472         << QMessageAccountFilter::byId(QMessageAccountFilter::byName("Personal", QMessageDataComparator::Equal), QMessageDataComparator::Includes) 

   473         << ( QMessageAccountIdList() << accountIds[1] )

   474         << ( QMessageAccountIdList() << accountIds[0] << accountIds[2] );

   475 

   476     QTest::newRow("id filter inclusion 3")

   477         << QMessageAccountFilter::byId(QMessageAccountFilter::byName("o", QMessageDataComparator::Includes), QMessageDataComparator::Includes) 

   478         << accountIds

   479         << QMessageAccountIdList();

   480 

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

   482         << QMessageAccountFilter::byId(QMessageAccountFilter(), QMessageDataComparator::Includes) 

   483         << accountIds

   484         << QMessageAccountIdList();

   485 

   486     QTest::newRow("id filter inclusion non-matching")

   487         << QMessageAccountFilter::byId(QMessageAccountFilter::byName("NoneSuch"), QMessageDataComparator::Includes) 

   488         << QMessageAccountIdList()

   489         << accountIds;

   490 

   491     QTest::newRow("id filter exclusion 1")

   492         << QMessageAccountFilter::byId(QMessageAccountFilter::byName("Work", QMessageDataComparator::Equal), QMessageDataComparator::Excludes) 

   493         << ( QMessageAccountIdList() << accountIds[1] << accountIds[2] )

   494         << ( QMessageAccountIdList() << accountIds[0] );

   495 

   496     QTest::newRow("id filter exclusion 2")

   497         << QMessageAccountFilter::byId(QMessageAccountFilter::byName("Personal", QMessageDataComparator::Equal), QMessageDataComparator::Excludes) 

   498         << ( QMessageAccountIdList() << accountIds[0] << accountIds[2] )

   499         << ( QMessageAccountIdList() << accountIds[1] );

   500 

   501     QTest::newRow("id filter exclusion 3")

   502         << QMessageAccountFilter::byId(QMessageAccountFilter::byName("o", QMessageDataComparator::Includes), QMessageDataComparator::Excludes) 

   503         << QMessageAccountIdList()

   504         << accountIds;

   505 

   506     QTest::newRow("id filter exclusion empty")

   507         << QMessageAccountFilter::byId(QMessageAccountFilter(), QMessageDataComparator::Excludes) 

   508         << QMessageAccountIdList()

   509         << accountIds;

   510 

   511     QTest::newRow("id filter exclusion non-matching")

   512         << QMessageAccountFilter::byId(QMessageAccountFilter::byName("NoneSuch"), QMessageDataComparator::Excludes) 

   513         << accountIds

   514         << QMessageAccountIdList();

   515 

   516     QTest::newRow("name equality 1")

   517         << QMessageAccountFilter::byName("Work", QMessageDataComparator::Equal) 

   518         << ( QMessageAccountIdList() << accountIds[0] )

   519         << ( QMessageAccountIdList() << accountIds[1] << accountIds[2] );

   520 

   521     QTest::newRow("name equality 2")

   522         << QMessageAccountFilter::byName("Personal", QMessageDataComparator::Equal) 

   523         << ( QMessageAccountIdList() << accountIds[1] )

   524         << ( QMessageAccountIdList() << accountIds[0] << accountIds[2] );

   525 

   526     QTest::newRow("name equality non-matching")

   527         << QMessageAccountFilter::byName("Nonesuch", QMessageDataComparator::Equal) 

   528         << QMessageAccountIdList()

   529         << accountIds;

   530 

   531     QTest::newRow("name equality empty")

   532         << QMessageAccountFilter::byName(QString(), QMessageDataComparator::Equal) 

   533         << QMessageAccountIdList()

   534         << accountIds;

   535 

   536     QTest::newRow("name equality zero-length")

   537         << QMessageAccountFilter::byName("", QMessageDataComparator::Equal) 

   538         << QMessageAccountIdList()

   539         << accountIds;

   540 

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

   542         << QMessageAccountFilter::byName("Work", QMessageDataComparator::NotEqual) 

   543         << ( QMessageAccountIdList() << accountIds[1] << accountIds[2] )

   544         << ( QMessageAccountIdList() << accountIds[0] );

   545 

   546     QTest::newRow("name inequality 2")

   547         << QMessageAccountFilter::byName("Personal", QMessageDataComparator::NotEqual) 

   548         << ( QMessageAccountIdList() << accountIds[0] << accountIds[2] )

   549         << ( QMessageAccountIdList() << accountIds[1] );

   550 

   551     QTest::newRow("name inequality non-matching")

   552         << QMessageAccountFilter::byName("Nonesuch", QMessageDataComparator::NotEqual) 

   553         << accountIds

   554         << QMessageAccountIdList();

   555 

   556     QTest::newRow("name inequality empty")

   557         << QMessageAccountFilter::byName(QString(), QMessageDataComparator::NotEqual) 

   558         << accountIds

   559         << QMessageAccountIdList();

   560 

   561     QTest::newRow("name inequality zero-length")

   562         << QMessageAccountFilter::byName("", QMessageDataComparator::NotEqual) 

   563         << accountIds

   564         << QMessageAccountIdList();

   565 

   566     QTest::newRow("name inclusion 1")

   567         << QMessageAccountFilter::byName("ork", QMessageDataComparator::Includes) 

   568         << ( QMessageAccountIdList() << accountIds[0] )

   569         << ( QMessageAccountIdList() << accountIds[1] << accountIds[2] );

   570 

   571     QTest::newRow("name inclusion 2")

   572         << QMessageAccountFilter::byName("o", QMessageDataComparator::Includes) 

   573         << accountIds

   574         << QMessageAccountIdList();

   575 

   576     QTest::newRow("name inclusion non-matching")

   577         << QMessageAccountFilter::byName("Nonesuch", QMessageDataComparator::Includes) 

   578         << QMessageAccountIdList()

   579         << accountIds;

   580 

   581     QTest::newRow("name inclusion empty")

   582         << QMessageAccountFilter::byName(QString(), QMessageDataComparator::Includes) 

   583         << accountIds

   584         << QMessageAccountIdList();

   585 

   586     QTest::newRow("name inclusion zero-length")

   587         << QMessageAccountFilter::byName("", QMessageDataComparator::Includes) 

   588         << accountIds

   589         << QMessageAccountIdList();

   590 

   591     QTest::newRow("name exclusion 1")

   592         << QMessageAccountFilter::byName("ork", QMessageDataComparator::Excludes) 

   593         << ( QMessageAccountIdList() << accountIds[1] << accountIds[2] )

   594         << ( QMessageAccountIdList() << accountIds[0] );

   595 

   596     QTest::newRow("name exclusion 2")

   597         << QMessageAccountFilter::byName("o", QMessageDataComparator::Excludes) 

   598         << QMessageAccountIdList()

   599         << accountIds;

   600 

   601     QTest::newRow("name exclusion non-matching")

   602         << QMessageAccountFilter::byName("Nonesuch", QMessageDataComparator::Excludes) 

   603         << accountIds

   604         << QMessageAccountIdList();

   605 

   606     QTest::newRow("name exclusion empty")

   607         << QMessageAccountFilter::byName(QString(), QMessageDataComparator::Excludes) 

   608         << QMessageAccountIdList()

   609         << accountIds;

   610 

   611     QTest::newRow("name exclusion zero-length")

   612         << QMessageAccountFilter::byName("", QMessageDataComparator::Excludes) 

   613         << QMessageAccountIdList()

   614         << accountIds;

   615 

   616     // Test some basic combinations

   617     QTest::newRow("id inequality AND name equality")

   618         << ( QMessageAccountFilter::byId(accountIds[0], QMessageDataComparator::NotEqual) &

   619              QMessageAccountFilter::byName("Personal", QMessageDataComparator::Equal) )

   620         << ( QMessageAccountIdList() << accountIds[1] )

   621         << ( QMessageAccountIdList() << accountIds[0] << accountIds[2] );

   622 

   623     QTest::newRow("id equality OR name inequality")

   624         << ( QMessageAccountFilter::byId(accountIds[0], QMessageDataComparator::Equal) |

   625              QMessageAccountFilter::byName("Personal", QMessageDataComparator::NotEqual) )

   626         << ( QMessageAccountIdList() << accountIds[0] << accountIds[2] )

   627         << ( QMessageAccountIdList() << accountIds[1] );

   628 

   629     QMessageAccountFilter andEquals(QMessageAccountFilter::byId(accountIds[0], QMessageDataComparator::NotEqual));

   630     andEquals &= QMessageAccountFilter::byName("Personal", QMessageDataComparator::Equal);

   631     QTest::newRow("id inequality AND name equality")

   632         << andEquals

   633         << ( QMessageAccountIdList() << accountIds[1] )

   634         << ( QMessageAccountIdList() << accountIds[0] << accountIds[2] );

   635 

   636     QMessageAccountFilter orEquals(QMessageAccountFilter::byId(accountIds[0], QMessageDataComparator::Equal));

   637     orEquals |= QMessageAccountFilter::byName("Personal", QMessageDataComparator::NotEqual);

   638     QTest::newRow("id equality OR name inequality")

   639         << orEquals

   640         << ( QMessageAccountIdList() << accountIds[0] << accountIds[2] )

   641         << ( QMessageAccountIdList() << accountIds[1] );

   642 

   643     // Test matchFlags

   644     QMessageAccountFilter caseInsensitive1(QMessageAccountFilter::byName("work", QMessageDataComparator::Equal));

   645     QTest::newRow("matchFlags:caseInsensitive 1")

   646         << caseInsensitive1

   647         << ( QMessageAccountIdList() << accountIds[0] )

   648         << ( QMessageAccountIdList() << accountIds[1] << accountIds[2] );

   649 

   650     QMessageAccountFilter caseSensitive1(QMessageAccountFilter::byName("work", QMessageDataComparator::Equal));

   651     caseSensitive1.setMatchFlags(QMessageDataComparator::MatchCaseSensitive);

   652     QTest::newRow("matchFlags:caseSensitive 1")

   653         << caseSensitive1

   654         << QMessageAccountIdList()

   655         << accountIds;

   656 

   657     QMessageAccountFilter caseSensitive2(QMessageAccountFilter::byName("Work", QMessageDataComparator::Equal));

   658     caseSensitive2.setMatchFlags(QMessageDataComparator::MatchCaseSensitive);

   659     QTest::newRow("matchFlags:caseSensitive 2")

   660         << caseSensitive2

   661         << ( QMessageAccountIdList() << accountIds[0] )

   662         << ( QMessageAccountIdList() << accountIds[1] << accountIds[2] );

   663 }

   664 

   665 void tst_QMessageStoreKeys::testAccountFilter()

   666 {

   667     QFETCH(QMessageAccountFilter, filter);

   668     QFETCH(QMessageAccountIdList, ids);

   669     QFETCH(QMessageAccountIdList, negatedIds);

   670 

   671     if (filter.isSupported()) {

   672         QVERIFY(filter == filter);

   673         QCOMPARE(filter != QMessageAccountFilter(), !filter.isEmpty());

   674 

   675         // Order is irrelevant for filtering

   676         QCOMPARE(manager->queryAccounts(filter).toSet().subtract(existingAccountIds), ids.toSet());

   677         QCOMPARE(manager->queryAccounts(~filter).toSet().subtract(existingAccountIds), negatedIds.toSet());

   678     } else {

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

   680     }

   681 }

   682 

   683 void tst_QMessageStoreKeys::testAccountOrdering_data()

   684 {

   685     QTest::addColumn<QMessageAccountSortOrder>("sortOrder");

   686     QTest::addColumn<QMessageAccountIdList>("ids");

   687 

   688     QTest::newRow("name ascending")

   689         << QMessageAccountSortOrder::byName(Qt::AscendingOrder)

   690         << ( QMessageAccountIdList() << accountIds[2] << accountIds[1] << accountIds[0] );

   691 

   692     QTest::newRow("name descending")

   693         << QMessageAccountSortOrder::byName(Qt::DescendingOrder)

   694         << ( QMessageAccountIdList() << accountIds[0] << accountIds[1] << accountIds[2] );

   695 }

   696 

   697 void tst_QMessageStoreKeys::testAccountOrdering()

   698 {

   699     QFETCH(QMessageAccountSortOrder, sortOrder);

   700     QFETCH(QMessageAccountIdList, ids);

   701 

   702     if (sortOrder.isSupported()) {

   703         QVERIFY(sortOrder == sortOrder);

   704         QCOMPARE(sortOrder != QMessageAccountSortOrder(), !sortOrder.isEmpty());

   705 

   706         // Filter out the existing accounts

   707         QMessageAccountIdList sortedIds(manager->queryAccounts(QMessageAccountFilter(), sortOrder));

   708         for (QMessageAccountIdList::iterator it = sortedIds.begin(); it != sortedIds.end(); ) {

   709             if (existingAccountIds.contains(*it)) {

   710                 it = sortedIds.erase(it);

   711             } else {

   712                 ++it;

   713             }

   714         }

   715 

   716         QCOMPARE(sortedIds, ids);

   717     } else {

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

   719     }

   720 }

   721 

   722 void tst_QMessageStoreKeys::testFolderFilter_data()

   723 {

   724     QTest::addColumn<QMessageFolderFilter>("filter");

   725     QTest::addColumn<QMessageFolderIdList>("ids");

   726     QTest::addColumn<QMessageFolderIdList>("negatedIds");

   727 

   728     QTest::newRow("empty filter")

   729         << QMessageFolderFilter() 

   730         << folderIds

   731         << QMessageFolderIdList();

   732 

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

   734         << QMessageFolderFilter::byId(folderIds[0], QMessageDataComparator::Equal) 

   735         << ( QMessageFolderIdList() << folderIds[0] )

   736         << ( QMessageFolderIdList() << folderIds[1] << folderIds[2] << folderIds[3] );

   737 

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

   739         << QMessageFolderFilter::byId(folderIds[1], QMessageDataComparator::Equal) 

   740         << ( QMessageFolderIdList() << folderIds[1] )

   741         << ( QMessageFolderIdList() << folderIds[0] << folderIds[2] << folderIds[3] );

   742 

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

   744         << QMessageFolderFilter::byId(QMessageFolderId(), QMessageDataComparator::Equal) 

   745         << QMessageFolderIdList()

   746         << folderIds;

   747 

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

   749         << QMessageFolderFilter::byId(folderIds[0], QMessageDataComparator::NotEqual) 

   750         << ( QMessageFolderIdList() << folderIds[1] << folderIds[2] << folderIds[3] )

   751         << ( QMessageFolderIdList() << folderIds[0] );

   752 

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

   754         << QMessageFolderFilter::byId(folderIds[1], QMessageDataComparator::NotEqual) 

   755         << ( QMessageFolderIdList() << folderIds[0] << folderIds[2] << folderIds[3] )

   756         << ( QMessageFolderIdList() << folderIds[1] );

   757 

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

   759         << QMessageFolderFilter::byId(QMessageFolderId(), QMessageDataComparator::NotEqual) 

   760         << folderIds

   761         << QMessageFolderIdList();

   762 

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

   764         << QMessageFolderFilter::byId(QMessageFolderIdList() << folderIds[0], QMessageDataComparator::Includes) 

   765         << ( QMessageFolderIdList() << folderIds[0] )

   766         << ( QMessageFolderIdList() << folderIds[1] << folderIds[2] << folderIds[3] );

   767 

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

   769         << QMessageFolderFilter::byId(QMessageFolderIdList() << folderIds[1], QMessageDataComparator::Includes) 

   770         << ( QMessageFolderIdList() << folderIds[1] )

   771         << ( QMessageFolderIdList() << folderIds[0] << folderIds[2] << folderIds[3] );

   772 

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

   774         << QMessageFolderFilter::byId(QMessageFolderIdList() << folderIds[0] << folderIds[1], QMessageDataComparator::Includes) 

   775         << ( QMessageFolderIdList() << folderIds[0] << folderIds[1] )

   776         << ( QMessageFolderIdList() << folderIds[2] << folderIds[3] );

   777 

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

   779         << QMessageFolderFilter::byId(QMessageFolderIdList(), QMessageDataComparator::Includes) 

   780         << QMessageFolderIdList()

   781         << folderIds;

   782 

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

   784         << QMessageFolderFilter::byId(QMessageFolderIdList() << folderIds[0], QMessageDataComparator::Excludes) 

   785         << ( QMessageFolderIdList() << folderIds[1] << folderIds[2] << folderIds[3] )

   786         << ( QMessageFolderIdList() << folderIds[0] );

   787 

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

   789         << QMessageFolderFilter::byId(QMessageFolderIdList() << folderIds[1], QMessageDataComparator::Excludes) 

   790         << ( QMessageFolderIdList() << folderIds[0] << folderIds[2] << folderIds[3] )

   791         << ( QMessageFolderIdList() << folderIds[1] );

   792 

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

   794         << QMessageFolderFilter::byId(QMessageFolderIdList() << folderIds[0] << folderIds[1], QMessageDataComparator::Excludes) 

   795         << ( QMessageFolderIdList() << folderIds[2] << folderIds[3] )

   796         << ( QMessageFolderIdList() << folderIds[0] << folderIds[1] );

   797 

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

   799         << QMessageFolderFilter::byId(QMessageFolderIdList(), QMessageDataComparator::Excludes) 

   800         << folderIds

   801         << QMessageFolderIdList();

   802 

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

   804         << QMessageFolderFilter::byId(QMessageFolderFilter::byPath("My messages", QMessageDataComparator::Equal), QMessageDataComparator::Includes)

   805         << ( QMessageFolderIdList() << folderIds[0] )

   806         << ( QMessageFolderIdList() << folderIds[1] << folderIds[2] << folderIds[3] );

   807 

   808 #ifndef Q_OS_SYMBIAN    

   809     QTest::newRow("id filter inclusion 2")

   810         << QMessageFolderFilter::byId(QMessageFolderFilter::byPath("Innbox/X-Announce", QMessageDataComparator::Equal), QMessageDataComparator::Includes)

   811         << ( QMessageFolderIdList() << folderIds[2] )

   812         << ( QMessageFolderIdList() << folderIds[0] << folderIds[1] << folderIds[3] );

   813 

   814     QTest::newRow("id filter inclusion 3")

   815         << QMessageFolderFilter::byId(QMessageFolderFilter::byPath("box/X-Ann", QMessageDataComparator::Includes), QMessageDataComparator::Includes)

   816         << ( QMessageFolderIdList() << folderIds[2] << folderIds[3] )

   817         << ( QMessageFolderIdList() << folderIds[0] << folderIds[1] );

   818 #endif    

   819 

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

   821         << QMessageFolderFilter::byId(QMessageFolderFilter(), QMessageDataComparator::Includes) 

   822         << folderIds

   823         << QMessageFolderIdList();

   824 

   825     QTest::newRow("id filter inclusion non-matching")

   826         << QMessageFolderFilter::byId(QMessageFolderFilter::byPath("NoneSuch"), QMessageDataComparator::Includes) 

   827         << QMessageFolderIdList()

   828         << folderIds;

   829 

   830     QTest::newRow("id filter exclusion 1")

   831         << QMessageFolderFilter::byId(QMessageFolderFilter::byPath("My messages", QMessageDataComparator::Equal), QMessageDataComparator::Excludes)

   832         << ( QMessageFolderIdList() << folderIds[1] << folderIds[2] << folderIds[3] )

   833         << ( QMessageFolderIdList() << folderIds[0] );

   834 

   835 #ifndef Q_OS_SYMBIAN    

   836     QTest::newRow("id filter exclusion 2")

   837         << QMessageFolderFilter::byId(QMessageFolderFilter::byPath("Innbox/X-Announce", QMessageDataComparator::Equal), QMessageDataComparator::Excludes)

   838         << ( QMessageFolderIdList() << folderIds[0] << folderIds[1] << folderIds[3] )

   839         << ( QMessageFolderIdList() << folderIds[2] );

   840 

   841     QTest::newRow("id filter exclusion 3")

   842         << QMessageFolderFilter::byId(QMessageFolderFilter::byPath("box/X-Ann", QMessageDataComparator::Includes), QMessageDataComparator::Excludes)

   843         << ( QMessageFolderIdList() << folderIds[0] << folderIds[1] )

   844         << ( QMessageFolderIdList() << folderIds[2] << folderIds[3] );

   845 #endif    

   846 

   847     QTest::newRow("id filter exclusion empty")

   848         << QMessageFolderFilter::byId(QMessageFolderFilter(), QMessageDataComparator::Excludes) 

   849         << QMessageFolderIdList()

   850         << folderIds;

   851 

   852     QTest::newRow("id filter exclusion non-matching")

   853         << QMessageFolderFilter::byId(QMessageFolderFilter::byPath("NoneSuch"), QMessageDataComparator::Excludes) 

   854         << folderIds

   855         << QMessageFolderIdList();

   856 

   857     QTest::newRow("path equality 1")

   858         << QMessageFolderFilter::byPath("My messages", QMessageDataComparator::Equal)

   859         << ( QMessageFolderIdList() << folderIds[0] )

   860         << ( QMessageFolderIdList() << folderIds[1] << folderIds[2] << folderIds[3] );

   861 

   862 #ifndef Q_OS_SYMBIAN    

   863     QTest::newRow("path equality 2")

   864         << QMessageFolderFilter::byPath("Innbox/X-Announce", QMessageDataComparator::Equal)

   865         << ( QMessageFolderIdList() << folderIds[2] )

   866         << ( QMessageFolderIdList() << folderIds[0] << folderIds[1] << folderIds[3] );

   867 #endif    

   868 

   869     QTest::newRow("path equality non-matching")

   870         << QMessageFolderFilter::byPath("Nonesuch", QMessageDataComparator::Equal) 

   871         << QMessageFolderIdList()

   872         << folderIds;

   873 

   874     QTest::newRow("path equality empty")

   875         << QMessageFolderFilter::byPath(QString(), QMessageDataComparator::Equal) 

   876         << QMessageFolderIdList()

   877         << folderIds;

   878 

   879     QTest::newRow("path equality zero-length")

   880         << QMessageFolderFilter::byPath("", QMessageDataComparator::Equal) 

   881         << QMessageFolderIdList()

   882         << folderIds;

   883 

   884     QTest::newRow("path inequality 1")

   885         << QMessageFolderFilter::byPath("My messages", QMessageDataComparator::NotEqual)

   886         << ( QMessageFolderIdList() << folderIds[1] << folderIds[2] << folderIds[3] )

   887         << ( QMessageFolderIdList() << folderIds[0] );

   888 

   889 #ifndef Q_OS_SYMBIAN    

   890     QTest::newRow("path inequality 2")

   891         << QMessageFolderFilter::byPath("Innbox/X-Announce", QMessageDataComparator::NotEqual)

   892         << ( QMessageFolderIdList() << folderIds[0] << folderIds[1] << folderIds[3] )

   893         << ( QMessageFolderIdList() << folderIds[2] );

   894 #endif    

   895 

   896     QTest::newRow("path inequality non-matching")

   897         << QMessageFolderFilter::byPath("Nonesuch", QMessageDataComparator::NotEqual) 

   898         << folderIds

   899         << QMessageFolderIdList();

   900 

   901     QTest::newRow("path inequality empty")

   902         << QMessageFolderFilter::byPath(QString(), QMessageDataComparator::NotEqual) 

   903         << folderIds

   904         << QMessageFolderIdList();

   905 

   906     QTest::newRow("path inequality zero-length")

   907         << QMessageFolderFilter::byPath("", QMessageDataComparator::NotEqual) 

   908         << folderIds

   909         << QMessageFolderIdList();

   910 

   911     QTest::newRow("path inclusion 1")

   912         << QMessageFolderFilter::byPath("ess", QMessageDataComparator::Includes) 

   913         << ( QMessageFolderIdList() << folderIds[0] )

   914         << ( QMessageFolderIdList() << folderIds[1] << folderIds[2] << folderIds[3] );

   915 

   916 #ifndef Q_OS_SYMBIAN    

   917     QTest::newRow("path inclusion 2")

   918         << QMessageFolderFilter::byPath("box/X-Ann", QMessageDataComparator::Includes)

   919         << ( QMessageFolderIdList() << folderIds[2] << folderIds[3] )

   920         << ( QMessageFolderIdList() << folderIds[0] << folderIds[1] );

   921 #endif    

   922 

   923     QTest::newRow("path inclusion non-matching")

   924         << QMessageFolderFilter::byPath("Nonesuch", QMessageDataComparator::Includes) 

   925         << QMessageFolderIdList()

   926         << folderIds;

   927 

   928     QTest::newRow("path inclusion empty")

   929         << QMessageFolderFilter::byPath(QString(), QMessageDataComparator::Includes) 

   930         << folderIds

   931         << QMessageFolderIdList();

   932 

   933     QTest::newRow("path inclusion zero-length")

   934         << QMessageFolderFilter::byPath("", QMessageDataComparator::Includes) 

   935         << folderIds

   936         << QMessageFolderIdList();

   937 

   938     QTest::newRow("path exclusion 1")

   939         << QMessageFolderFilter::byPath("ess", QMessageDataComparator::Excludes) 

   940         << ( QMessageFolderIdList() << folderIds[1] << folderIds[2] << folderIds[3] )

   941         << ( QMessageFolderIdList() << folderIds[0] );

   942 

   943 #ifndef Q_OS_SYMBIAN    

   944     QTest::newRow("path exclusion 2")

   945         << QMessageFolderFilter::byPath("box/X-Ann", QMessageDataComparator::Excludes)

   946         << ( QMessageFolderIdList() << folderIds[0] << folderIds[1] )

   947         << ( QMessageFolderIdList() << folderIds[2] << folderIds[3] );

   948 #endif    

   949 

   950     QTest::newRow("path exclusion non-matching")

   951         << QMessageFolderFilter::byPath("Nonesuch", QMessageDataComparator::Excludes) 

   952         << folderIds

   953         << QMessageFolderIdList();

   954 

   955     QTest::newRow("path exclusion empty")

   956         << QMessageFolderFilter::byPath(QString(), QMessageDataComparator::Excludes) 

   957         << QMessageFolderIdList()

   958         << folderIds;

   959 

   960     QTest::newRow("path exclusion zero-length")

   961         << QMessageFolderFilter::byPath("", QMessageDataComparator::Excludes) 

   962         << QMessageFolderIdList()

   963         << folderIds;

   964 

   965     QTest::newRow("name equality 1")

   966         << QMessageFolderFilter::byName("My messages", QMessageDataComparator::Equal) 

   967         << ( QMessageFolderIdList() << folderIds[0] )

   968         << ( QMessageFolderIdList() << folderIds[1] << folderIds[2] << folderIds[3] );

   969 

   970     QTest::newRow("name equality 2")

   971         << QMessageFolderFilter::byName("X-Announce", QMessageDataComparator::Equal) 

   972         << ( QMessageFolderIdList() << folderIds[2] )

   973         << ( QMessageFolderIdList() << folderIds[0] << folderIds[1] << folderIds[3] );

   974 

   975     QTest::newRow("name equality non-matching")

   976         << QMessageFolderFilter::byName("Nonesuch", QMessageDataComparator::Equal) 

   977         << QMessageFolderIdList()

   978         << folderIds;

   979 

   980     QTest::newRow("name equality empty")

   981         << QMessageFolderFilter::byName(QString(), QMessageDataComparator::Equal) 

   982         << QMessageFolderIdList()

   983         << folderIds;

   984 

   985     QTest::newRow("name equality zero-length")

   986         << QMessageFolderFilter::byName("", QMessageDataComparator::Equal) 

   987         << QMessageFolderIdList()

   988         << folderIds;

   989 

   990     QTest::newRow("name inequality 1")

   991         << QMessageFolderFilter::byName("My messages", QMessageDataComparator::NotEqual) 

   992         << ( QMessageFolderIdList() << folderIds[1] << folderIds[2] << folderIds[3] )

   993         << ( QMessageFolderIdList() << folderIds[0] );

   994 

   995     QTest::newRow("name inequality 2")

   996         << QMessageFolderFilter::byName("X-Announce", QMessageDataComparator::NotEqual) 

   997         << ( QMessageFolderIdList() << folderIds[0] << folderIds[1] << folderIds[3] )

   998         << ( QMessageFolderIdList() << folderIds[2] );

   999 

  1000     QTest::newRow("name inequality non-matching")

  1001         << QMessageFolderFilter::byName("Nonesuch", QMessageDataComparator::NotEqual) 

  1002         << folderIds

  1003         << QMessageFolderIdList();

  1004 

  1005     QTest::newRow("name inequality empty")

  1006         << QMessageFolderFilter::byName(QString(), QMessageDataComparator::NotEqual) 

  1007         << folderIds

  1008         << QMessageFolderIdList();

  1009 

  1010     QTest::newRow("name inequality zero-length")

  1011         << QMessageFolderFilter::byName("", QMessageDataComparator::NotEqual) 

  1012         << folderIds

  1013         << QMessageFolderIdList();

  1014 

  1015     QTest::newRow("name inclusion 1")

  1016         << QMessageFolderFilter::byName("message", QMessageDataComparator::Includes) 

  1017         << ( QMessageFolderIdList() << folderIds[0] )

  1018         << ( QMessageFolderIdList() << folderIds[1] << folderIds[2] << folderIds[3] );

  1019 

  1020     QTest::newRow("name inclusion 2")

  1021         << QMessageFolderFilter::byName("X-A", QMessageDataComparator::Includes) 

  1022         << ( QMessageFolderIdList() << folderIds[2] << folderIds[3] )

  1023         << ( QMessageFolderIdList() << folderIds[0] << folderIds[1] );

  1024 

  1025     QTest::newRow("name inclusion non-matching")

  1026         << QMessageFolderFilter::byName("Nonesuch", QMessageDataComparator::Includes) 

  1027         << QMessageFolderIdList()

  1028         << folderIds;

  1029 

  1030     QTest::newRow("name inclusion empty")

  1031         << QMessageFolderFilter::byName(QString(), QMessageDataComparator::Includes) 

  1032         << folderIds

  1033         << QMessageFolderIdList();

  1034 

  1035     QTest::newRow("name inclusion zero-length")

  1036         << QMessageFolderFilter::byName("", QMessageDataComparator::Includes) 

  1037         << folderIds

  1038         << QMessageFolderIdList();

  1039 

  1040     QTest::newRow("name exclusion 1")

  1041         << QMessageFolderFilter::byName("messages", QMessageDataComparator::Excludes) 

  1042         << ( QMessageFolderIdList() << folderIds[1] << folderIds[2] << folderIds[3] )

  1043         << ( QMessageFolderIdList() << folderIds[0] );

  1044 

  1045     QTest::newRow("name exclusion 2")

  1046         << QMessageFolderFilter::byName("X-A", QMessageDataComparator::Excludes) 

  1047         << ( QMessageFolderIdList() << folderIds[0] << folderIds[1] )

  1048         << ( QMessageFolderIdList() << folderIds[2] << folderIds[3] );

  1049 

  1050     QTest::newRow("name exclusion non-matching")

  1051         << QMessageFolderFilter::byName("Nonesuch", QMessageDataComparator::Excludes) 

  1052         << folderIds

  1053         << QMessageFolderIdList();

  1054 

  1055     QTest::newRow("name exclusion empty")

  1056         << QMessageFolderFilter::byName(QString(), QMessageDataComparator::Excludes) 

  1057         << QMessageFolderIdList()

  1058         << folderIds;

  1059 

  1060     QTest::newRow("name exclusion zero-length")

  1061         << QMessageFolderFilter::byName("", QMessageDataComparator::Excludes) 

  1062         << QMessageFolderIdList()

  1063         << folderIds;

  1064 

  1065     QTest::newRow("parentAccountId equality 1")

  1066         << QMessageFolderFilter::byParentAccountId(accountIds[0], QMessageDataComparator::Equal) 

  1067         << ( QMessageFolderIdList() << folderIds[1] << folderIds[2] << folderIds[3] )

  1068         << ( QMessageFolderIdList() << folderIds[0] );

  1069 

  1070     QTest::newRow("parentAccountId equality 2")

  1071         << QMessageFolderFilter::byParentAccountId(accountIds[2], QMessageDataComparator::Equal) 

  1072         << ( QMessageFolderIdList() << folderIds[0] )

  1073         << ( QMessageFolderIdList() << folderIds[1] << folderIds[2] << folderIds[3] );

  1074 

  1075     QTest::newRow("parentAccountId equality invalid")

  1076         << QMessageFolderFilter::byParentAccountId(QMessageAccountId(), QMessageDataComparator::Equal) 

  1077         << QMessageFolderIdList()

  1078         << folderIds;

  1079 

  1080     QTest::newRow("parentAccountId inequality 1")

  1081         << QMessageFolderFilter::byParentAccountId(accountIds[0], QMessageDataComparator::NotEqual) 

  1082         << ( QMessageFolderIdList() << folderIds[0] )

  1083         << ( QMessageFolderIdList() << folderIds[1] << folderIds[2] << folderIds[3] );

  1084 

  1085     QTest::newRow("parentAccountId inequality 2")

  1086         << QMessageFolderFilter::byParentAccountId(accountIds[2], QMessageDataComparator::NotEqual) 

  1087         << ( QMessageFolderIdList() << folderIds[1] << folderIds[2] << folderIds[3] )

  1088         << ( QMessageFolderIdList() << folderIds[0] );

  1089 

  1090     QTest::newRow("parentAccountId inequality invalid")

  1091         << QMessageFolderFilter::byParentAccountId(QMessageAccountId(), QMessageDataComparator::NotEqual) 

  1092         << folderIds

  1093         << QMessageFolderIdList();

  1094 

  1095     QTest::newRow("parentAccountId filter inclusion 1")

  1096         << QMessageFolderFilter::byParentAccountId(QMessageAccountFilter::byName("Alter Ego", QMessageDataComparator::Equal), QMessageDataComparator::Includes) 

  1097         << ( QMessageFolderIdList() << folderIds[0] )

  1098         << ( QMessageFolderIdList() << folderIds[1] << folderIds[2] << folderIds[3] );

  1099 

  1100     QTest::newRow("parentAccountId filter inclusion 2")

  1101         << QMessageFolderFilter::byParentAccountId(QMessageAccountFilter::byName("Work", QMessageDataComparator::Equal), QMessageDataComparator::Includes) 

  1102         << ( QMessageFolderIdList() << folderIds[1] << folderIds[2] << folderIds[3] )

  1103         << ( QMessageFolderIdList() << folderIds[0] );

  1104 

  1105     QTest::newRow("parentAccountId filter inclusion 3")

  1106         << QMessageFolderFilter::byParentAccountId(QMessageAccountFilter::byName("o", QMessageDataComparator::Includes), QMessageDataComparator::Includes) 

  1107         << folderIds

  1108         << QMessageFolderIdList();

  1109 

  1110     QTest::newRow("parentAccountId filter inclusion empty")

  1111         << QMessageFolderFilter::byParentAccountId(QMessageAccountFilter(), QMessageDataComparator::Includes) 

  1112         << folderIds 

  1113         << QMessageFolderIdList();

  1114 

  1115     QTest::newRow("parentAccountId filter inclusion non-matching")

  1116         << QMessageFolderFilter::byParentAccountId(QMessageAccountFilter::byName("NoneSuch"), QMessageDataComparator::Includes) 

  1117         << QMessageFolderIdList()

  1118         << folderIds;

  1119 

  1120     QTest::newRow("parentAccountId filter exclusion 1")

  1121         << QMessageFolderFilter::byParentAccountId(QMessageAccountFilter::byName("Alter Ego", QMessageDataComparator::Equal), QMessageDataComparator::Excludes) 

  1122         << ( QMessageFolderIdList() << folderIds[1] << folderIds[2] << folderIds[3] )

  1123         << ( QMessageFolderIdList() << folderIds[0] );

  1124 

  1125     QTest::newRow("parentAccountId filter exclusion 2")

  1126         << QMessageFolderFilter::byParentAccountId(QMessageAccountFilter::byName("Work", QMessageDataComparator::Equal), QMessageDataComparator::Excludes) 

  1127         << ( QMessageFolderIdList() << folderIds[0] )

  1128         << ( QMessageFolderIdList() << folderIds[1] << folderIds[2] << folderIds[3] );

  1129 

  1130     QTest::newRow("parentAccountId filter exclusion 3")

  1131         << QMessageFolderFilter::byParentAccountId(QMessageAccountFilter::byName("o", QMessageDataComparator::Includes), QMessageDataComparator::Excludes) 

  1132         << QMessageFolderIdList()

  1133         << folderIds;

  1134