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

**

** Copyright (C) 2009 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 "qversitreader_p.h"

#include "versitutils_p.h"

#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");

QTM_USE_NAMESPACE

void tst_QVersitReader::init()

{

    mInputDevice = new QBuffer;

    mInputDevice->open(QBuffer::ReadWrite);

    mReader = new QVersitReader;

    mReaderPrivate = new QVersitReaderPrivate;

    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()

{

    delete mReaderPrivate;

    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");

    const QByteArray& wideDocument =

    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()

{

    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));

}

{

    buffer.open(QIODevice::ReadOnly);

    LineReader lineReader(&buffer, mAsciiCodec);

}

{