/****************************************************************************

**

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

** All rights reserved.

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

**

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

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

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

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

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

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

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

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

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

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

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

**

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

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

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

**

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

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

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "tst_qversitreader.h"

#include "qversitreader.h"

#include "qversitproperty.h"

#ifdef QT_BUILD_INTERNAL

#include "qversitreader_p.h"

#include "versitutils_p.h"

#endif

#include <QtTest/QtTest>

#include <QSignalSpy>

// Copied from tst_qcontactmanager.cpp

// Waits until __expr is true and fails if it doesn't happen within 5s.

#ifndef QTRY_VERIFY

#define QTRY_VERIFY(__expr) \

        do { \

        const int __step = 50; \

        const int __timeout = 5000; \

        if (!(__expr)) { \

            QTest::qWait(0); \

        } \

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

            QTest::qWait(__step); \

        } \

        QVERIFY(__expr); \

    } while(0)

#endif

// This says "NOKIA" in Katakana encoded with UTF-8

const QByteArray KATAKANA_NOKIA("\xe3\x83\x8e\xe3\x82\xad\xe3\x82\xa2");

const static QByteArray SAMPLE_GIF_BASE64(QByteArray(

        "R0lGODlhEgASAIAAAAAAAP///yH5BAEAAAEALAAAAAASABIAAAIdjI+py+0G"

        "wEtxUmlPzRDnzYGfN3KBaKGT6rDmGxQAOw=="));

const static QByteArray SAMPLE_GIF(QByteArray::fromBase64(SAMPLE_GIF_BASE64));

Q_DECLARE_METATYPE(QVersitDocument::VersitType);

Q_DECLARE_METATYPE(QVersitProperty);

QTM_USE_NAMESPACE

void tst_QVersitReader::init()

{

    mInputDevice = new QBuffer;

    mInputDevice->open(QBuffer::ReadWrite);

    mReader = new QVersitReader;

#ifdef QT_BUILD_INTERNAL    

    mReaderPrivate = new QVersitReaderPrivate;

#endif

    mSignalCatcher = new SignalCatcher;

    connect(mReader, SIGNAL(stateChanged(QVersitReader::State)),

            mSignalCatcher, SLOT(stateChanged(QVersitReader::State)));

    connect(mReader, SIGNAL(resultsAvailable()),

            mSignalCatcher, SLOT(resultsAvailable()));

    mAsciiCodec = QTextCodec::codecForName("ISO 8859-1");

}

void tst_QVersitReader::cleanup()

{

#ifdef QT_BUILD_INTERNAL

    delete mReaderPrivate;

#endif

    delete mReader;

    delete mInputDevice;

    delete mSignalCatcher;

}

void tst_QVersitReader::testDevice()

{

    // No device

    QVERIFY(mReader->device() == NULL);

    // Device has been set

    mReader->setDevice(mInputDevice);

    QVERIFY(mReader->device() == mInputDevice);

    delete mInputDevice;

    QVERIFY(mReader->device() == NULL);

    mInputDevice = new QBuffer;

    mInputDevice->open(QBuffer::ReadWrite);

    QVERIFY(mReader->device() == NULL);

    mReader->setDevice(mInputDevice);

    QVERIFY(mReader->device() == mInputDevice);

}

void tst_QVersitReader::testDefaultCodec()

{

    QVERIFY(mReader->defaultCodec() == QTextCodec::codecForName("UTF-8"));

    mReader->setDefaultCodec(QTextCodec::codecForName("UTF-16BE"));

    QVERIFY(mReader->defaultCodec() == QTextCodec::codecForName("UTF-16BE"));

}

void tst_QVersitReader::testReading()

{

    // No I/O device set

    QVERIFY(!mReader->startReading());

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

    // Device set, no data

    mReader->setDevice(mInputDevice);

    mInputDevice->open(QBuffer::ReadOnly);

    QVERIFY(mReader->startReading());

    QVERIFY(mReader->waitForFinished());

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

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

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

    QCOMPARE(results.count(),0);

    // Device set, one document

    const QByteArray& oneDocument =

        "BEGIN:VCARD\r\nVERSION:2.1\r\nFN:John\r\nEND:VCARD\r\n";

    mInputDevice->close();

    mInputDevice->setData(oneDocument);

    mInputDevice->open(QBuffer::ReadOnly);

    mInputDevice->seek(0);

    QVERIFY(mReader->startReading());

    QVERIFY(mReader->waitForFinished());

    results = mReader->results();

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

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

    QCOMPARE(results.count(),1);

    // Wide charset with no byte-order mark

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

    QTextCodec::ConverterState converterState(QTextCodec::IgnoreHeader);

    QString document = QString::fromAscii("BEGIN:VCARD\r\nVERSION:2.1\r\nFN:John\r\nEND:VCARD\r\n");

    const QByteArray& wideDocument =

        codec->fromUnicode(document.data(), document.length(), &converterState);

    mInputDevice->close();

    mInputDevice->setData(wideDocument);

    mInputDevice->open(QBuffer::ReadOnly);

    mInputDevice->seek(0);

    mReader->setDefaultCodec(codec);

    QVERIFY(mReader->startReading());

    QVERIFY(mReader->waitForFinished());

    results = mReader->results();

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

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

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

    mReader->setDefaultCodec(NULL);

    // Two documents

    const QByteArray& twoDocuments =

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

    mInputDevice->close();

    mInputDevice->setData(twoDocuments);

    mInputDevice->open(QBuffer::ReadOnly);

    mInputDevice->seek(0);

    QVERIFY(mReader->startReading());

    QVERIFY(mReader->waitForFinished());

    results = mReader->results();

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

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

    QCOMPARE(results.count(),2);

    // Erroneous document (missing property name)

    mInputDevice->close();

    mInputDevice->setData(QByteArray(

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

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

    mInputDevice->open(QBuffer::ReadOnly);

    mInputDevice->seek(0);

    QVERIFY(mReader->startReading());

    QVERIFY(mReader->waitForFinished());

    results = mReader->results();

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

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

    QCOMPARE(results.count(), 1);

    // Valid documents and a grouped document between them

    const QByteArray& validDocumentsAndGroupedDocument =

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

BEGIN:VCARD\r\n\

X-GROUPING:pub gang\r\n\

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

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

END:VCARD\r\n\

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

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

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

    mInputDevice->close();

    mInputDevice->setData(validDocumentsAndGroupedDocument);

    mInputDevice->open(QBuffer::ReadWrite);

    mInputDevice->seek(0);

    QVERIFY(mReader->startReading());

    QVERIFY(mReader->waitForFinished());

    results = mReader->results();

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

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

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

    QCOMPARE(results.count(),4);

    // Valid documents and a grouped document between them

    const QByteArray& validDocumentsAndGroupedDocument2 =

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

BEGIN:VCARD\r\n\

X-GROUPING:pub gang\r\n\

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

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

END:VCARD\r\n\

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

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

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

    mInputDevice->close();

    mInputDevice->setData(validDocumentsAndGroupedDocument2);

    mInputDevice->open(QBuffer::ReadWrite);

    mInputDevice->seek(0);

    QVERIFY(mReader->startReading());

    QVERIFY(mReader->waitForFinished());

    results = mReader->results();

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

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

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

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

    qApp->processEvents(); // clean up before we start sniffing signals

    // Asynchronous reading

    mInputDevice->close();

    mInputDevice->setData(twoDocuments);

    mInputDevice->open(QBuffer::ReadWrite);

    mInputDevice->seek(0);

    mSignalCatcher->mStateChanges.clear();

    mSignalCatcher->mResultsCount = 0;

    QVERIFY(mReader->startReading());

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

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

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

    QVERIFY(mSignalCatcher->mResultsCount >= 2);

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

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

    // Cancelling

    mInputDevice->close();

    mInputDevice->setData(twoDocuments);

    mInputDevice->open(QBuffer::ReadOnly);

    mInputDevice->seek(0);

    mSignalCatcher->mStateChanges.clear();

    mSignalCatcher->mResultsCount = 0;

    QVERIFY(mReader->startReading());

    mReader->cancel();

    mReader->waitForFinished();

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

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

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

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

    QVERIFY(state == QVersitReader::CanceledState

            || state == QVersitReader::FinishedState);

}

void tst_QVersitReader::testResult()

{

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

}

void tst_QVersitReader::testSetVersionFromProperty()

{

#ifndef QT_BUILD_INTERNAL

    QSKIP("Testing private API", SkipSingle);

#else

    QVersitDocument document;

    // Some other property than VERSION

    QVersitProperty property;

    property.setName(QString::fromAscii("N"));

    QVERIFY(mReaderPrivate->setVersionFromProperty(document,property));

    // VERSION property with 2.1

    property.setName(QString::fromAscii("VERSION"));

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

    QVERIFY(mReaderPrivate->setVersionFromProperty(document,property));

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

    // VERSION property with 3.0

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

    QVERIFY(mReaderPrivate->setVersionFromProperty(document,property));

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

    // VERSION property with a not supported value

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

    QVERIFY(!mReaderPrivate->setVersionFromProperty(document,property));

    // VERSION property with BASE64 encoded supported value

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

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

    QVERIFY(mReaderPrivate->setVersionFromProperty(document,property));

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

    // VERSION property with BASE64 encoded not supported value

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

    QVERIFY(!mReaderPrivate->setVersionFromProperty(document,property));

#endif

}

void tst_QVersitReader::testParseNextVersitProperty()

{

#ifndef QT_BUILD_INTERNAL

    QSKIP("Testing private API", SkipSingle);

#else

    QFETCH(QVersitDocument::VersitType, documentType);

    QFETCH(QByteArray, input);

    QFETCH(QVersitProperty, expectedProperty);

    QBuffer buffer(&input);

    buffer.open(QIODevice::ReadOnly);

    LineReader lineReader(&buffer, mAsciiCodec);

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

    if (property != expectedProperty) {

        // compare each part of the property separately for easier debugging

        QCOMPARE(property.groups(), expectedProperty.groups());

        QCOMPARE(property.name(), expectedProperty.name());

        QCOMPARE(property.valueType(), expectedProperty.valueType());

        // QVariant doesn't support == on QVersitDocuments - do it manually

        if (property.variantValue().userType() == qMetaTypeId<QVersitDocument>()) {

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

            QCOMPARE(property.value<QVersitDocument>(), expectedProperty.value<QVersitDocument>());

        }

        else

            QCOMPARE(property.variantValue(), expectedProperty.variantValue());

        // Don't check parameters because the reader can add random parameters of its own (like CHARSET)

        // QCOMPARE(property.parameters(), expectedProperty.parameters());

    }

#endif

}

void tst_QVersitReader::testParseNextVersitProperty_data()

{

#ifdef QT_BUILD_INTERNAL

    QTest::addColumn<QVersitDocument::VersitType>("documentType");

    QTest::addColumn<QByteArray>("input");

    QTest::addColumn<QVersitProperty>("expectedProperty");

    {

        QVersitProperty expectedProperty;

        expectedProperty.setName(QLatin1String("BEGIN"));

        expectedProperty.setValue(QLatin1String("vcard"));

        QTest::newRow("begin")

            << QVersitDocument::VCard21Type

            << QByteArray("Begin:vcard\r\n")

            << expectedProperty;

    }

    {

        QVersitProperty expectedProperty;

        expectedProperty.setName(QLatin1String("VERSION"));

        expectedProperty.setValue(QLatin1String("2.1"));

        expectedProperty.setValueType(QVersitProperty::PlainType);

        QTest::newRow("version")

            << QVersitDocument::VCard21Type

            << QByteArray("VERSION:2.1\r\n")

            << expectedProperty;

    }

    {

        QVersitProperty expectedProperty;

        expectedProperty.setName(QLatin1String("FN"));

        expectedProperty.setValue(QLatin1String("John"));

        expectedProperty.setValueType(QVersitProperty::PlainType);

        QTest::newRow("fn")

            << QVersitDocument::VCard21Type

            << QByteArray("FN:John\r\n")

            << expectedProperty;

    }

    {

        // "NOTE:\;\,\:\\"

        QVersitProperty expectedProperty;

        expectedProperty.setName(QLatin1String("NOTE"));

        expectedProperty.setValue(QLatin1String("\\;\\,\\:\\\\"));

        expectedProperty.setValueType(QVersitProperty::PlainType);

        QTest::newRow("vcard21 note")

            << QVersitDocument::VCard21Type

            << QByteArray("NOTE:\\;\\,\\:\\\\\r\n")

            << expectedProperty;

        expectedProperty.setValue(QLatin1String(";,:\\"));

        QTest::newRow("vcard30 note")

            << QVersitDocument::VCard30Type

            << QByteArray("NOTE:\\;\\,\\:\\\\\r\n")

            << expectedProperty;

    }

    {

        // "N:foo\;bar;foo\,bar;foo\:bar;foo\\bar;foo\\\;bar"

        QVersitProperty expectedProperty;

        expectedProperty.setName(QLatin1String("N"));

        QStringList components;

        components << QLatin1String("foo;bar")

            << QLatin1String("foo\\,bar")

            << QLatin1String("foo\\:bar")

            << QLatin1String("foo\\\\bar")

            << QLatin1String("foo\\\\;bar");

        expectedProperty.setValue(components);

        expectedProperty.setValueType(QVersitProperty::CompoundType);

        QTest::newRow("vcard21 n")

            << QVersitDocument::VCard21Type

            << QByteArray("N:foo\\;bar;foo\\,bar;foo\\:bar;foo\\\\bar;foo\\\\\\;bar\r\n")

            << expectedProperty;

        components.clear();

        components << QLatin1String("foo;bar")

            << QLatin1String("foo,bar")

            << QLatin1String("foo:bar")

            << QLatin1String("foo\\bar")

            << QLatin1String("foo\\;bar");

        expectedProperty.setValue(components);

        QTest::newRow("vcard30 n")

            << QVersitDocument::VCard30Type

            << QByteArray("N:foo\\;bar;foo\\,bar;foo\\:bar;foo\\\\bar;foo\\\\\\;bar\r\n")

            << expectedProperty;

    }

    {

        QVersitProperty expectedProperty;

        expectedProperty.setName(QLatin1String("ADR"));

        expectedProperty.setValue(QStringList(QString()));

        expectedProperty.setValueType(QVersitProperty::CompoundType);

        QTest::newRow("empty structured")

            << QVersitDocument::VCard21Type

            << QByteArray("ADR:\r\n")

            << expectedProperty;

    }

    {

        QVersitProperty expectedProperty;

        expectedProperty.setName(QLatin1String("X-CHILDREN"));

        expectedProperty.setValue(QStringList() << QLatin1String("Child1") << QLatin1String("Child2"));

        expectedProperty.setValueType(QVersitProperty::ListType);

        QTest::newRow("children")

            << QVersitDocument::VCard21Type

            << QByteArray("X-CHILDREN:Child1,Child2\r\n")

            << expectedProperty;

    }

    {

        // "NICKNAME:foo\;bar,foo\,bar,foo\:bar,foo\\bar,foo\\\,bar"

        QVersitProperty expectedProperty;

        expectedProperty.setName(QLatin1String("NICKNAME"));

        QStringList components;

        components << QLatin1String("foo\\;bar")

            << QLatin1String("foo,bar")

            << QLatin1String("foo\\:bar")

            << QLatin1String("foo\\\\bar")

            << QLatin1String("foo\\\\,bar");

        expectedProperty.setValue(components);

        expectedProperty.setValueType(QVersitProperty::ListType);

        QTest::newRow("vcard21 nickname")

            << QVersitDocument::VCard21Type

            << QByteArray("NICKNAME:foo\\;bar,foo\\,bar,foo\\:bar,foo\\\\bar,foo\\\\\\,bar\r\n")

            << expectedProperty;

        components.clear();

        components << QLatin1String("foo;bar")

            << QLatin1String("foo,bar")

            << QLatin1String("foo:bar")

            << QLatin1String("foo\\bar")

            << QLatin1String("foo\\,bar");

        expectedProperty.setValue(components);

        QTest::newRow("vcard30 nickname")

            << QVersitDocument::VCard30Type

            << QByteArray("NICKNAME:foo\\;bar,foo\\,bar,foo\\:bar,foo\\\\bar,foo\\\\\\,bar\r\n")

            << expectedProperty;

    }

    {

        // "CATEGORIES:foo\;bar,foo\,bar,foo\:bar,foo\\bar,foo\\\,bar"

        QVersitProperty expectedProperty;

        expectedProperty.setName(QLatin1String("CATEGORIES"));

        QStringList components;

        components << QLatin1String("foo\\;bar")

            << QLatin1String("foo,bar")

            << QLatin1String("foo\\:bar")

            << QLatin1String("foo\\\\bar")

            << QLatin1String("foo\\\\,bar");

        expectedProperty.setValue(components);

        expectedProperty.setValueType(QVersitProperty::ListType);

        QTest::newRow("vcard21 categories")

            << QVersitDocument::VCard21Type

            << QByteArray("CATEGORIES:foo\\;bar,foo\\,bar,foo\\:bar,foo\\\\bar,foo\\\\\\,bar\r\n")

            << expectedProperty;

        components.clear();