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 

    42 #include "../../../src/publishsubscribe/psmapperserver_symbian/qcrmlparser_p.h"

    43 

    44 #include <qmobilityglobal.h>

    45 #include <QtTest/QTest>

    46 #include <QDebug>

    47 #include <QDir>

    48 

    49 #if defined(Q_OS_SYMBIAN)

    50 # define TESTDATA_DIR "."

    51 #endif

    52 

    53 QTM_USE_NAMESPACE

    54 

    55 class tst_QCrmlParser : public QObject

    56 {

    57     Q_OBJECT

    58 

    59 private slots:

    60     void init();

    61     void empty();

    62     void simple();

    63     void keyRangeSequence();

    64     void bitmaskKey();

    65     void keyWithUnknownElements();

    66     void keyRangeNoSequence();

    67     void singleKey();

    68     void multipleKeyRanges();

    69     void multipleBitmaskKeys();

    70 

    71     void wrongXmlFile();

    72     void noRepositoryUidValue();

    73     void keyMissingEndTag();

    74     void outOfPlaceEndTag();

    75     void invalidTarget();

    76 

    77 private:

    78     bool verifyKeyData(const QHash<QString,KeyData> &keyHash, const QString &key,

    79                     quint64 uid, KeyData::Target target = KeyData::CRepository, quint32 bitIndex = 0);

    80     QHash<QString,KeyData> makeHash(const QList<KeyData> &keyList);

    81     void printKeyList(const QList<KeyData> &list);

    82     QDir testData;

    83 };

    84 

    85 void tst_QCrmlParser::init()

    86 {

    87     testData.setPath(TESTDATA_DIR "/testdata");

    88 }

    89 

    90 void tst_QCrmlParser::empty()

    91 {

    92     QList<KeyData> keyData;

    93     KeyData *key = new KeyData();

    94     keyData.append(*key);

    95     KeyData::Target target = KeyData::RProperty;

    96 

    97     QHash<QString, KeyData> keyHash = makeHash(keyData);

    98     QVERIFY(verifyKeyData(keyHash, "", 0, target));

    99 }

   100 

   101 void tst_QCrmlParser::simple()

   102 {

   103     QCrmlParser parser;

   104     QList<KeyData> keyData;

   105     keyData = parser.parseQCrml("dontexist");

   106     QVERIFY(parser.error() == QCrmlParser::FileNotFound);

   107     QCOMPARE(parser.errorString(), QString("File does not exist: dontexist"));

   108     QVERIFY(keyData.count() == 0);

   109 

   110     keyData = parser.parseQCrml(testData.absoluteFilePath("test1.qcrml"));

   111     QVERIFY(parser.error() == QCrmlParser::NoError);

   112     QHash<QString, KeyData> keyHash = makeHash(keyData);

   113 

   114     KeyData::Target target = KeyData::CRepository;

   115     QVERIFY(verifyKeyData(keyHash, "/sensors/accelerometer/x",

   116                           Q_UINT64_C(0x4815162300000000),target));

   117     QVERIFY(verifyKeyData(keyHash, "/sensors/accelerometer/y",

   118                           Q_UINT64_C(0x4815162300000001),target));

   119     QVERIFY(verifyKeyData(keyHash, "/sensors/accelerometer/z",

   120                           Q_UINT64_C(0x4815162300000002),target));

   121 

   122     QVERIFY(parser.error() == QCrmlParser::NoError);

   123 

   124     for (int i = 0; i < keyData.count(); ++i) {

   125         QVERIFY(keyData.at(i).keyId() == quint32(i));

   126         QVERIFY(keyData.at(i).repoId() == (keyData.at(i).uid() >> 32));

   127     }

   128 }

   129 

   130 void tst_QCrmlParser::keyRangeSequence()

   131 {

   132     QCrmlParser parser;

   133     QList<KeyData> keyData;

   134     keyData = parser.parseQCrml(testData.absoluteFilePath("test2.qcrml"));

   135     QCOMPARE(keyData.count(), 763);

   136     QHash<QString,KeyData> keyHash = makeHash(keyData);

   137 

   138     quint64 repoUID = Q_UINT64_C(0x81531600000000);

   139 

   140     quint32 settingsIdentifier = 0x07000000;

   141     quint32 itemSettingIndex = 0x00010000;

   142     quint32 itemSettingIndexOffset = 0x00020000;

   143     quint64 uidPrefix = 0;

   144 

   145     QVERIFY(verifyKeyData(keyHash, QString("/PIM/Contact"), repoUID + settingsIdentifier));

   146 

   147     for(int i=0; i < 254; i++) {

   148         uidPrefix = repoUID + settingsIdentifier + itemSettingIndex * i + itemSettingIndexOffset;

   149 

   150         QVERIFY(verifyKeyData(keyHash,QString("/PIM/Contact/") + QString::number(i) + "/firstName",

   151                               uidPrefix + 0x1));

   152         QVERIFY(verifyKeyData(keyHash,QString("/PIM/Contact/") + QString::number(i) + "/lastName",

   153                               uidPrefix + 0x2));

   154         QVERIFY(verifyKeyData(keyHash,QString("/PIM/Contact/") + QString::number(i) + "/group",

   155                               uidPrefix + 0xf00f));

   156     }

   157 

   158     for (int i = 0; i < keyData.count(); ++i) {

   159         QVERIFY(keyData.at(i).keyId() == (keyData.at(i).uid() & 0xFFFFFFFF));

   160         QVERIFY(keyData.at(i).repoId() == (keyData.at(i).uid() >> 32));

   161     }

   162 }

   163 

   164 void tst_QCrmlParser::bitmaskKey()

   165 {

   166     QCrmlParser parser;

   167     QList<KeyData> keyData;

   168     keyData = parser.parseQCrml(testData.absoluteFilePath("test3.qcrml"));

   169     QCOMPARE(keyData.count(), 4);

   170     QHash<QString, KeyData> keyHash = makeHash(keyData);

   171 

   172     quint64 uid = Q_UINT64_C(0x1234567800000001);

   173 

   174     KeyData::Target target = KeyData::CRepository;

   175     QVERIFY(verifyKeyData(keyHash, QString("/Dharma/Swan"), uid, target, 1));

   176     QVERIFY(verifyKeyData(keyHash, QString("/Dharma/Pearl"), uid, target, 2));

   177     QVERIFY(verifyKeyData(keyHash, QString("/Dharma/Hydra"), uid, target,32));

   178     QVERIFY(verifyKeyData(keyHash, QString("/Dharma/LookingGlass"), uid, target, 4));

   179 

   180     for (int i = 0; i < keyData.count(); ++i) {

   181         QVERIFY(keyData.at(i).keyId() == (keyData.at(i).uid() & 0xFFFFFFFF));

   182         QVERIFY(keyData.at(i).repoId() == (keyData.at(i).uid() >> 32));

   183     }

   184 }

   185 

   186 void tst_QCrmlParser::keyWithUnknownElements()

   187 {

   188     QCrmlParser parser;

   189     QList<KeyData> keyData;

   190     keyData = parser.parseQCrml(testData.absoluteFilePath("test4.qcrml"));

   191     QCOMPARE(keyData.count(), 3);

   192     QHash<QString, KeyData> keyHash = makeHash(keyData);

   193 

   194     KeyData::Target target  = KeyData::RProperty;

   195     QVERIFY(verifyKeyData(keyHash, "/sensors/accelerometer/x",

   196                           Q_UINT64_C(0x4815162300000000),target));

   197     QVERIFY(verifyKeyData(keyHash, "/sensors/accelerometer/y",

   198                           Q_UINT64_C(0x4815162300000001),target));

   199     QVERIFY(verifyKeyData(keyHash, "/sensors/accelerometer/z",

   200                           Q_UINT64_C(0x4815162300000002),target));

   201 

   202     for (int i = 0; i < keyData.count(); ++i) {

   203         QVERIFY(keyData.at(i).keyId() == (keyData.at(i).uid() & 0xFFFFFFFF));

   204         QVERIFY(keyData.at(i).repoId() == (keyData.at(i).uid() >> 32));

   205     }

   206 }

   207 

   208 void tst_QCrmlParser::keyRangeNoSequence()

   209 {

   210     QCrmlParser parser;

   211     QList<KeyData> keyData;

   212     keyData = parser.parseQCrml(testData.absoluteFilePath("test5.qcrml"));

   213     QCOMPARE(keyData.count(), 65535);

   214     QHash<QString,KeyData> keyHash = makeHash(keyData);

   215 

   216     quint64 repoUid = Q_UINT64_C(0x8765432100000000);

   217     quint32 firstAddr = 0x1;

   218     quint64 uidPrefix = repoUid + firstAddr;

   219 

   220     for (int i = 0; i < 65535; ++i) {

   221         QVERIFY(verifyKeyData(keyHash, QString("/MyFeature/MyNumbers/") + QString::number(i),

   222                         uidPrefix + i));

   223     }

   224 

   225     for (int i = 0; i < keyData.count(); ++i) {

   226         QVERIFY(keyData.at(i).keyId() == (keyData.at(i).uid() & 0xFFFFFFFF));

   227         QVERIFY(keyData.at(i).repoId() == (keyData.at(i).uid() >> 32));

   228     }

   229 }

   230 

   231 void tst_QCrmlParser::singleKey()

   232 {

   233     QCrmlParser parser;

   234     QList<KeyData> keyData;

   235     keyData = parser.parseQCrml(testData.absoluteFilePath("test6.qcrml"));

   236     QCOMPARE(keyData.count(), 1);

   237     QHash<QString, KeyData> keyHash = makeHash(keyData);

   238     QVERIFY(verifyKeyData(keyHash, "/compass",

   239                           Q_UINT64_C(0x1111222298765432)));

   240 

   241     for (int i = 0; i < keyData.count(); ++i) {

   242         QVERIFY(keyData.at(i).keyId() == (keyData.at(i).uid() & 0xFFFFFFFF));

   243         QVERIFY(keyData.at(i).repoId() == (keyData.at(i).uid() >> 32));

   244     }

   245 }

   246 

   247 void tst_QCrmlParser::multipleKeyRanges()

   248 {

   249     QCrmlParser parser;

   250     QList<KeyData> keyData;

   251     keyData = parser.parseQCrml(testData.absoluteFilePath("test7.qcrml"));

   252     QCOMPARE(keyData.count(),33 );

   253     QHash<QString, KeyData> keyHash = makeHash(keyData);

   254 

   255     for(int i = 0x8; i <=0xC; ++i) {

   256         QVERIFY(verifyKeyData(keyHash, QString("/section31/") + QString::number(i - 0x8,10),

   257                                     Q_UINT64_C(0x1212989800000000)+i));

   258     }

   259 

   260     for(int i = 0xE; i <= 0x13; ++i) {

   261      QVERIFY(verifyKeyData(keyHash, QString("/talshiar/") + QString::number(i - 0xE,10),

   262                                     Q_UINT64_C(0x1212989800000000)+i));

   263     }

   264 

   265     quint64 repoUID = Q_UINT64_C(0x1212989800000000);

   266 

   267     quint32 settingsIdentifier = 0x200;

   268     quint32 itemSettingIndex = 0x020;

   269     quint64 uidPrefix = 0;

   270 

   271     for(int i = 0; i < 11; i++) {

   272         uidPrefix = repoUID + settingsIdentifier + itemSettingIndex * i;

   273 

   274         QVERIFY(verifyKeyData(keyHash,QString("/obsidian/") + QString::number(i) + "/name",

   275                               uidPrefix + 0x1));

   276         QVERIFY(verifyKeyData(keyHash,QString("/obsidian/") + QString::number(i) + "/rank",

   277                               uidPrefix + 0x2));

   278     }

   279 

   280     for (int i = 0; i < keyData.count(); ++i) {

   281         QVERIFY(keyData.at(i).keyId() == (keyData.at(i).uid() & 0xFFFFFFFF));

   282         QVERIFY(keyData.at(i).repoId() == (keyData.at(i).uid() >> 32));

   283     }

   284 }

   285 

   286 void tst_QCrmlParser::multipleBitmaskKeys()

   287 {

   288     QCrmlParser parser;

   289     QList<KeyData> keyData;

   290     keyData = parser.parseQCrml(testData.absoluteFilePath("test8.qcrml"));

   291     QCOMPARE(keyData.count(), 7);

   292     QHash<QString, KeyData> keyHash = makeHash(keyData);

   293     

   294     KeyData::Target target = KeyData::CRepository;

   295     QVERIFY(verifyKeyData(keyHash, QString("/Dharma/Swan"),Q_UINT64_C(0x1234567800000001),target,1));

   296     QVERIFY(verifyKeyData(keyHash, QString("/Dharma/Pearl"),Q_UINT64_C(0x1234567800000001),target,2));

   297     QVERIFY(verifyKeyData(keyHash, QString("/Dharma/Hydra"),Q_UINT64_C(0x1234567800000001),target,32));

   298     QVERIFY(verifyKeyData(keyHash, QString("/Dharma/LookingGlass"),Q_UINT64_C(0x1234567800000001),target,4));

   299 

   300     QVERIFY(verifyKeyData(keyHash, QString("/Ben"),Q_UINT64_C(0x123456780000000A),target,2));

   301     QVERIFY(verifyKeyData(keyHash, QString("/Tom"),Q_UINT64_C(0x123456780000000A),target,4));

   302     QVERIFY(verifyKeyData(keyHash, QString("/Ethan"),Q_UINT64_C(0x123456780000000A),target,5));

   303 

   304     for (int i = 0; i < keyData.count(); ++i) {

   305         QVERIFY(keyData.at(i).keyId() == (keyData.at(i).uid() & 0xFFFFFFFF));

   306         QVERIFY(keyData.at(i).repoId() == (keyData.at(i).uid() >> 32));

   307     }

   308 }

   309 

   310 void tst_QCrmlParser::wrongXmlFile()

   311 {

   312     QCrmlParser parser;

   313     QList<KeyData> keyData;

   314     keyData = parser.parseQCrml(testData.absoluteFilePath("error1.qcrml"));

   315     QVERIFY(parser.error() == QCrmlParser::ParseError);

   316 }

   317 

   318 void tst_QCrmlParser::noRepositoryUidValue()

   319 {

   320     QCrmlParser parser;

   321     QList<KeyData> keyData;

   322     keyData = parser.parseQCrml(testData.absoluteFilePath("error2.qcrml"));

   323     QVERIFY(parser.error() == QCrmlParser::ParseError);

   324 }

   325 

   326 void tst_QCrmlParser::keyMissingEndTag()

   327 {

   328     QCrmlParser parser;

   329     QList<KeyData> keyData;

   330     keyData = parser.parseQCrml(testData.absoluteFilePath("error3.qcrml"));

   331     QVERIFY(parser.error() == QCrmlParser::ParseError);

   332 }

   333 

   334 

   335 void tst_QCrmlParser::outOfPlaceEndTag()

   336 {

   337     QCrmlParser parser;

   338     QList<KeyData> keyData;

   339     keyData = parser.parseQCrml(testData.absoluteFilePath("error4.qcrml"));

   340     QVERIFY(parser.error() == QCrmlParser::ParseError);

   341     QVERIFY(keyData.count() == 0);

   342 }

   343 

   344 void tst_QCrmlParser::invalidTarget()

   345 {

   346     QCrmlParser parser;

   347     QList<KeyData> keyData;

   348     keyData = parser.parseQCrml(testData.absoluteFilePath("error5.qcrml"));

   349     QVERIFY(parser.error() == QCrmlParser::ParseError);

   350     QVERIFY(keyData.count() == 0);

   351 }

   352 

   353 bool tst_QCrmlParser::verifyKeyData(const QHash<QString,KeyData> &keyHash, const QString &key,

   354                     quint64 uid, KeyData::Target target, quint32 bitIndex) {

   355     KeyData data = keyHash.value(key);

   356 

   357     if (data.target() != target) {

   358         qWarning() << "Target does not match, expected" << target

   359                 << "\n actual:" << data.target();

   360         return false;

   361     }

   362 

   363     if ( data.uid()!= uid ) {

   364         qWarning() << "UID does not match expected:" << QString::number(uid,16) << "\n actual:"

   365                 << QString::number(data.uid(),16);

   366         return false;

   367     }

   368 

   369     if (data.bitIndex() != bitIndex) {

   370         qWarning() << "BitIndex does not match, expected: " << QString::number(bitIndex,16)

   371                 << "\n actual:" << QString::number(data.bitIndex(),16);

   372         return false;

   373     }

   374 

   375     return true;

   376 }

   377 

   378 QHash<QString,KeyData> tst_QCrmlParser::makeHash(const QList<KeyData> &keyList)

   379 {

   380     QHash<QString,KeyData> rv;

   381     for (int i = 0; i < keyList.count(); ++i) {

   382         rv.insert(keyList.at(i).path(), keyList.at(i));

   383     }

   384     return rv;

   385 }

   386 

   387 void tst_QCrmlParser::printKeyList(const QList<KeyData> &keyList)

   388 {

   389     for (int i=0; i < keyList.count(); ++i) {

   390         qDebug() << "KeyPath = " << keyList.at(i).path();

   391         qDebug() << "UID = " << QString::number(keyList.at(i).uid(), 16);

   392         qDebug() << "bitIndex"<< QString::number(keyList.at(i).bitIndex());

   393     }

   394 }

   395 

   396 QTEST_MAIN(tst_QCrmlParser)

   397 #include "tst_qcrmlparser.moc"