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

**

** 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 test suite of the Qt Toolkit.

**

** $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 <QtTest/QtTest>

#ifdef QTEST_XMLPATTERNS

#include <QAbstractMessageHandler>

#include <QFileInfo>

#include <QNetworkReply>

#include <QtNetwork/QTcpServer>

#include <QtNetwork/QTcpSocket>

#include <QXmlFormatter>

#include <QXmlItem>

#include <QXmlName>

#include <QXmlQuery>

#include <QXmlResultItems>

#include <QXmlSerializer>

#include "MessageSilencer.h"

#include "MessageValidator.h"

#include "NetworkOverrider.h"

#include "PushBaseliner.h"

#include "../qabstracturiresolver/TestURIResolver.h"

#include "../qsimplexmlnodemodel/TestSimpleNodeModel.h"

#include "TestFundament.h"

#include "../network-settings.h"

#if defined(Q_OS_SYMBIAN)

#define SRCDIR ""

#endif

/*!

 \class tst_QXmlQuery

 \internal

 \since 4.4

 \brief Tests class QXmlQuery.

 This test is not intended for testing the engine, but the functionality specific

 to the QXmlQuery class.

 In other words, if you have an engine bug; don't add it here because it won't be

 tested properly. Instead add it to the test suite.

 */

class tst_QXmlQuery : public QObject

                    , private TestFundament

{

    Q_OBJECT

public:

    inline tst_QXmlQuery() : m_generatedBaselines(0)

                           , m_pushTestsCount(0)

                           , m_testNetwork(true)

    {

        Q_SET_DEFAULT_IAP

    }

private Q_SLOTS:

    void defaultConstructor() const;

    void copyConstructor() const;

    void constructorQXmlNamePool() const;

    void constructorQXmlNamePoolQueryLanguage() const;

    void constructorQXmlNamePoolWithinQSimpleXmlNodeModel() const;

    void assignmentOperator() const;

    void isValid() const;

    void sequentialExecution() const;

    void bindVariableQString() const;

    void bindVariableQStringNoExternalDeclaration() const;

    void bindVariableQXmlName() const;

    void bindVariableQXmlNameTriggerWarnings() const;

    void bindVariableQStringQIODevice() const;

    void bindVariableQStringQIODeviceWithByteArray() const;

    void bindVariableQStringQIODeviceWithString() const;

    void bindVariableQStringQIODeviceWithQFile() const;

    void bindVariableQXmlNameQIODevice() const;

    void bindVariableQXmlNameQIODeviceTriggerWarnings() const;

    void bindVariableXSLTSuccess() const;

    void bindVariableTemporaryNode() const;

    void setMessageHandler() const;

    void messageHandler() const;

    void evaluateToQAbstractXmlReceiverTriggerWarnings() const;

    void evaluateToQXmlResultItems() const;

    void evaluateToQXmlResultItemsTriggerWarnings() const;

    void evaluateToQXmlResultItemsErrorAtEnd() const;

    void evaluateToReceiver();

    void evaluateToReceiver_data() const;

    void evaluateToReceiverOnInvalidQuery() const;

    void evaluateToQStringTriggerError() const;

    void evaluateToQString() const;

    void evaluateToQString_data() const;

    void evaluateToQStringSignature() const;

    void checkGeneratedBaselines() const;

    void basicXQueryToQtTypeCheck() const;

    void basicQtToXQueryTypeCheck() const;

    void bindNode() const;

    void relativeBaseURI() const;

    void emptyBaseURI() const;

    void roundTripDateWithinQXmlItem() const;

    void bindingMissing() const;

    void bindDefaultConstructedItem() const;

    void bindDefaultConstructedItem_data() const;

    void bindEmptyNullString() const;

    void bindEmptyString() const;

    void rebindVariableSameType() const;

    void rebindVariableDifferentType() const;

    void rebindVariableWithNullItem() const;

    void eraseQXmlItemBinding() const;

    void eraseDeviceBinding() const;

    void constCorrectness() const;

    void objectSize() const;

    void setUriResolver() const;

    void uriResolver() const;

    void messageXML() const;

    void resultItemsDeallocatedQuery() const;

    void copyCheckMessageHandler() const;

    void shadowedVariables() const;

    void setFocusQXmlItem() const;

    void setFocusQUrl() const;

    void setFocusQIODevice() const;

    void setFocusQIODeviceAvoidVariableClash() const;

    void setFocusQIODeviceFailure() const;

    void setFocusQIODeviceTriggerWarnings() const;

    void setFocusQString() const;

    void setFocusQStringFailure() const;

    void setFocusQStringSignature() const;

    void recompilationWithEvaluateToResultFailing() const;

    void secondEvaluationWithEvaluateToResultFailing() const;

    void recompilationWithEvaluateToReceiver() const;

    void fnDocOnQIODeviceTimeout() const;

    void evaluateToQStringListOnInvalidQuery() const;

    void evaluateToQStringList() const;

    void evaluateToQStringListTriggerWarnings() const;

    void evaluateToQStringList_data() const;

    void evaluateToQStringListNoConversion() const;

    void evaluateToQIODevice() const;

    void evaluateToQIODeviceTriggerWarnings() const;

    void evaluateToQIODeviceSignature() const;

    void evaluateToQIODeviceOnInvalidQuery() const;

    void setQueryQIODeviceQUrl() const;

    void setQueryQIODeviceQUrlTriggerWarnings() const;

    void setQueryQString() const;

    void setQueryQUrlSuccess() const;

    void setQueryQUrlSuccess_data() const;

    void setQueryQUrlFailSucceed() const;

    void setQueryQUrlFailure() const;

    void setQueryQUrlFailure_data() const;

    void setQueryQUrlBaseURI() const;

    void setQueryQUrlBaseURI_data() const;

    void setQueryWithNonExistentQUrlOnValidQuery() const;

    void setQueryWithInvalidQueryFromQUrlOnValidQuery() const;

    void retrieveNameFromQuery() const;

    void retrieveNameFromQuery_data() const;

    void cleanupTestCase() const;

    void declareUnavailableExternal() const;

    void msvcCacheIssue() const;

    void unavailableExternalVariable() const;

    void useUriResolver() const;

    void queryWithFocusAndVariable() const;

    void undefinedFocus() const;

    void basicFocusUsage() const;

    void queryLanguage() const;

    void queryLanguageSignature() const;

    void enumQueryLanguage() const;

    void setNetworkAccessManager() const;

    void networkAccessManagerSignature() const;

    void networkAccessManagerDefaultValue() const;

    void networkAccessManager() const;

    void setInitialTemplateNameQXmlName() const;

    void setInitialTemplateNameQXmlNameSignature() const;

    void setInitialTemplateNameQString() const;

    void setInitialTemplateNameQStringSignature() const;

    void initialTemplateName() const;

    void initialTemplateNameSignature() const;

    void fnDocNetworkAccessSuccess() const;

    void fnDocNetworkAccessSuccess_data() const;

    void fnDocNetworkAccessFailure() const;

    void fnDocNetworkAccessFailure_data() const;

    void multipleDocsAndFocus() const;

    void multipleEvaluationsWithDifferentFocus() const;

    void bindVariableQXmlQuery() const;

    void bindVariableQXmlQuery_data() const;

    void bindVariableQStringQXmlQuerySignature() const;

    void bindVariableQXmlNameQXmlQuerySignature() const;

    void bindVariableQXmlNameQXmlQuery() const;

    void bindVariableQXmlQueryInvalidate() const;

    void unknownSourceLocation() const;

    void identityConstraintSuccess() const;

    void identityConstraintFailure() const;

    void identityConstraintFailure_data() const;

    // TODO call all URI resolving functions where 1) the URI resolver return a null QUrl(); 2) resolves into valid, existing URI, 3) invalid, non-existing URI.

    // TODO bind stringlists, variant lists, both ways.

    // TODO trigger serialization error, or any error in evaluateToushCallback().

    // TODO let items travle between two queries, as seen in the SDK

    // TODO what happens if the query declares local variable and external ones are provided?

private:

    enum

    {

        /**

         * One excluded, since we skip static-base-uri.xq.

         */

        ExpectedQueryCount = 29

    };

    static void checkBaseURI(const QUrl &baseURI, const QString &candidate);

    static QStringList queries();

    static const char *const queriesDirectory;

    int m_generatedBaselines;

    int m_pushTestsCount;

    const bool m_testNetwork;

};

void tst_QXmlQuery::checkBaseURI(const QUrl &baseURI, const QString &candidate)

{

    /* The use of QFileInfo::canonicalFilePath() takes into account that drive letters

     * on Windows may have different cases. */

    QVERIFY(QDir(baseURI.toLocalFile()).relativeFilePath(QFileInfo(candidate).canonicalFilePath()).startsWith("../"));

}

const char *const tst_QXmlQuery::queriesDirectory = SRCDIR "../xmlpatterns/queries/";

QStringList tst_QXmlQuery::queries()

{

    QDir dir;

    dir.cd(inputFile(QLatin1String(queriesDirectory)));

    return dir.entryList(QStringList(QLatin1String("*.xq")));

}

void tst_QXmlQuery::defaultConstructor() const

{

    /* Allocate instance in different orders. */

    {

        QXmlQuery query;

    }

    {

        QXmlQuery query1;

        QXmlQuery query2;

    }

    {

        QXmlQuery query1;

        QXmlQuery query2;

        QXmlQuery query3;

    }

}

void tst_QXmlQuery::copyConstructor() const

{

    /* Verify that we can take a const reference, and simply do a copy of a default constructed object. */

    {

        const QXmlQuery query1;

        QXmlQuery query2(query1);

    }

    /* Copy twice. */

    {

        const QXmlQuery query1;

        QXmlQuery query2(query1);

        QXmlQuery query3(query2);

    }

    /* Verify that copying default values works. */

    {

        const QXmlQuery query1;

        const QXmlQuery query2(query1);

        QCOMPARE(query2.messageHandler(), query1.messageHandler());

        QCOMPARE(query2.uriResolver(), query1.uriResolver());

        QCOMPARE(query2.queryLanguage(), query1.queryLanguage());

        QCOMPARE(query2.initialTemplateName(), query1.initialTemplateName());

        QCOMPARE(query2.networkAccessManager(), query1.networkAccessManager());

    }

    /* Check that the

     *

     * - name pool

     * - URI resolver

     * - message handler

     * - query language

     * - initial template name

     *

     *   sticks with the copy. */

    {

        MessageSilencer silencer;

        TestURIResolver resolver;

        QNetworkAccessManager networkManager;

        QXmlQuery query1(QXmlQuery::XSLT20);

        QXmlNamePool np1(query1.namePool());

        query1.setMessageHandler(&silencer);

        query1.setUriResolver(&resolver);

        query1.setNetworkAccessManager(&networkManager);

        const QXmlName name(np1, QLatin1String("localName"),

                                 QLatin1String("http://example.com/"),

                                 QLatin1String("prefix"));

        query1.setInitialTemplateName(name);

        const QXmlQuery query2(query1);

        QCOMPARE(query2.messageHandler(), static_cast<QAbstractMessageHandler *>(&silencer));

        QCOMPARE(query2.uriResolver(), static_cast<const QAbstractUriResolver *>(&resolver));

        QCOMPARE(query2.queryLanguage(), QXmlQuery::XSLT20);

        QCOMPARE(query2.initialTemplateName(), name);

        QCOMPARE(query2.networkAccessManager(), &networkManager);

        QXmlNamePool np2(query2.namePool());

        QCOMPARE(name.namespaceUri(np2), QString::fromLatin1("http://example.com/"));

        QCOMPARE(name.localName(np2), QString::fromLatin1("localName"));

        QCOMPARE(name.prefix(np2), QString::fromLatin1("prefix"));

    }

    {

        QXmlQuery original;

        original.setFocus(QXmlItem(4));

        original.setQuery(QLatin1String("."));

        QVERIFY(original.isValid());

        const QXmlQuery copy(original);

        QXmlResultItems result;

        copy.evaluateTo(&result);

        QCOMPARE(result.next().toAtomicValue(), QVariant(4));

        QVERIFY(result.next().isNull());

        QVERIFY(!result.hasError());

    }

    /* Copy, set, compare. Check that copies are independent. */

    {

        // TODO all members except queryLanguage().

    }

}

void tst_QXmlQuery::constructorQXmlNamePool() const

{

    /* Check that the namepool we are passed, is actually used. */

    QXmlNamePool np;

    QXmlQuery query(np);

    const QXmlName name(np, QLatin1String("localName"),

                            QLatin1String("http://example.com/"),

                            QLatin1String("prefix"));

    QXmlNamePool np2(query.namePool());

    QCOMPARE(name.namespaceUri(np2), QString::fromLatin1("http://example.com/"));

    QCOMPARE(name.localName(np2), QString::fromLatin1("localName"));

    QCOMPARE(name.prefix(np2), QString::fromLatin1("prefix"));

}

/*!

  Ensure that the internal variable loading mechanisms uses the user-supplied

  name pool.

  If that is not the case, different name pools are used and the code crashes.

  \since 4.5

 */

void tst_QXmlQuery::constructorQXmlNamePoolQueryLanguage() const

{

    QXmlNamePool np;

    QXmlName name(np, QLatin1String("arbitraryName"));

    QXmlQuery query(QXmlQuery::XQuery10, np);

    QBuffer input;

    input.setData("<yall/>");

    QVERIFY(input.open(QIODevice::ReadOnly));

    query.bindVariable(name, &input);

    query.setQuery("string(doc($arbitraryName))");

    QStringList result;

    query.evaluateTo(&result);

}

void tst_QXmlQuery::constructorQXmlNamePoolWithinQSimpleXmlNodeModel() const

{

    class TestCTOR : public TestSimpleNodeModel

    {

    public:

        TestCTOR(const QXmlNamePool &np) : TestSimpleNodeModel(np)

        {

        }

        void checkCTOR() const

        {

            /* If this fails to compile, the constructor has trouble with taking

             * a mutable reference.

             *

             * The reason we use the this pointer explicitly, is to avoid a compiler

             * warnings with MSVC 2005. */

            QXmlQuery(this->namePool());

        }

    };

    QXmlNamePool np;

    TestCTOR ctor(np);

    ctor.checkCTOR();

}

void tst_QXmlQuery::assignmentOperator() const

{

    class ReturnURI : public QAbstractUriResolver

    {

    public:

        virtual QUrl resolve(const QUrl &relative,

                             const QUrl &baseURI) const

        {

            return baseURI.resolved(relative);

        }

    };

    /* Assign this to this. */

    {

        QXmlQuery query;

        query = query;

        query = query;

        query = query;

        /* Just call a couple of functions to give valgrind

         * something to check. */

        QVERIFY(!query.isValid());

        query.messageHandler();

    }

    /* Assign null instances a couple of times. */

    {

        QXmlQuery query1;

        QXmlQuery query2;

        query1 = query2;

        query1 = query2;

        query1 = query2;

        /* Just call a couple of functions to give valgrind

         * something to check. */

        QVERIFY(!query1.isValid());

        query1.messageHandler();

        /* Just call a couple of functions to give valgrind

         * something to check. */

        QVERIFY(!query2.isValid());

        query2.messageHandler();

    }

    /* Create a query, set all the things it stores, and ensure it

     * travels over to the new instance. */

    {

        MessageSilencer silencer;

        const ReturnURI returnURI;

        QXmlNamePool namePool;

        QBuffer documentDevice;

        documentDevice.setData(QByteArray("<e>a</e>"));

        QVERIFY(documentDevice.open(QIODevice::ReadOnly));

        QXmlQuery original(namePool);

        QXmlName testName(namePool, QLatin1String("somethingToCheck"));

        original.setMessageHandler(&silencer);

        original.bindVariable(QLatin1String("var"), QXmlItem(1));

        original.bindVariable(QLatin1String("device"), &documentDevice);

        original.setUriResolver(&returnURI);

        original.setFocus(QXmlItem(3));

        original.setQuery(QLatin1String("$var, 1 + 1, ., string(doc($device))"));

        /* Do a copy, and check that everything followed on into the copy. No modification

         * of the copy. */

        {

            QXmlQuery copy;

            /* We use assignment operator, not copy constructor. */

            copy = original;

            QVERIFY(copy.isValid());

            QCOMPARE(copy.uriResolver(), static_cast<const QAbstractUriResolver *>(&returnURI));

            QCOMPARE(copy.messageHandler(), static_cast<QAbstractMessageHandler *>(&silencer));

            QCOMPARE(testName.localName(copy.namePool()), QString::fromLatin1("somethingToCheck"));