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 

    42 #include "ut_qvcard21writer.h"

    43 #include "qvcard21writer_p.h"

    44 #include "qversitproperty.h"

    45 #include "qversitdocument.h"

    46 #include <QtTest/QtTest>

    47 #include <QByteArray>

    48 #include <QVariant>

    49 

    50 // This says "NOKIA" in Katakana

    51 const QString KATAKANA_NOKIA(QString::fromUtf8("\xe3\x83\x8e\xe3\x82\xad\xe3\x82\xa2"));

    52 

    53 QTM_USE_NAMESPACE

    54 

    55 void UT_QVCard21Writer::init()

    56 {

    57     mWriter = new QVCard21Writer;

    58     mWriter->setCodec(QTextCodec::codecForName("ISO_8859-1"));

    59 }

    60 

    61 void UT_QVCard21Writer::cleanup()

    62 {

    63     delete mWriter;

    64 }

    65 

    66 void UT_QVCard21Writer::testEncodeVersitProperty()

    67 {

    68     QByteArray encodedProperty;

    69     QBuffer buffer(&encodedProperty);

    70     mWriter->setDevice(&buffer);

    71     buffer.open(QIODevice::WriteOnly);

    72 

    73     // No parameters

    74     QByteArray expectedResult = "FN:John Citizen\r\n";

    75     QVersitProperty property;

    76     property.setName(QString::fromAscii("FN"));

    77     property.setValue(QString::fromAscii("John Citizen"));

    78     mWriter->encodeVersitProperty(property);

    79     QCOMPARE(encodedProperty, expectedResult);

    80 

    81     // With parameter(s). No special characters in the value.

    82     // -> No need to Quoted-Printable encode the value.

    83     mWriter->writeCrlf(); // so it doesn't start folding

    84     buffer.close();

    85     encodedProperty.clear();

    86     buffer.open(QIODevice::WriteOnly);

    87     expectedResult = "TEL;HOME:123\r\n";

    88     property.setName(QString::fromAscii("TEL"));

    89     property.setValue(QString::fromAscii("123"));

    90     property.insertParameter(QString::fromAscii("TYPE"),QString::fromAscii("HOME"));

    91     mWriter->encodeVersitProperty(property);

    92     QCOMPARE(encodedProperty, expectedResult);

    93 

    94     // With parameter(s). Special characters in the value.

    95     // -> The value needs to be Quoted-Printable encoded.

    96     mWriter->writeCrlf(); // so it doesn't start folding

    97     buffer.close();

    98     encodedProperty.clear();

    99     buffer.open(QIODevice::WriteOnly);

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

   101     property.setName(QString::fromAscii("EMAIL"));

   102     property.setValue(QString::fromAscii("john.citizen@example.com"));

   103     mWriter->encodeVersitProperty(property);

   104     QCOMPARE(encodedProperty, expectedResult);

   105 

   106     // AGENT property with parameter

   107     mWriter->writeCrlf(); // so it doesn't start folding

   108     buffer.close();

   109     encodedProperty.clear();

   110     buffer.open(QIODevice::WriteOnly);

   111     expectedResult =

   112 "AGENT;X-PARAMETER=VALUE:\r\n\

   113 BEGIN:VCARD\r\n\

   114 VERSION:2.1\r\n\

   115 FN:Secret Agent\r\n\

   116 END:VCARD\r\n\

   117 \r\n";

   118     property.setParameters(QMultiHash<QString,QString>());

   119     property.setName(QString::fromAscii("AGENT"));

   120     property.setValue(QString());

   121     property.insertParameter(QString::fromAscii("X-PARAMETER"),QString::fromAscii("VALUE"));

   122     QVersitDocument document;

   123     QVersitProperty embeddedProperty;

   124     embeddedProperty.setName(QString(QString::fromAscii("FN")));

   125     embeddedProperty.setValue(QString::fromAscii("Secret Agent"));

   126     document.addProperty(embeddedProperty);

   127     property.setValue(QVariant::fromValue(document));

   128     mWriter->encodeVersitProperty(property);

   129     QCOMPARE(encodedProperty, expectedResult);

   130 

   131     // Value is base64 encoded.

   132     // Check that the extra folding and the line break are added

   133     mWriter->writeCrlf(); // so it doesn't start folding

   134     buffer.close();

   135     encodedProperty.clear();

   136     buffer.open(QIODevice::WriteOnly);

   137     QByteArray value("value");

   138     expectedResult = "Springfield.HOUSE.PHOTO;ENCODING=BASE64:\r\n " + value.toBase64() + "\r\n\r\n";

   139     QStringList groups(QString::fromAscii("Springfield"));

   140     groups.append(QString::fromAscii("HOUSE"));

   141     property.setGroups(groups);

   142     property.setParameters(QMultiHash<QString,QString>());

   143     property.setName(QString::fromAscii("PHOTO"));

   144     property.setValue(value);

   145     mWriter->encodeVersitProperty(property);

   146     QCOMPARE(encodedProperty, expectedResult);

   147 

   148     // Characters other than ASCII:

   149     mWriter->writeCrlf(); // so it doesn't start folding

   150     buffer.close();

   151     encodedProperty.clear();

   152     buffer.open(QIODevice::WriteOnly);

   153     expectedResult = "ORG;CHARSET=UTF-8:" + KATAKANA_NOKIA.toUtf8() + "\r\n";

   154     property = QVersitProperty();

   155     property.setName(QLatin1String("ORG"));

   156     property.setValue(KATAKANA_NOKIA);

   157     mWriter->encodeVersitProperty(property);

   158     QCOMPARE(encodedProperty, expectedResult);

   159 

   160     // In Shift-JIS codec.

   161     mWriter->writeCrlf(); // so it doesn't start folding

   162     buffer.close();

   163     encodedProperty.clear();

   164     buffer.open(QIODevice::WriteOnly);

   165     QTextCodec* jisCodec = QTextCodec::codecForName("Shift-JIS");

   166     expectedResult = jisCodec->fromUnicode(

   167             QLatin1String("ORG:") + KATAKANA_NOKIA + QLatin1String("\r\n"));

   168     property = QVersitProperty();

   169     property.setName(QLatin1String("ORG"));

   170     property.setValue(KATAKANA_NOKIA);

   171     mWriter->setCodec(jisCodec);

   172     mWriter->encodeVersitProperty(property);

   173     QCOMPARE(encodedProperty, expectedResult);

   174 

   175     // CHARSET and QUOTED-PRINTABLE

   176     mWriter->writeCrlf(); // so it doesn't start folding

   177     buffer.close();

   178     encodedProperty.clear();

   179     buffer.open(QIODevice::WriteOnly);

   180     expectedResult = "EMAIL;CHARSET=UTF-8;ENCODING=QUOTED-PRINTABLE:john=40"

   181                      + KATAKANA_NOKIA.toUtf8() + ".com\r\n";

   182     property = QVersitProperty();

   183     property.setName(QLatin1String("EMAIL"));

   184     property.setValue(QString::fromAscii("john@%1.com").arg(KATAKANA_NOKIA));

   185     mWriter->setCodec(QTextCodec::codecForName("ISO_8859-1"));

   186     mWriter->encodeVersitProperty(property);

   187     QCOMPARE(encodedProperty, expectedResult);

   188 }

   189 

   190 void UT_QVCard21Writer::testEncodeParameters()

   191 {

   192     QByteArray encodedParameters;

   193     QBuffer buffer(&encodedParameters);

   194     mWriter->setDevice(&buffer);

   195     buffer.open(QIODevice::WriteOnly);

   196 

   197     QString typeParameterName(QString::fromAscii("TYPE"));

   198     QString encodingParameterName(QString::fromAscii("ENCODING"));

   199 

   200     // No parameters

   201     QMultiHash<QString,QString> parameters;

   202     mWriter->encodeParameters(parameters);

   203     QCOMPARE(encodedParameters, QByteArray(""));

   204 

   205     // One TYPE parameter

   206     mWriter->writeCrlf(); // so it doesn't start folding

   207     buffer.close();

   208     encodedParameters.clear();

   209     buffer.open(QIODevice::WriteOnly);

   210     parameters.insert(typeParameterName,QString::fromAscii("HOME"));

   211     mWriter->encodeParameters(parameters);

   212     QCOMPARE(encodedParameters, QByteArray(";HOME"));

   213 

   214     // Two TYPE parameters

   215     mWriter->writeCrlf(); // so it doesn't start folding

   216     buffer.close();

   217     encodedParameters.clear();

   218     buffer.open(QIODevice::WriteOnly);

   219     parameters.insert(typeParameterName,QString::fromAscii("VOICE"));

   220     mWriter->encodeParameters(parameters);

   221     QCOMPARE(encodedParameters, QByteArray(";VOICE;HOME"));

   222 

   223     // One ENCODING parameter

   224     mWriter->writeCrlf(); // so it doesn't start folding

   225     buffer.close();

   226     encodedParameters.clear();

   227     buffer.open(QIODevice::WriteOnly);

   228     parameters.clear();

   229     parameters.insert(encodingParameterName,QString::fromAscii("8BIT"));

   230     mWriter->encodeParameters(parameters);

   231     QCOMPARE(encodedParameters, QByteArray(";ENCODING=8BIT"));

   232 

   233     // Two parameters

   234     mWriter->writeCrlf(); // so it doesn't start folding

   235     buffer.close();

   236     encodedParameters.clear();

   237     buffer.open(QIODevice::WriteOnly);

   238     parameters.insert(QString::fromAscii("X-PARAM"),QString::fromAscii("VALUE"));

   239     mWriter->encodeParameters(parameters);

   240     QCOMPARE(encodedParameters, QByteArray(";X-PARAM=VALUE;ENCODING=8BIT"));

   241 }

   242 

   243 void UT_QVCard21Writer::testEncodeGroupsAndName()

   244 {

   245     QVersitProperty property;

   246     QByteArray result;

   247     QBuffer buffer(&result);

   248     mWriter->setDevice(&buffer);

   249     buffer.open(QIODevice::WriteOnly);

   250 

   251     // No groups

   252 

   253     property.setName(QString::fromAscii("name"));

   254     QByteArray expected("NAME");

   255     mWriter->encodeGroupsAndName(property);

   256     QCOMPARE(result, expected);

   257 

   258     // One group

   259     mWriter->writeCrlf(); // so it doesn't start folding

   260     buffer.close();

   261     result.clear();

   262     buffer.open(QIODevice::WriteOnly);

   263     property.setGroups(QStringList(QString::fromAscii("group")));

   264     expected = "group.NAME";

   265     mWriter->encodeGroupsAndName(property);

   266     QCOMPARE(result, expected);

   267 

   268     // Two groups

   269     mWriter->writeCrlf(); // so it doesn't start folding

   270     buffer.close();

   271     result.clear();

   272     buffer.open(QIODevice::WriteOnly);

   273     QStringList groups(QString::fromAscii("group1"));

   274     groups.append(QString::fromAscii("group2"));

   275     property.setGroups(groups);

   276     expected = "group1.group2.NAME";

   277     mWriter->encodeGroupsAndName(property);

   278     QCOMPARE(result, expected);

   279 }

   280 

   281 

   282 void UT_QVCard21Writer::testQuotedPrintableEncode()

   283 {

   284     QByteArray encodedBytes;

   285 

   286     // Nothing to encode

   287     QString nothingToEncode(QLatin1String("nothing to encode"));

   288     QVERIFY(!mWriter->quotedPrintableEncode(nothingToEncode));

   289 

   290     // Special characters

   291     QString inputOutput(QLatin1String("\n"));

   292     QVERIFY(mWriter->quotedPrintableEncode(inputOutput));

   293     QCOMPARE(inputOutput, QLatin1String("=0A"));

   294     inputOutput = QLatin1String("\r");

   295     QVERIFY(mWriter->quotedPrintableEncode(inputOutput));

   296     QCOMPARE(inputOutput, QLatin1String("=0D"));

   297     inputOutput = QLatin1String("!");

   298     QVERIFY(mWriter->quotedPrintableEncode(inputOutput));

   299     QCOMPARE(inputOutput, QLatin1String("=21"));

   300     inputOutput = QLatin1String("\"");

   301     QVERIFY(mWriter->quotedPrintableEncode(inputOutput));

   302     QCOMPARE(inputOutput, QLatin1String("=22"));

   303     inputOutput = QLatin1String("#");

   304     QVERIFY(mWriter->quotedPrintableEncode(inputOutput));

   305     QCOMPARE(inputOutput, QLatin1String("=23"));

   306     inputOutput = QLatin1String("$");

   307     QVERIFY(mWriter->quotedPrintableEncode(inputOutput));

   308     QCOMPARE(inputOutput, QLatin1String("=24"));

   309     inputOutput = QLatin1String("=");

   310     QVERIFY(mWriter->quotedPrintableEncode(inputOutput));

   311     QCOMPARE(inputOutput, QLatin1String("=3D"));

   312     inputOutput = QLatin1String("@");

   313     QVERIFY(mWriter->quotedPrintableEncode(inputOutput));

   314     QCOMPARE(inputOutput, QLatin1String("=40"));

   315     inputOutput = QLatin1String("[");

   316     QVERIFY(mWriter->quotedPrintableEncode(inputOutput));

   317     QCOMPARE(inputOutput, QLatin1String("=5B"));

   318     inputOutput = QLatin1String("\\");

   319     QVERIFY(mWriter->quotedPrintableEncode(inputOutput));

   320     QCOMPARE(inputOutput, QLatin1String("=5C"));

   321     inputOutput = QLatin1String("]");

   322     QVERIFY(mWriter->quotedPrintableEncode(inputOutput));

   323     QCOMPARE(inputOutput, QLatin1String("=5D"));

   324     inputOutput = QLatin1String("^");

   325     QVERIFY(mWriter->quotedPrintableEncode(inputOutput));

   326     QCOMPARE(inputOutput, QLatin1String("=5E"));

   327     inputOutput = QLatin1String("`");

   328     QVERIFY(mWriter->quotedPrintableEncode(inputOutput));

   329     QCOMPARE(inputOutput, QLatin1String("=60"));

   330     inputOutput = QLatin1String("{");

   331     QVERIFY(mWriter->quotedPrintableEncode(inputOutput));

   332     QCOMPARE(inputOutput, QLatin1String("=7B"));

   333     inputOutput = QLatin1String("|");

   334     QVERIFY(mWriter->quotedPrintableEncode(inputOutput));

   335     QCOMPARE(inputOutput, QLatin1String("=7C"));

   336     inputOutput = QLatin1String("}");

   337     QVERIFY(mWriter->quotedPrintableEncode(inputOutput));

   338     QCOMPARE(inputOutput, QLatin1String("=7D"));

   339     inputOutput = QLatin1String("~");

   340     QVERIFY(mWriter->quotedPrintableEncode(inputOutput));

   341     QCOMPARE(inputOutput, QLatin1String("=7E"));

   342 }

   343 

   344 QTEST_MAIN(UT_QVCard21Writer)

   345