65 }

    91     delete mSignalCatcher;

    66 

    67 void UT_QVersitReader::readingDone()

    68 {

    69     QCOMPARE(mReader->result().count(),mExpectedDocumentCount);

    70     mReadingDoneCalled = true;

    86     QVERIFY(!mReader->readAll());

   124     QVERIFY(!mReader->startReading());

   125     QCOMPARE(mReader->error(), QVersitReader::IOError);

    90     mInputDevice->open(QBuffer::ReadWrite);

   129     mInputDevice->open(QBuffer::ReadOnly);

    91     QVERIFY(!mReader->readAll());

   130     QVERIFY(mReader->startReading());

    92     QCOMPARE(mReader->result().count(),0);

   131     QVERIFY(mReader->waitForFinished());

   132     QList<QVersitDocument> results(mReader->results());

   133     QCOMPARE(mReader->state(), QVersitReader::FinishedState);

   134     QCOMPARE(mReader->error(), QVersitReader::NoError);

   135     QCOMPARE(results.count(),0);

    97     mInputDevice->write(oneDocument);

   140     mInputDevice->close();

   141     mInputDevice->setData(oneDocument);

   142     mInputDevice->open(QBuffer::ReadOnly);

    99     QVERIFY(mReader->readAll());

   144     QVERIFY(mReader->startReading());

   100     QCOMPARE(mReader->result().count(),1);

   145     QVERIFY(mReader->waitForFinished());

   146     results = mReader->results();

   147     QCOMPARE(mReader->state(), QVersitReader::FinishedState);

   148     QCOMPARE(mReader->error(), QVersitReader::NoError);

   149     QCOMPARE(results.count(),1);

   150 

   151     // Wide charset with no byte-order mark

   152     QTextCodec* codec = QTextCodec::codecForName("UTF-16BE");

   153     const QByteArray& wideDocument =

   154             VersitUtils::encode("BEGIN:VCARD\r\nVERSION:2.1\r\nFN:John\r\nEND:VCARD\r\n", codec);

   155     mInputDevice->close();

   156     mInputDevice->setData(wideDocument);

   157     mInputDevice->open(QBuffer::ReadOnly);

   158     mInputDevice->seek(0);

   159     mReader->setDefaultCodec(codec);

   160     QVERIFY(mReader->startReading());

   161     QVERIFY(mReader->waitForFinished());

   162     results = mReader->results();

   163     QCOMPARE(mReader->state(), QVersitReader::FinishedState);

   164     QCOMPARE(mReader->error(), QVersitReader::NoError);

   165     QCOMPARE(mReader->results().count(),1);

   166     mReader->setDefaultCodec(NULL);

   104         "BEGIN:VCARD\r\nFN:Jenny\r\nEND:VCARD\r\nBEGIN:VCARD\r\nFN:Jake\r\nEND:VCARD\r\n";

   170         " \r\n BEGIN:VCARD\r\nFN:Jenny\r\nEND:VCARD\r\nBEGIN:VCARD\r\nFN:Jake\r\nEND:VCARD\r\n";

   105     delete mInputDevice;

   171     mInputDevice->close();

   106     mInputDevice = 0;

   172     mInputDevice->setData(twoDocuments);

   107     mInputDevice = new QBuffer;

   173     mInputDevice->open(QBuffer::ReadOnly);

   108     mInputDevice->open(QBuffer::ReadWrite);

   109     mInputDevice->write(twoDocuments);

   111     QVERIFY(mReader->readAll());

   175     QVERIFY(mReader->startReading());

   112     QCOMPARE(mReader->result().count(),2);

   176     QVERIFY(mReader->waitForFinished());

   177     results = mReader->results();

   178     QCOMPARE(mReader->state(), QVersitReader::FinishedState);

   179     QCOMPARE(mReader->error(), QVersitReader::NoError);

   180     QCOMPARE(results.count(),2);

   181 

   182     // Erroneous document (missing property name)

   183     mInputDevice->close();

   184     mInputDevice->setData(QByteArray(

   185             "BEGIN:VCARD\r\nFN:Jenny\r\n;Jenny;;;\r\nEND:VCARD\r\n"

   186             "BEGIN:VCARD\r\nFN:Jake\r\nEND:VCARD\r\n"));

   187     mInputDevice->open(QBuffer::ReadOnly);

   188     mInputDevice->seek(0);

   189     QVERIFY(mReader->startReading());

   190     QVERIFY(mReader->waitForFinished());

   191     results = mReader->results();

   192     QCOMPARE(mReader->state(), QVersitReader::FinishedState);

   193     QCOMPARE(mReader->error(), QVersitReader::ParseError);

   194     QCOMPARE(results.count(), 1);

   125     delete mInputDevice;

   207     mInputDevice->close();

   126     mInputDevice = 0;

   208     mInputDevice->setData(validDocumentsAndGroupedDocument);

   127     mInputDevice = new QBuffer;

   131     QVERIFY(mReader->readAll());

   211     QVERIFY(mReader->startReading());

   132     QCOMPARE(mReader->result().count(),4);

   212     QVERIFY(mReader->waitForFinished());

   213     results = mReader->results();

   214     QCOMPARE(mReader->state(), QVersitReader::FinishedState);

   215     // An error is logged because one failed, but the rest are readable.

   216     QCOMPARE(mReader->error(), QVersitReader::ParseError);

   217     QCOMPARE(results.count(),4);

   218 

   219     // Valid documents and a grouped document between them

   220     const QByteArray& validDocumentsAndGroupedDocument2 =

   221 "BEGIN:VCARD\r\nFN:Jenny\r\nEND:VCARD\r\n\

   222 BEGIN:VCARD\r\n\

   223 X-GROUPING:pub gang\r\n\

   224 BEGIN:VCARD\r\nFN:Jeremy\r\nEND:VCARD\r\n\

   225 BEGIN:VCARD\r\nFN:Jeffery\r\nEND:VCARD\r\n\

   226 END:VCARD\r\n\

   227 BEGIN:VCARD\r\nFN:Jake\r\nEND:VCARD\r\n\

   228 BEGIN:VCARD\r\nFN:James\r\nEND:VCARD\r\n\

   229 BEGIN:VCARD\r\nFN:Jane\r\nEND:VCARD";

   230     mInputDevice->close();

   231     mInputDevice->setData(validDocumentsAndGroupedDocument2);

   232     mInputDevice->open(QBuffer::ReadWrite);

   233     mInputDevice->seek(0);

   234     QVERIFY(mReader->startReading());

   235     QVERIFY(mReader->waitForFinished());

   236     results = mReader->results();

   237     QCOMPARE(mReader->state(), QVersitReader::FinishedState);

   238     // An error is logged because one failed, but the rest are readable.

   239     QCOMPARE(mReader->error(), QVersitReader::ParseError);

   240     QCOMPARE(mReader->results().count(),4);

   135     QVERIFY(!mReadingDoneCalled);

   243     mInputDevice->close();

   136     delete mInputDevice;

   244     mInputDevice->setData(twoDocuments);

   137     mInputDevice = 0;

   138     mInputDevice = new QBuffer;

   142     mExpectedDocumentCount = 1;

   247     mSignalCatcher->mStateChanges.clear();

   248     mSignalCatcher->mResultsCount = 0;

   144     delete mReader; // waits for the thread to finish

   250     QTRY_VERIFY(mSignalCatcher->mStateChanges.count() >= 2);

   145     mReader = 0;

   251     QCOMPARE(mSignalCatcher->mStateChanges.at(0), QVersitReader::ActiveState);

   146     QVERIFY(mReadingDoneCalled);

   252     QCOMPARE(mSignalCatcher->mStateChanges.at(1), QVersitReader::FinishedState);

   253     QVERIFY(mSignalCatcher->mResultsCount >= 2);

   254     QCOMPARE(mReader->results().size(), 2);

   255     QCOMPARE(mReader->error(), QVersitReader::NoError);

   256 

   257     // Cancelling

   258     mInputDevice->close();

   259     mInputDevice->setData(twoDocuments);

   260     mInputDevice->open(QBuffer::ReadOnly);

   261     mInputDevice->seek(0);

   262     mSignalCatcher->mStateChanges.clear();

   263     mSignalCatcher->mResultsCount = 0;

   264     QVERIFY(mReader->startReading());

   265     mReader->cancel();

   266     mReader->waitForFinished();

   267     QTRY_VERIFY(mSignalCatcher->mStateChanges.count() >= 2);

   268     QCOMPARE(mSignalCatcher->mStateChanges.at(0), QVersitReader::ActiveState);

   269     QVersitReader::State state(mSignalCatcher->mStateChanges.at(1));

   270     // It's possible that it finishes before it cancels.

   271     QVERIFY(state == QVersitReader::CanceledState

   272             || state == QVersitReader::FinishedState);

   151     QCOMPARE(mReader->result().count(),0);

   277     QCOMPARE(mReader->results().count(),0);

   165     property.setValue(QByteArray("2.1"));

   291     property.setValue(QString::fromAscii("2.1"));

   167     QVERIFY(document.versitType() == QVersitDocument::VCard21);

   293     QVERIFY(document.type() == QVersitDocument::VCard21Type);

   170     property.setValue(QByteArray("3.0"));

   296     property.setValue(QString::fromAscii("3.0"));

   172     QVERIFY(document.versitType() == QVersitDocument::VCard30);

   298     QVERIFY(document.type() == QVersitDocument::VCard30Type);

   175     property.setValue(QByteArray("4.0"));

   301     property.setValue(QString::fromAscii("4.0"));

   179     property.setValue(QByteArray("2.1").toBase64());

   305     property.setValue(QString::fromAscii(QByteArray("2.1").toBase64()));

   180     property.addParameter(QString::fromAscii("ENCODING"),QString::fromAscii("BASE64"));

   306     property.insertParameter(QString::fromAscii("ENCODING"),QString::fromAscii("BASE64"));

   182     QVERIFY(document.versitType() == QVersitDocument::VCard21);

   308     QVERIFY(document.type() == QVersitDocument::VCard21Type);

   185     property.setValue(QByteArray("4.0").toBase64());

   311     property.setValue(QString::fromAscii(QByteArray("4.0").toBase64()));

   191     QVersitDocument::VersitType type = QVersitDocument::VCard21;

   317     QVersitDocument::VersitType type = QVersitDocument::VCard21Type;

   194     // AGENT property, some property with parameter ENCODING=QUOTED-PRINTABLE 

   320     // AGENT property, ENCODING parameters (BASE64 and QUOTED-PRINTABLE) and CHARSET parameter

   195     // and some other property without this parameter

   321     QTextCodec* codec = QTextCodec::codecForName("UTF-16BE");

   203 

   342     QBuffer buffer(&vCard);

   204     QVersitProperty property = mReaderPrivate->parseNextVersitProperty(type,vCard);

   343     buffer.open(QIODevice::ReadOnly);

   344     LineReader lineReader(&buffer, mAsciiCodec);

   345 

   346     QVersitProperty property = mReaderPrivate->parseNextVersitProperty(type, lineReader);

   206     QCOMPARE(property.value(),QByteArray("vcard"));

   348     QCOMPARE(property.value(),QString::fromAscii("vcard"));

   207     

   349     

   208     property = mReaderPrivate->parseNextVersitProperty(type,vCard);

   350     property = mReaderPrivate->parseNextVersitProperty(type, lineReader);

   210     QCOMPARE(property.value(),QByteArray("2.1"));

   352     QCOMPARE(property.value(),QString::fromAscii("2.1"));

   211     

   353 

   212     property = mReaderPrivate->parseNextVersitProperty(type,vCard);

   354     property = mReaderPrivate->parseNextVersitProperty(type, lineReader);

   214     QCOMPARE(property.value(),QByteArray("John"));

   356     QCOMPARE(property.value(),QString::fromAscii("John"));

   215     

   357 

   216     property = mReaderPrivate->parseNextVersitProperty(type,vCard);

   358     property = mReaderPrivate->parseNextVersitProperty(type, lineReader);

   359     QCOMPARE(property.name(),QString::fromAscii("ORG"));

   360     QCOMPARE(property.value(),QString::fromUtf8(KATAKANA_NOKIA));

   361 

   362     property = mReaderPrivate->parseNextVersitProperty(type, lineReader);

   363     QCOMPARE(property.name(),QString::fromAscii("NOTE"));

   364     QCOMPARE(property.value(),QString::fromUtf8(KATAKANA_NOKIA));

   365     

   366     property = mReaderPrivate->parseNextVersitProperty(type, lineReader);

   218     QCOMPARE(1,property.parameters().count());

   368     // Linear whitespaces (SPACEs and TABs) removed from the value and base64 decoded:

   219     // Linear whitespaces (SPACEs and TABs) removed from the value:

   369     QCOMPARE(property.variantValue().type(), QVariant::ByteArray);

   220     QCOMPARE(property.value(),QByteArray("UXQgaXMgZ3JlYXQh"));

   370     QCOMPARE(property.value<QByteArray>(), QByteArray("Qt is great!"));

   221 

   371     // Ensure that base-64 encoded strings can be retrieved as strings.

   222     property = mReaderPrivate->parseNextVersitProperty(type,vCard);

   372     QCOMPARE(property.value(), QLatin1String("Qt is great!"));

   373 

   374     property = mReaderPrivate->parseNextVersitProperty(type, lineReader);

   375     QCOMPARE(property.name(),QString::fromAscii("PHOTO"));

   376     QCOMPARE(property.variantValue().type(), QVariant::ByteArray);

   377     QCOMPARE(property.value<QByteArray>(), QByteArray("Qt is great!"));

   378     QCOMPARE(property.value(), QLatin1String("Qt is great!"));

   379 

   380     property = mReaderPrivate->parseNextVersitProperty(type, lineReader);

   228     QCOMPARE(property.value(),QByteArray("john.citizen@example.com"));

   386     QCOMPARE(property.value(),QString::fromAscii("john.citizen@example.com"));

   229     

   387 

   230     property = mReaderPrivate->parseNextVersitProperty(type,vCard);

   388     property = mReaderPrivate->parseNextVersitProperty(type, lineReader);

   389     QCOMPARE(property.name(),QString::fromAscii("EMAIL"));

   390     // The base64 parameter should be stripped by the reader.

   391     QCOMPARE(property.parameters().count(), 0);

   392     QCOMPARE(property.value(),QString::fromAscii("john.citizen@example.com"));

   393 

   394     property = mReaderPrivate->parseNextVersitProperty(type, lineReader);

   232     QCOMPARE(property.value(),QByteArray());

   396     QCOMPARE(property.value(),QString());

   233     QCOMPARE(property.embeddedDocument().properties().count(),1);

   397     QVERIFY(property.variantValue().userType() == qMetaTypeId<QVersitDocument>());

   234     

   398     QCOMPARE(property.value<QVersitDocument>().properties().count(), 1);

   235     property = mReaderPrivate->parseNextVersitProperty(type,vCard);

   399     

   400     property = mReaderPrivate->parseNextVersitProperty(type, lineReader);

   237     QCOMPARE(property.value(),QByteArray("VCARD"));

   402     QCOMPARE(property.value(),QString::fromAscii("VCARD"));

   238     

   403     

   239     property = mReaderPrivate->parseNextVersitProperty(type,vCard);

   404     property = mReaderPrivate->parseNextVersitProperty(type, lineReader);

   241     QCOMPARE(property.value(),QByteArray());

   406     QCOMPARE(property.value(),QString());

   247     property = mReaderPrivate->parseNextVersitProperty(type,agentProperty);

   412     buffer.close();

   248     QCOMPARE(property.name(),QString());

   413     buffer.setData(agentProperty);

   249     QCOMPARE(property.embeddedDocument().properties().count(),0);

   414     buffer.open(QIODevice::ReadOnly);

   250     QCOMPARE(property.value(),QByteArray());

   415     LineReader agentLineReader(&buffer, mAsciiCodec);

   416 

   417     property = mReaderPrivate->parseNextVersitProperty(type, agentLineReader);

   418     QVERIFY(property.isEmpty());

   255     QVersitDocument::VersitType type = QVersitDocument::VCard30;

   423     QVersitDocument::VersitType type = QVersitDocument::VCard30Type;

   267 

   445     QBuffer buffer(&vCard);

   268     QVersitProperty property = mReaderPrivate->parseNextVersitProperty(type,vCard);

   446     buffer.open(QIODevice::ReadOnly);

   447     LineReader lineReader(&buffer, mAsciiCodec);

   448 

   449     QVersitProperty property = mReaderPrivate->parseNextVersitProperty(type, lineReader);

   270     QCOMPARE(property.value(),QByteArray("vcard"));

   451     QCOMPARE(property.value(),QString::fromAscii("vcard"));

   271 

   452 

   272     property = mReaderPrivate->parseNextVersitProperty(type,vCard);

   453     property = mReaderPrivate->parseNextVersitProperty(type, lineReader);

   274     QCOMPARE(property.value(),QByteArray("3.0"));

   455     QCOMPARE(property.value(),QString::fromAscii("3.0"));

   275 

   456 

   276     property = mReaderPrivate->parseNextVersitProperty(type,vCard);

   457     property = mReaderPrivate->parseNextVersitProperty(type, lineReader);

   278     QCOMPARE(property.value(),QByteArray("John"));

   459     QCOMPARE(property.value(),QString::fromAscii("John"));

   279 

   460 

   280     property = mReaderPrivate->parseNextVersitProperty(type,vCard);

   461     property = mReaderPrivate->parseNextVersitProperty(type, lineReader);

   462     QCOMPARE(property.name(),QString::fromAscii("ORG"));

   463     QCOMPARE(property.value(),QString::fromUtf8(KATAKANA_NOKIA));

   464 

   465     property = mReaderPrivate->parseNextVersitProperty(type, lineReader);

   466     QCOMPARE(property.name(),QString::fromAscii("NOTE"));

   467     QCOMPARE(property.value(),QString::fromUtf8(KATAKANA_NOKIA));

   468 

   469     property = mReaderPrivate->parseNextVersitProperty(type, lineReader);

   282     QCOMPARE(property.value(),QByteArray("123"));

   471     QCOMPARE(property.value(),QString::fromAscii("123"));

   285     property = mReaderPrivate->parseNextVersitProperty(type,vCard);

   474     property = mReaderPrivate->parseNextVersitProperty(type, lineReader);

   287     QCOMPARE(1,property.parameters().count());

   476     QCOMPARE(property.variantValue().type(), QVariant::ByteArray);

   288     QCOMPARE(property.value(),QByteArray("UXQgaXMgZ3JlYXQh"));

   477     QCOMPARE(property.value<QByteArray>(), QByteArray("Qt is great!"));

   289 

   478     // Ensure that base-64 encoded strings can be retrieved as strings.

   290     property = mReaderPrivate->parseNextVersitProperty(type,vCard);

   479     QCOMPARE(property.value(), QLatin1String("Qt is great!"));

   480 

   481     property = mReaderPrivate->parseNextVersitProperty(type, lineReader);

   482     QCOMPARE(property.name(),QString::fromAscii("PHOTO"));

   483     QCOMPARE(property.variantValue().type(), QVariant::ByteArray);

   484     QCOMPARE(property.value<QByteArray>(), QByteArray("Qt is great!"));

   485     QCOMPARE(property.value(), QLatin1String("Qt is great!"));

   486 

   487     property = mReaderPrivate->parseNextVersitProperty(type, lineReader);

   293     QCOMPARE(property.value(),QByteArray("john.citizen@example.com"));

   490     QCOMPARE(property.value(),QString::fromAscii("john.citizen@example.com"));

   294 

   491 

   295     property = mReaderPrivate->parseNextVersitProperty(type,vCard);

   492     property = mReaderPrivate->parseNextVersitProperty(type, lineReader);

   297     QCOMPARE(property.value(),QByteArray());

   494     QVERIFY(property.variantValue().userType() == qMetaTypeId<QVersitDocument>());

   298     QCOMPARE(property.embeddedDocument().properties().count(),1);

   495     QCOMPARE(property.value<QVersitDocument>().properties().count(), 1);

   299 

   496 

   300     property = mReaderPrivate->parseNextVersitProperty(type,vCard);

   497     property = mReaderPrivate->parseNextVersitProperty(type, lineReader);

   302     QCOMPARE(property.value(),QByteArray("VCARD"));

   499     QCOMPARE(property.value(),QString::fromAscii("VCARD"));

   303 

   500 

   304     property = mReaderPrivate->parseNextVersitProperty(type,vCard);

   501     property = mReaderPrivate->parseNextVersitProperty(type, lineReader);

   306     QCOMPARE(property.value(),QByteArray());

   503     QCOMPARE(property.value(),QString());

   312     property = mReaderPrivate->parseNextVersitProperty(type,agentProperty);

   509     buffer.close();

   313     QCOMPARE(property.name(),QString());

   510     buffer.setData(agentProperty);

   314     QCOMPARE(property.embeddedDocument().properties().count(),0);

   511     buffer.open(QIODevice::ReadOnly);

   315     QCOMPARE(property.value(),QByteArray());

   512     LineReader agentLineReader(&buffer, mAsciiCodec);

   513 

   514     property = mReaderPrivate->parseNextVersitProperty(type, agentLineReader);

   515     QVERIFY(property.isEmpty());

   320     // Valid vCard 2.1

   520     QFETCH(QByteArray, vCard);

   321     const char validCard21[] =

   521     QFETCH(bool, expectedSuccess);

   322 "BEGIN:VCARD\r\n\

   522     QFETCH(int, expectedProperties);

   323 VERSION:2.1\r\n\

   523 

   324 FN:John\r\n\

   524     QBuffer buffer(&vCard);

   325 AGENT:BEGIN:VCARD\r\nN:Jenny\r\nEND:VCARD\r\n\r\n\

   525     buffer.open(QIODevice::ReadOnly);

   326 EMAIL;ENCODING=QUOTED-PRINTABLE:john.citizen=40exam=\r\nple.com\r\n\

   526     LineReader lineReader(&buffer, QTextCodec::codecForName("UTF-8"));

   327 END:VCARD\r\n";

   527 

   328     QByteArray vCard(validCard21);

   330     QVERIFY(mReaderPrivate->parseVersitDocument(vCard,document));

   529     QCOMPARE(mReaderPrivate->parseVersitDocument(lineReader, document), expectedSuccess);

   331     QCOMPARE(document.properties().count(),3);

   530     QCOMPARE(document.properties().count(), expectedProperties);

   332     QCOMPARE(mReaderPrivate->mDocumentNestingLevel,0);

   333 

   334     // Valid vCard 3.0

   335     const char validCard30[] =

   336 "BEGIN:VCARD\r\n\

   337 VERSION:3.0\r\n\

   338 FN:John\r\n\

   339 AGENT:BEGIN\\:VCARD\\nN\\:Jenny\\nEND\\:VCARD\\n\r\n\

   340 EMAIL:john.citizen@example.com\r\n\

   341 END:VCARD\r\n";

   342     vCard = validCard30;

   343     document = QVersitDocument();

   344     QVERIFY(mReaderPrivate->parseVersitDocument(vCard,document));

   345     QCOMPARE(document.properties().count(),3);

   346     QCOMPARE(mReaderPrivate->mDocumentNestingLevel,0);

   347     

   348     // No BEGIN found

   349     const char beginMissing[] = 

   350 "VCARD\r\n\

   351 VERSION:2.1\r\n\

   352 FN:Nobody\r\n\

   353 END:VCARD\r\n";

   354     vCard = beginMissing;

   355     document = QVersitDocument();

   356     QVERIFY(mReaderPrivate->parseVersitDocument(vCard,document));

   357     QCOMPARE(document.properties().count(),0);

   358     QCOMPARE(mReaderPrivate->mDocumentNestingLevel,0);

   359     

   360     // Wrong card type

   361     const char wrongType[] = 

   362 "BEGIN:VCAL\r\n\

   363 END:VCAL\r\n";

   364     vCard = wrongType;

   365     document = QVersitDocument();

   366     QVERIFY(mReaderPrivate->parseVersitDocument(vCard,document));

   367     QCOMPARE(document.properties().count(),0);

   368     QCOMPARE(mReaderPrivate->mDocumentNestingLevel,0);

   369     

   370     // Wrong version

   371     const char wrongVersion[] = 

   372 "BEGIN:VCARD\r\n\

   373 VERSION:4.0\r\n\

   374 FN:Nobody\r\n\

   375 END:VCARD\r\n";

   376     vCard = wrongVersion;

   377     document = QVersitDocument();

   378     QVERIFY(!mReaderPrivate->parseVersitDocument(vCard,document));

   379     QCOMPARE(document.properties().count(),0);

   380     QCOMPARE(mReaderPrivate->mDocumentNestingLevel,0);

   381 

   382     // Grouped vCards are not supported. The whole vCard will be discarded.

   383     const char groupedCard[] =

   384 "BEGIN:VCARD\r\n\

   385 VERSION:2.1\r\n\

   386 X-EXAMPLES:Family vCard\r\n\

   387 BEGIN:VCARD\r\n\

   388 VERSION:2.1\r\n\

   389 N:Citizen;John\r\n\

   390 TEL;CELL:1111\r\n\

   391 EMAIL;ENCODING=QUOTED-PRINTABLE:john.citizen=40example.com\r\n\

   392 END:VCARD\r\n\

   393 BEGIN:VCARD\r\n\

   394 VERSION:2.1\r\n\

   395 N:Citizen;Jenny\r\n\

   396 TEL;CELL:7777\r\n\

   397 END:VCARD\r\n\

   398 END:VCARD";

   399     vCard = groupedCard;

   400     document = QVersitDocument();

   401     QVERIFY(!mReaderPrivate->parseVersitDocument(vCard,document));

   403     QCOMPARE(mReaderPrivate->mVersitDocuments.count(), 0);

   532 }

   533 

   534 void UT_QVersitReader::testParseVersitDocument_data()

   535 {

   536     QTest::addColumn<QByteArray>("vCard");

   537     QTest::addColumn<bool>("expectedSuccess");

   538     QTest::addColumn<int>("expectedProperties");

   539 

   540     QTest::newRow("Basic vCard 2.1")

   541             << QByteArray(

   542                     "BEGIN:VCARD\r\n"

   543                     "VERSION:2.1\r\n"

   544                     "FN:John\r\n"

   545                     "END:VCARD\r\n")

   546             << true

   547             << 1;

   548 

   549     QTest::newRow("vCard 2.1 with Agent")

   550             << QByteArray(

   551                     "BEGIN:VCARD\r\n"

   552                     "VERSION:2.1\r\n"

   553                     "FN:John\r\n"

   554                     "AGENT:BEGIN:VCARD\r\nN:Jenny\r\nEND:VCARD\r\n\r\n"

   555                     "EMAIL;ENCODING=QUOTED-PRINTABLE:john.citizen=40exam=\r\nple.com\r\n"

   556                     "END:VCARD\r\n")

   557             << true

   558             << 3;

   559 

   560     QTest::newRow("vCard 3.0 with Agent")

   561             << QByteArray(

   562                     "BEGIN:VCARD\r\n"

   563                     "VERSION:3.0\r\n"

   564                     "FN:John\r\n"

   565                     "AGENT:BEGIN\\:VCARD\\nN\\:Jenny\\nEND\\:VCARD\\n\r\n"

   566                     "EMAIL:john.citizen@example.com\r\n"

   567                     "END:VCARD\r\n")

   568             << true

   569             << 3;

   570     

   571     QTest::newRow("No BEGIN found")

   572             << QByteArray(

   573                     "VCARD\r\n"

   574                     "VERSION:2.1\r\n"

   575                     "FN:Nobody\r\n"

   576                     "END:VCARD\r\n")

   577             << false

   578             << 0;

   579     

   580     QTest::newRow("Wrong card type")

   581             << QByteArray(

   582                     "BEGIN:VCAL\r\n"

   583                     "END:VCAL\r\n")

   584             << false

   585             << 0;

   586     

   587     QTest::newRow("Wrong version")

   588             << QByteArray(

   589                     "BEGIN:VCARD\r\n"

   590                     "VERSION:4.0\r\n"

   591                     "FN:Nobody\r\n"

   592                     "END:VCARD\r\n")

   593             << false

   594             << 0;

   595 

   596     QTest::newRow("No trailing crlf")

   597             << QByteArray(

   598                     "BEGIN:VCARD\r\n"

   599                     "VERSION:2.1\r\n"

   600                     "FN:Nobody\r\n"

   601                     "END:VCARD")

   602             << true

   603             << 1;

   604 

   605     QTest::newRow("No end")

   606             << QByteArray(

   607                     "BEGIN:VCARD\r\n"

   608                     "VERSION:2.1\r\n"

   609                     "FN:Nobody\r\n")

   610             << false

   611             << 0;

   612 

   613     QTest::newRow("Grouped vCards are not supported. The whole vCard will be discarded.")

   614             << QByteArray(

   615                     "BEGIN:VCARD\r\n"

   616                     "VERSION:2.1\r\n"

   617                     "X-EXAMPLES:Family vCard\r\n"

   618                     "BEGIN:VCARD\r\n"

   619                     "VERSION:2.1\r\n"

   620                     "N:Citizen;John\r\n"

   621                     "TEL;CELL:1111\r\n"

   622                     "EMAIL;ENCODING=QUOTED-PRINTABLE:john.citizen=40example.com\r\n"

   623                     "END:VCARD\r\n"

   624                     "BEGIN:VCARD\r\n"

   625                     "VERSION:2.1\r\n"

   626                     "N:Citizen;Jenny\r\n"

   627                     "TEL;CELL:7777\r\n"

   628                     "END:VCARD\r\n"

   629                     "END:VCARD")

   630             << false

   631             << 0;

   632 }

   633 

   634 void UT_QVersitReader::testDecodeQuotedPrintable()

   635 {

   636     // Soft line breaks

   637     QString encoded(QLatin1String("This=\r\n is =\r\none line."));

   638     QString decoded(QLatin1String("This is one line."));

   639     mReaderPrivate->decodeQuotedPrintable(encoded);

   640     QCOMPARE(encoded, decoded);

   641 

   642     // Characters recommended to be encoded according to RFC 1521:

   643     encoded = QLatin1String("To be decoded: =0A=0D=21=22=23=24=3D=40=5B=5C=5D=5E=60=7B=7C=7D=7E");

   644     decoded = QLatin1String("To be decoded: \n\r!\"#$=@[\\]^`{|}~");

   645     mReaderPrivate->decodeQuotedPrintable(encoded);

   646     QCOMPARE(encoded, decoded);

   647 

   648     // Other random characters encoded.

   649     // Some implementation may encode these too, as it is allowed.

   650     encoded = QLatin1String("=45=6E=63=6F=64=65=64 =64=61=74=61");

   651     decoded = QLatin1String("Encoded data");

   652     mReaderPrivate->decodeQuotedPrintable(encoded);

   653     QCOMPARE(encoded, decoded);

   654 }

   655 void UT_QVersitReader::testParamName()

   656 {

   657     // Empty value

   658     QByteArray param;

   659     QCOMPARE(mReaderPrivate->paramName(param, mAsciiCodec),QString());

   660 

   661     // Only value present

   662     param = "WORK";

   663     QCOMPARE(mReaderPrivate->paramName(param, mAsciiCodec),

   664              QString::fromAscii("TYPE"));

   665 

   666     // The below tests intentionally use the misspelling TIPE to avoid the default behaviour of

   667     // returning TYPE when the name can't be parsed.

   668     // Both name and value, spaces after the name

   669     param = "TIPE \t =WORK";

   670     QCOMPARE(mReaderPrivate->paramName(param, mAsciiCodec),

   671              QString::fromAscii("TIPE"));

   672 

   673     // Both name and value, no spaces after the name

   674     param = "TIPE=WORK";

   675     QCOMPARE(mReaderPrivate->paramName(param, mAsciiCodec),

   676              QString::fromAscii("TIPE"));

   677 

   678     // Test wide character support.

   679     QTextCodec* codec = QTextCodec::codecForName("UTF-16BE");

   680     param = codec->fromUnicode(QString::fromAscii("TIPE=WORK"));

   681     QCOMPARE(mReaderPrivate->paramName(param, codec),

   682              QString::fromAscii("TIPE"));

   683 

   684 }

   685 

   686 void UT_QVersitReader::testParamValue()

   687 {

   688     // Empty value

   689     QByteArray param;

   690     QCOMPARE(mReaderPrivate->paramValue(param, mAsciiCodec),QString());

   691 

   692     // Only value present

   693     param = "WORK";

   694     QCOMPARE(mReaderPrivate->paramValue(param, mAsciiCodec),

   695              QString::fromAscii("WORK"));

   696 

   697     // Name and equals sign, but no value

   698     param = "TYPE=";

   699     QCOMPARE(mReaderPrivate->paramValue(param, mAsciiCodec),QString());

   700 

   701     // Name and equals sign, but value has only spaces

   702     param = "TYPE=  \t ";

   703     QCOMPARE(mReaderPrivate->paramValue(param, mAsciiCodec),QString());

   704 

   705     // Both name and value, spaces before the value

   706     param = "TYPE= \t  WORK";

   707     QCOMPARE(mReaderPrivate->paramValue(param, mAsciiCodec),

   708              QString::fromAscii("WORK"));

   709 

   710     // Both name and value, no spaces before the value

   711     param = "ENCODING=QUOTED-PRINTABLE";

   712     QCOMPARE(mReaderPrivate->paramValue(param, mAsciiCodec),

   713              QString::fromAscii("QUOTED-PRINTABLE"));

   714 

   715     // Test wide character support.

   716     QTextCodec* codec = QTextCodec::codecForName("UTF-16BE");

   717     param = codec->fromUnicode(QString::fromAscii("TYPE=WORK"));

   718     QCOMPARE(mReaderPrivate->paramValue(param, codec),

   719              QString::fromAscii("WORK"));

   720 }

   721 

   722 void UT_QVersitReader::testExtractPart()

   723 {

   724     QByteArray originalStr;

   725 

   726     // Negative starting position

   727     QCOMPARE(mReaderPrivate->extractPart(originalStr,-1,1), QByteArray());

   728 

   729     // Empty original string

   730     QCOMPARE(mReaderPrivate->extractPart(originalStr,0,1), QByteArray());

   731 

   732     // Trimmed substring empty

   733     originalStr = " \t \t";

   734     QCOMPARE(mReaderPrivate->extractPart(originalStr,0,4), QByteArray());

   735 

   736     // The given substring length is greater than the original string length

   737     originalStr = "ENCODING=7BIT";

   738     QCOMPARE(mReaderPrivate->extractPart(originalStr,0,100), originalStr);

   739 

   740     // Non-empty substring, from the beginning

   741     originalStr = " TYPE=WORK ; X-PARAM=X-VALUE; ENCODING=8BIT";

   742     QCOMPARE(mReaderPrivate->extractPart(originalStr,0,11),

   743              QByteArray("TYPE=WORK"));

   744 

   745     // Non-empty substring, from the middle

   746     QCOMPARE(mReaderPrivate->extractPart(originalStr,12,16),

   747              QByteArray("X-PARAM=X-VALUE"));

   748 

   749     // Non-empty substring, from the middle to the end

   750     QCOMPARE(mReaderPrivate->extractPart(originalStr,29),

   751              QByteArray("ENCODING=8BIT"));

   752 }

   753 

   754 void UT_QVersitReader::testExtractParts()

   755 {

   756     QList<QByteArray> parts;

   757 

   758     // Empty value

   759     QByteArray text;

   760     parts = mReaderPrivate->extractParts(text,";", mAsciiCodec);

   761     QVERIFY(parts.isEmpty());

   762 

   763     // Only separator

   764     text = ";";

   765     parts = mReaderPrivate->extractParts(text,";", mAsciiCodec);

   766     QVERIFY(parts.isEmpty());

   767 

   768     // One part

   769     text = "part";

   770     parts = mReaderPrivate->extractParts(text,";", mAsciiCodec);

   771     QCOMPARE(parts.count(),1);

   772     QCOMPARE(QString::fromAscii(parts[0]),QString::fromAscii("part"));

   773 

   774     // Separator in the beginning, one part

   775     text = ";part";

   776     parts = mReaderPrivate->extractParts(text,";", mAsciiCodec);

   777     QCOMPARE(parts.count(),1);

   778     QCOMPARE(QString::fromAscii(parts[0]),QString::fromAscii("part"));

   779 

   780     // Separator in the end, one part

   781     text = "part;";

   782     parts = mReaderPrivate->extractParts(text,";", mAsciiCodec);

   783     QCOMPARE(parts.count(),1);

   784     QCOMPARE(QString::fromAscii(parts[0]),QString::fromAscii("part"));

   785 

   786     // One part that contains escaped separator

   787     text = "part\\;";

   788     parts = mReaderPrivate->extractParts(text,";", mAsciiCodec);

   789     QCOMPARE(parts.count(),1);

   790     QCOMPARE(QString::fromAscii(parts[0]),QString::fromAscii("part\\;"));

   791 

   792     // Two parts

   793     text = "part1;part2";

   794     parts = mReaderPrivate->extractParts(text,";", mAsciiCodec);

   795     QCOMPARE(parts.count(),2);

   796     QCOMPARE(QString::fromAscii(parts[0]),QString::fromAscii("part1"));

   797     QCOMPARE(QString::fromAscii(parts[1]),QString::fromAscii("part2"));

   798 

   799     // Two parts that contain escaped separators

   800     text = "pa\\;rt1;par\\;t2";

   801     parts = mReaderPrivate->extractParts(text,";", mAsciiCodec);

   802     QCOMPARE(parts.count(),2);

   803     QCOMPARE(QString::fromAscii(parts[0]),QString::fromAscii("pa\\;rt1"));

   804     QCOMPARE(QString::fromAscii(parts[1]),QString::fromAscii("par\\;t2"));

   805 

   806     // Test wide character support

   807     QTextCodec* codec = QTextCodec::codecForName("UTF-16BE");

   808     text = codec->fromUnicode(QString::fromAscii("part1;part2"));

   809     parts = mReaderPrivate->extractParts(text,";", codec);

   810     QCOMPARE(parts.count(),2);

   811     QCOMPARE(codec->toUnicode(parts[0]),QString::fromAscii("part1"));

   812     QCOMPARE(codec->toUnicode(parts[1]),QString::fromAscii("part2"));

   813 }

   814 

   815 void UT_QVersitReader::testExtractPropertyGroupsAndName()

   816 {

   817     QPair<QStringList,QString> groupsAndName;

   818 

   819     // Empty string

   820     VersitCursor cursor(QByteArray(" "));

   821     groupsAndName = mReaderPrivate->extractPropertyGroupsAndName(cursor, mAsciiCodec);

   822     QCOMPARE(groupsAndName.first.count(),0);

   823     QCOMPARE(groupsAndName.second,QString());

   824 

   825     // No value -> returns empty string and no groups

   826     QByteArray property("TEL");

   827     cursor.setData(property);

   828     cursor.selection = property.size();

   829     groupsAndName = mReaderPrivate->extractPropertyGroupsAndName(cursor, mAsciiCodec);

   830     QCOMPARE(groupsAndName.first.count(),0);

   831     QCOMPARE(groupsAndName.second,QString());

   832 

   833     // Simple name and value

   834     property = "TEL:123";

   835     cursor.setData(property);

   836     cursor.selection = property.size();

   837     groupsAndName = mReaderPrivate->extractPropertyGroupsAndName(cursor, mAsciiCodec);

   838     QCOMPARE(groupsAndName.first.count(),0);

   839     QCOMPARE(groupsAndName.second,QString::fromAscii("TEL"));

   840 

   841     // One whitespace before colon

   842     property = "TEL :123";

   843     cursor.setData(property);

   844     cursor.selection = property.size();

   845     groupsAndName = mReaderPrivate->extractPropertyGroupsAndName(cursor, mAsciiCodec);

   846     QCOMPARE(groupsAndName.first.count(),0);

   847     QCOMPARE(groupsAndName.second,QString::fromAscii("TEL"));

   848 

   849     // Several whitespaces before colon

   850     property = "TEL \t  :123";

   851     cursor.setData(property);

   852     cursor.selection = property.size();

   853     groupsAndName = mReaderPrivate->extractPropertyGroupsAndName(cursor, mAsciiCodec);

   854     QCOMPARE(groupsAndName.first.count(),0);

   855     QCOMPARE(groupsAndName.second,QString::fromAscii("TEL"));

   856 

   857     // Name contains a group

   858     property = "group1.TEL:1234";

   859     cursor.setData(property);

   860     cursor.selection = property.size();

   861     groupsAndName = mReaderPrivate->extractPropertyGroupsAndName(cursor, mAsciiCodec);

   862     QCOMPARE(groupsAndName.first.count(),1);

   863     QCOMPARE(groupsAndName.first.takeFirst(),QString::fromAscii("group1"));

   864     QCOMPARE(groupsAndName.second,QString::fromAscii("TEL"));

   865 

   866     // Name contains more than one group

   867     property = "group1.group2.TEL:12345";

   868     cursor.setData(property);

   869     cursor.selection = property.size();

   870     groupsAndName = mReaderPrivate->extractPropertyGroupsAndName(cursor, mAsciiCodec);

   871     QCOMPARE(groupsAndName.first.count(),2);

   872     QCOMPARE(groupsAndName.first.takeFirst(),QString::fromAscii("group1"));

   873     QCOMPARE(groupsAndName.first.takeFirst(),QString::fromAscii("group2"));

   874     QCOMPARE(groupsAndName.second,QString::fromAscii("TEL"));

   875     QCOMPARE(cursor.position, 17);

   876 

   877     // Property contains one parameter

   878     property = "TEL;WORK:123";

   879     cursor.setData(property);

   880     cursor.selection = property.size();

   881     groupsAndName = mReaderPrivate->extractPropertyGroupsAndName(cursor, mAsciiCodec);

   882     QCOMPARE(groupsAndName.first.count(),0);

   883     QCOMPARE(groupsAndName.second,QString::fromAscii("TEL"));

   884 

   885     // Property contains several parameters

   886     property = "EMAIL;INTERNET;ENCODING=QUOTED-PRINTABLE:user=40ovi.com";

   887     cursor.setData(property);

   888     cursor.selection = property.size();

   889     groupsAndName = mReaderPrivate->extractPropertyGroupsAndName(cursor, mAsciiCodec);

   890     QCOMPARE(groupsAndName.first.count(),0);

   891     QCOMPARE(groupsAndName.second,QString::fromAscii("EMAIL"));

   892 

   893     // Name contains an escaped semicolon

   894     property = "X-proper\\;ty:value";

   895     cursor.setData(property);

   896     cursor.selection = property.size();

   897     groupsAndName = mReaderPrivate->extractPropertyGroupsAndName(cursor, mAsciiCodec);

   898     QCOMPARE(groupsAndName.first.count(),0);

   899     QCOMPARE(groupsAndName.second,QString::fromAscii("X-proper\\;ty"));

   900 

   901     // Test wide character support

   902     QTextCodec* codec = QTextCodec::codecForName("UTF-16BE");

   903     property = codec->fromUnicode(QString::fromAscii("group1.group2.TEL;WORK:123"));

   904     cursor.setData(property);

   905     cursor.selection = property.size();

   906     groupsAndName = mReaderPrivate->extractPropertyGroupsAndName(cursor, codec);

   907     QCOMPARE(groupsAndName.first.count(),2);

   908     QCOMPARE(groupsAndName.first.takeFirst(),QString::fromAscii("group1"));

   909     QCOMPARE(groupsAndName.first.takeFirst(),QString::fromAscii("group2"));

   910     QCOMPARE(groupsAndName.second,QString::fromAscii("TEL"));

   911     QCOMPARE(cursor.position, 36); // 2 bytes * 17 characters + 2 byte BOM.

   912 

   913 }

   914 

   915 void UT_QVersitReader::testExtractVCard21PropertyParams()

   916 {

   917     // No parameters

   918     VersitCursor cursor(QByteArray(":123"));

   919     cursor.setSelection(cursor.data.size());

   920     QCOMPARE(mReaderPrivate->extractVCard21PropertyParams(cursor, mAsciiCodec).count(), 0);

   921 

   922     // "Empty" parameter

   923     cursor.setData(QByteArray(";:123"));

   924     cursor.setSelection(cursor.data.size());

   925     QCOMPARE(mReaderPrivate->extractVCard21PropertyParams(cursor, mAsciiCodec).count(), 0);

   926 

   927     // Semicolon found, but no value for the property

   928     cursor.setData(QByteArray(";TYPE=X-TYPE"));

   929     cursor.setSelection(cursor.data.size());

   930     QCOMPARE(mReaderPrivate->extractVCard21PropertyParams(cursor, mAsciiCodec).count(), 0);

   931 

   932     // The property name contains an escaped semicolon, no parameters

   933     cursor.setData(QByteArray(":value"));

   934     cursor.setSelection(cursor.data.size());

   935     QCOMPARE(mReaderPrivate->extractVCard21PropertyParams(cursor, mAsciiCodec).count(), 0);

   936 

   937     // The property value contains a semicolon, no parameters

   938     cursor.setData(QByteArray(":va;lue"));

   939     cursor.setSelection(cursor.data.size());

   940     QCOMPARE(mReaderPrivate->extractVCard21PropertyParams(cursor, mAsciiCodec).count(), 0);

   941 

   942     // One parameter

   943     cursor.setData(QByteArray(";HOME:123"));

   944     cursor.setSelection(cursor.data.size());

   945     QMultiHash<QString,QString> params = mReaderPrivate->extractVCard21PropertyParams(cursor,

   946                                                                                    mAsciiCodec);

   947     QCOMPARE(1, params.count());

   948     QCOMPARE(1, params.values(QString::fromAscii("TYPE")).count());

   949     QCOMPARE(params.values(QString::fromAscii("TYPE"))[0],QString::fromAscii("HOME"));

   950 

   951     // Two parameters of the same type

   952     cursor.setData(QByteArray(";HOME;VOICE:123"));

   953     cursor.setSelection(cursor.data.size());

   954     params = mReaderPrivate->extractVCard21PropertyParams(cursor, mAsciiCodec);

   955     QCOMPARE(2, params.count());

   956     QCOMPARE(2, params.values(QString::fromAscii("TYPE")).count());

   957     QCOMPARE(params.values(QString::fromAscii("TYPE"))[0],QString::fromAscii("HOME"));

   958     QCOMPARE(params.values(QString::fromAscii("TYPE"))[1],QString::fromAscii("VOICE"));

   959 

   960     // Two parameters, several empty parameters (extra semicolons)

   961     cursor.setData(QByteArray(";;;;HOME;;;;;VOICE;;;:123"));

   962     cursor.setSelection(cursor.data.size());

   963     params = mReaderPrivate->extractVCard21PropertyParams(cursor, mAsciiCodec);

   964     QCOMPARE(2, params.count());

   965     QCOMPARE(2, params.values(QString::fromAscii("TYPE")).count());

   966     QCOMPARE(params.values(QString::fromAscii("TYPE"))[0],QString::fromAscii("HOME"));

   967     QCOMPARE(params.values(QString::fromAscii("TYPE"))[1],QString::fromAscii("VOICE"));

   968 

   969     // Two parameters with different types

   970     cursor.setData(QByteArray(";INTERNET;ENCODING=QUOTED-PRINTABLE:user=40ovi.com"));

   971     cursor.setSelection(cursor.data.size());

   972     params.clear();

   973     params = mReaderPrivate->extractVCard21PropertyParams(cursor, mAsciiCodec);

   974     QCOMPARE(2, params.count());

   975     QList<QString> typeParams = params.values(QString::fromAscii("TYPE"));

   976     QCOMPARE(1, typeParams.count());

   977     QCOMPARE(typeParams[0],QString::fromAscii("INTERNET"));

   978     QList<QString> encodingParams = params.values(QString::fromAscii("ENCODING"));

   979     QCOMPARE(1, encodingParams.count());

   980     QCOMPARE(encodingParams[0],QString::fromAscii("QUOTED-PRINTABLE"));

   981 

   982     // Test wide character support.

   983     QTextCodec* codec = QTextCodec::codecForName("UTF-16BE");

   984     QByteArray data = VersitUtils::encode(";HOME;CHARSET=UTF-16:123", codec);

   985     cursor.setData(data);

   986     cursor.setSelection(cursor.data.size());

   987     params = mReaderPrivate->extractVCard21PropertyParams(cursor, codec);

   988     QCOMPARE(2, params.count());

   989     typeParams = params.values(QString::fromAscii("TYPE"));

   990     QCOMPARE(1, typeParams.count());

   991     QCOMPARE(typeParams[0],QString::fromAscii("HOME"));

   992     encodingParams = params.values(QString::fromAscii("CHARSET"));

   993     QCOMPARE(1, encodingParams.count());

   994     QCOMPARE(encodingParams[0],QString::fromAscii("UTF-16"));

   995 }

   996 

   997 void UT_QVersitReader::testExtractVCard30PropertyParams()

   998 {

   999     // No parameters

  1000     VersitCursor cursor(QByteArray(":123"));

  1001     cursor.setSelection(cursor.data.size());

  1002     QCOMPARE(mReaderPrivate->extractVCard30PropertyParams(cursor, mAsciiCodec).count(), 0);

  1003 

  1004     // One parameter

  1005     cursor.setData(QByteArray(";TYPE=HOME:123"));

  1006     cursor.setSelection(cursor.data.size());

  1007     QMultiHash<QString,QString> params = mReaderPrivate->extractVCard30PropertyParams(cursor,

  1008                                                                                    mAsciiCodec);

  1009     QCOMPARE(params.count(), 1);

  1010     QCOMPARE(params.values(QString::fromAscii("TYPE")).count(), 1);

  1011     QCOMPARE(params.values(QString::fromAscii("TYPE"))[0], QString::fromAscii("HOME"));

  1012 

  1013     // One parameter with an escaped semicolon

  1014     cursor.setData(QByteArray(";para\\;meter:value"));

  1015     cursor.setSelection(cursor.data.size());

  1016     params = mReaderPrivate->extractVCard30PropertyParams(cursor, mAsciiCodec);

  1017     QCOMPARE(params.count(), 1);

  1018     QCOMPARE(params.values(QString::fromAscii("TYPE")).count(), 1);

  1019     QCOMPARE(params.values(QString::fromAscii("TYPE"))[0], QString::fromAscii("para;meter"));

  1020 

  1021     // One parameter with and escaped comma in the name and the value

  1022     cursor.setData(QByteArray(";X-PA\\,RAM=VAL\\,UE:123"));

  1023     cursor.setSelection(cursor.data.size());

  1024     params = mReaderPrivate->extractVCard30PropertyParams(cursor, mAsciiCodec);

  1025     QCOMPARE(params.count(), 1);

  1026     QCOMPARE(params.values(QString::fromAscii("X-PA,RAM")).count(), 1);

  1027     QCOMPARE(params.values(QString::fromAscii("X-PA,RAM"))[0], QString::fromAscii("VAL,UE"));

  1028 

  1029     // Two parameters of the same type

  1030     cursor.setData(QByteArray(";TYPE=HOME,VOICE:123"));

  1031     cursor.setSelection(cursor.data.size());

  1032     params = mReaderPrivate->extractVCard30PropertyParams(cursor, mAsciiCodec);

  1033     QCOMPARE(params.count(), 2);

  1034     QCOMPARE(params.values(QString::fromAscii("TYPE")).count(), 2);

  1035     QVERIFY(params.values(QString::fromAscii("TYPE")).contains(QString::fromAscii("HOME")));

  1036     QVERIFY(params.values(QString::fromAscii("TYPE")).contains(QString::fromAscii("VOICE")));

  1037 

  1038     // Two parameters of the same type in separate name-values

  1039     cursor.setData(QByteArray(";TYPE=HOME;TYPE=VOICE:123"));

  1040     cursor.setSelection(cursor.data.size());

  1041     params = mReaderPrivate->extractVCard30PropertyParams(cursor, mAsciiCodec);

  1042     QCOMPARE(params.count(), 2);

  1043     QCOMPARE(params.values(QString::fromAscii("TYPE")).count(), 2);

  1044     QVERIFY(params.values(QString::fromAscii("TYPE")).contains(QString::fromAscii("HOME")));

  1045     QVERIFY(params.values(QString::fromAscii("TYPE")).contains(QString::fromAscii("VOICE")));

  1046 

  1047     // Three parameters of the same type

  1048     cursor.setData(QByteArray(";TYPE=PREF,HOME,VOICE:123"));

  1049     cursor.setSelection(cursor.data.size());

  1050     params = mReaderPrivate->extractVCard30PropertyParams(cursor, mAsciiCodec);

  1051     QCOMPARE(params.count(), 3);

  1052     QCOMPARE(params.values(QString::fromAscii("TYPE")).count(), 3);

  1053     QVERIFY(params.values(QString::fromAscii("TYPE")).contains(QString::fromAscii("PREF")));

  1054     QVERIFY(params.values(QString::fromAscii("TYPE")).contains(QString::fromAscii("HOME")));

  1055     QVERIFY(params.values(QString::fromAscii("TYPE")).contains(QString::fromAscii("VOICE")));

  1056 

  1057     // Two parameters with different types

  1058     cursor.setData(QByteArray(";TYPE=HOME;X-PARAM=X-VALUE:Home Street 1"));

  1059     cursor.setSelection(cursor.data.size());

  1060     params.clear();

  1061     params = mReaderPrivate->extractVCard30PropertyParams(cursor, mAsciiCodec);

  1062     QCOMPARE(params.count(), 2);

  1063     QList<QString> typeParams = params.values(QString::fromAscii("TYPE"));

  1064     QCOMPARE(typeParams.count(), 1);

  1065     QCOMPARE(typeParams[0],QString::fromAscii("HOME"));

  1066     QList<QString> encodingParams = params.values(QString::fromAscii("X-PARAM"));

  1067     QCOMPARE(encodingParams.count(), 1);

  1068     QCOMPARE(encodingParams[0],QString::fromAscii("X-VALUE"));

  1069 

  1070     // Test wide character support.

  1071     QTextCodec* codec = QTextCodec::codecForName("UTF-16BE");

  1072     QByteArray data = VersitUtils::encode(";TIPE=HOME,VOICE;CHARSET=UTF-16:123", codec);

  1073     cursor.setData(data);

  1074     cursor.setSelection(cursor.data.size());

  1075     params = mReaderPrivate->extractVCard30PropertyParams(cursor, codec);

  1076     QCOMPARE(params.count(), 3);

  1077     typeParams = params.values(QString::fromAscii("TIPE"));

  1078     QCOMPARE(params.values(QString::fromAscii("TIPE")).count(), 2);

  1079     QVERIFY(params.values(QString::fromAscii("TIPE")).contains(QString::fromAscii("HOME")));

  1080     QVERIFY(params.values(QString::fromAscii("TIPE")).contains(QString::fromAscii("VOICE")));

  1081     encodingParams = params.values(QString::fromAscii("CHARSET"));

  1082     QCOMPARE(1, encodingParams.count());

  1083     QCOMPARE(encodingParams[0],QString::fromAscii("UTF-16"));

  1084 }

  1085 

  1086 void UT_QVersitReader::testExtractParams()

  1087 {

  1088     VersitCursor cursor;

  1089     QByteArray data = ":123";

  1090     cursor.setData(data);

  1091     cursor.setPosition(0);

  1092     cursor.setSelection(cursor.data.size());