/****************************************************************************+
−
**+
−
** 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 <QtXmlPatterns/QXmlNamePool>+
−
#include <QtXmlPatterns/QXmlName>+
−
+
−
/*!+
−
 \class tst_QXmlName+
−
 \internal+
−
 \since 4.4+
−
 \brief Tests class QXmlName.+
−
+
−
 This test is not intended for testing the engine, but the functionality specific+
−
 to the QXmlName 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_QXmlName : public QObject+
−
{+
−
    Q_OBJECT+
−
+
−
private Q_SLOTS:+
−
    void defaultConstructor() const;+
−
    void argumentConstructor() const;+
−
    void argumentConstructor_data() const;+
−
    void argumentConstructorDefaultArguments() const;+
−
    void equalnessoperator() const;+
−
    void inequalnessoperator() const;+
−
+
−
    void isNull() const;+
−
    void operatorEqual() const;+
−
    void operatorEqual_data() const;+
−
    void operatorNotEqual() const;+
−
    void operatorNotEqual_data() const;+
−
    void toClarkName() const;+
−
    void toClarkName_data() const;+
−
    void constCorrectness() const;+
−
    void qHash() const;+
−
    void objectSize() const;+
−
    void withinQVariant() const;+
−
    void typeWithinQVariant() const;+
−
    void isNCName() const;+
−
    void isNCName_data() const;+
−
    void isNCNameSignature() const;+
−
    void fromClarkName() const;+
−
    void fromClarkName_data() const;+
−
    void fromClarkNameSignature() const;+
−
};+
−
+
−
void tst_QXmlName::defaultConstructor() const+
−
{+
−
    /* Allocate instance in different orders. */+
−
    {+
−
        QXmlName name;+
−
    }+
−
+
−
    {+
−
        QXmlName name1;+
−
        QXmlName name2;+
−
        QXmlName name3;+
−
    }+
−
}+
−
+
−
Q_DECLARE_METATYPE(QXmlNamePool)+
−
void tst_QXmlName::argumentConstructor() const+
−
{+
−
    QFETCH(QString, namespaceURI);+
−
    QFETCH(QString, localName);+
−
    QFETCH(QString, prefix);+
−
    QFETCH(QXmlNamePool, namePool);+
−
+
−
    const QXmlName name(namePool, localName, namespaceURI, prefix);+
−
+
−
    QCOMPARE(name.namespaceUri(namePool), namespaceURI);+
−
    QCOMPARE(name.localName(namePool), localName);+
−
    QCOMPARE(name.prefix(namePool), prefix);+
−
}+
−
+
−
/*!+
−
  \internal+
−
+
−
 Below we use the same QXmlNamePool instance. This means the same name pool+
−
 is used.+
−
 */+
−
void tst_QXmlName::argumentConstructor_data() const+
−
{+
−
    QTest::addColumn<QString>("namespaceURI");+
−
    QTest::addColumn<QString>("localName");+
−
    QTest::addColumn<QString>("prefix");+
−
    QTest::addColumn<QXmlNamePool>("namePool");+
−
+
−
    QXmlNamePool namePool;+
−
    QTest::newRow("Basic test")+
−
                    << QString::fromLatin1("http://example.com/Namespace1")+
−
                    << QString::fromLatin1("localName1")+
−
                    << QString::fromLatin1("prefix1")+
−
                    << namePool;+
−
+
−
    QTest::newRow("Same namespace & prefix as before, different local name.")+
−
                    << QString::fromLatin1("http://example.com/Namespace1")+
−
                    << QString::fromLatin1("localName2")+
−
                    << QString::fromLatin1("prefix1")+
−
                    << namePool;+
−
+
−
    QTest::newRow("Same namespace & local name as before, different prefix.")+
−
                    << QString::fromLatin1("http://example.com/Namespace1")+
−
                    << QString::fromLatin1("localName2")+
−
                    << QString::fromLatin1("prefix2")+
−
                    << namePool;+
−
+
−
    QTest::newRow("No prefix")+
−
                    << QString::fromLatin1("http://example.com/Namespace2")+
−
                    << QString::fromLatin1("localName3")+
−
                    << QString()+
−
                    << namePool;+
−
}+
−
+
−
/*!+
−
 Ensure that the three last arguments have default values, and that they are null strings.+
−
 */+
−
void tst_QXmlName::argumentConstructorDefaultArguments() const+
−
{+
−
    QXmlNamePool np;+
−
    const QXmlName n1(np, QLatin1String("localName"));+
−
    const QXmlName n2(np, QLatin1String("localName"), QString(), QString());+
−
+
−
    QCOMPARE(n1, n2);+
−
    QCOMPARE(n1.toClarkName(np), QString::fromLatin1("localName"));+
−
}+
−
+
−
void tst_QXmlName::equalnessoperator() const+
−
{+
−
    const QXmlName o1;+
−
    const QXmlName o2;+
−
    o1 == o2;+
−
    // TODO+
−
}+
−
+
−
void tst_QXmlName::inequalnessoperator() const+
−
{+
−
    const QXmlName o1;+
−
    const QXmlName o2;+
−
    o1 != o2;+
−
    // TODO+
−
}+
−
+
−
void tst_QXmlName::isNull() const+
−
{+
−
    /* Check default value. */+
−
    QXmlName name;+
−
    QVERIFY(name.isNull());+
−
}+
−
+
−
void tst_QXmlName::operatorEqual() const+
−
{+
−
    QFETCH(QXmlName, op1);+
−
    QFETCH(QXmlName, op2);+
−
    QFETCH(bool, expected);+
−
+
−
    QCOMPARE(op1 == op2, expected);+
−
}+
−
+
−
void tst_QXmlName::operatorEqual_data() const+
−
{+
−
    QTest::addColumn<QXmlName>("op1");+
−
    QTest::addColumn<QXmlName>("op2");+
−
    QTest::addColumn<bool>("expected");+
−
+
−
    QXmlNamePool namePool;+
−
    const QXmlName n1(namePool, QString::fromLatin1("localName1"),+
−
                                QString::fromLatin1("http://example.com/Namespace1"),+
−
                                QString::fromLatin1("prefix1"));+
−
+
−
    const QXmlName n2(namePool, QString::fromLatin1("localName2"),+
−
                                QString::fromLatin1("http://example.com/Namespace1"),+
−
                                QString::fromLatin1("prefix1"));+
−
+
−
    const QXmlName n3(namePool, QString::fromLatin1("localName2"),+
−
                                QString::fromLatin1("http://example.com/Namespace1"),+
−
                                QString::fromLatin1("prefix2"));+
−
+
−
    const QXmlName n4(namePool, QString::fromLatin1("localName3"),+
−
                                QString::fromLatin1("http://example.com/Namespace2"));+
−
+
−
    const QXmlName n5(namePool, QString::fromLatin1("localName4"),+
−
                                QString::fromLatin1("http://example.com/Namespace2"));+
−
+
−
    const QXmlName n6(namePool, QString::fromLatin1("localName4"),+
−
                                QString::fromLatin1("http://example.com/Namespace2"),+
−
                                QString::fromLatin1("prefix3"));+
−
+
−
    const QXmlName n7(namePool, QString::fromLatin1("localName2"),+
−
                                QString::fromLatin1("http://example.com/Namespace2"),+
−
                                QString::fromLatin1("prefix3"));+
−
+
−
    QTest::newRow(qPrintable(n1.toClarkName(namePool)))+
−
        << n1+
−
        << n1+
−
        << true;+
−
+
−
    QTest::newRow(qPrintable(n2.toClarkName(namePool)))+
−
        << n2+
−
        << n2+
−
        << true;+
−
+
−
    QTest::newRow(qPrintable(n3.toClarkName(namePool)))+
−
        << n3+
−
        << n3+
−
        << true;+
−
+
−
    QTest::newRow(qPrintable(n4.toClarkName(namePool)))+
−
        << n4+
−
        << n4+
−
        << true;+
−
+
−
    QTest::newRow(qPrintable(n5.toClarkName(namePool)))+
−
        << n5+
−
        << n5+
−
        << true;+
−
+
−
    QTest::newRow(qPrintable(n6.toClarkName(namePool)))+
−
        << n6+
−
        << n6+
−
        << true;+
−
+
−
    QTest::newRow(qPrintable(n7.toClarkName(namePool)))+
−
        << n7+
−
        << n7+
−
        << true;+
−
+
−
    QTest::newRow("Prefix differs")+
−
        << n2+
−
        << n3+
−
        << true;+
−
+
−
    QTest::newRow("No prefix vs. prefix")+
−
        << n5+
−
        << n6+
−
        << true;+
−
+
−
    QTest::newRow("Local name differs")+
−
        << n1+
−
        << n2+
−
        << false;+
−
+
−
    QTest::newRow("Namespace differs")+
−
        << n2+
−
        << n7+
−
        << false;+
−
}+
−
+
−
void tst_QXmlName::operatorNotEqual() const+
−
{+
−
    QFETCH(QXmlName, op1);+
−
    QFETCH(QXmlName, op2);+
−
    QFETCH(bool, expected);+
−
+
−
    QCOMPARE(op1 != op2, !expected);+
−
}+
−
+
−
void tst_QXmlName::operatorNotEqual_data() const+
−
{+
−
    operatorEqual_data();+
−
}+
−
+
−
/*!+
−
  Check that functions have the correct const qualification.+
−
 */+
−
void tst_QXmlName::constCorrectness() const+
−
{+
−
    const QXmlName name;+
−
+
−
    /* isNull() */+
−
    QVERIFY(name.isNull());+
−
+
−
    /* operator==() */+
−
    QVERIFY(name == name);+
−
+
−
    /* operator!=() */+
−
    QVERIFY(!(name != name));+
−
+
−
    QXmlNamePool namePool;+
−
    const QXmlName name2(namePool, QLatin1String("localName"), QLatin1String("http://example.com/"), QLatin1String("prefix"));+
−
+
−
    /* namespaceUri(). */+
−
    QCOMPARE(name2.namespaceUri(namePool), QLatin1String("http://example.com/"));+
−
+
−
    /* localName(). */+
−
    QCOMPARE(name2.localName(namePool), QLatin1String("localName"));+
−
+
−
    /* prefix(). */+
−
    QCOMPARE(name2.prefix(namePool), QLatin1String("prefix"));+
−
+
−
    /* toClarkname(). */+
−
    QCOMPARE(name2.toClarkName(namePool), QLatin1String("{http://example.com/}prefix:localName"));+
−
}+
−
+
−
void tst_QXmlName::qHash() const+
−
{+
−
    /* Just call it, so we know it exist and that we don't trigger undefined+
−
     * behavior. We can't test the return value, since it's opaque. */+
−
    QXmlName name;+
−
    ::qHash(name);+
−
}+
−
+
−
void tst_QXmlName::objectSize() const+
−
{+
−
    QVERIFY2(sizeof(QXmlName) == sizeof(qint64), "QXmlName should have at least a d-pointer.");+
−
}+
−
+
−
void tst_QXmlName::toClarkName() const+
−
{+
−
    QFETCH(QString, produced);+
−
    QFETCH(QString, expected);+
−
+
−
    QCOMPARE(produced, expected);+
−
}+
−
+
−
void tst_QXmlName::toClarkName_data() const+
−
{+
−
    QTest::addColumn<QString>("produced");+
−
    QTest::addColumn<QString>("expected");+
−
+
−
    QXmlNamePool np;+
−
+
−
    /* A null QXmlName. */+
−
    {+
−
        const QXmlName n;+
−
        QTest::newRow("") << n.toClarkName(np)+
−
                          << QString::fromLatin1("QXmlName(null)");+
−
    }+
−
+
−
    {+
−
        const QXmlName n(np, QLatin1String("localName"));+
−
        QTest::newRow("") << n.toClarkName(np)+
−
                          << QString::fromLatin1("localName");+
−
    }+
−
+
−
    /* Local name with namespace URI, empty prefix. */+
−
    {+
−
        const QXmlName n(np, QLatin1String("localName"),+
−
                             QLatin1String("http://example.com/"));+
−
        QTest::newRow("") << n.toClarkName(np)+
−
                          << QString::fromLatin1("{http://example.com/}localName");+
−
    }+
−
+
−
    /* Local name with namespace URI and prefix. */+
−
    {+
−
        const QXmlName n(np, QLatin1String("localName"),+
−
                             QLatin1String("http://example.com/"),+
−
                             QLatin1String("p"));+
−
        QTest::newRow("") << n.toClarkName(np)+
−
                          << QString::fromLatin1("{http://example.com/}p:localName");+
−
    }+
−
}+
−
+
−
/*!+
−
  Check that QXmlName can be used inside QVariant.+
−
 */+
−
void tst_QXmlName::withinQVariant() const+
−
{+
−
    /* The extra paranthesis silences a warning on win32-msvc2005. */+
−
    QVariant value(qVariantFromValue(QXmlName()));+
−
}+
−
+
−
/*!+
−
 Check that the user type of QXmlName holds.+
−
 */+
−
void tst_QXmlName::typeWithinQVariant() const+
−
{+
−
    const int qxmlNameType = QVariant(qVariantFromValue(QXmlName())).userType();+
−
+
−
    const QVariant value(qVariantFromValue(QXmlName()));+
−
+
−
    QCOMPARE(value.userType(), qxmlNameType);+
−
}+
−
+
−
/*!+
−
  We don't do full testing here. Don't have the resources for it. We simply assume+
−
  we use a code path which is fully tested elsewhere.+
−
 */+
−
void tst_QXmlName::isNCName() const+
−
{+
−
    QFETCH(QString, input);+
−
    QFETCH(bool, expectedValidity);+
−
+
−
    QCOMPARE(QXmlName::isNCName(input), expectedValidity);+
−
}+
−
+
−
void tst_QXmlName::isNCName_data() const+
−
{+
−
    QTest::addColumn<QString>("input");+
−
    QTest::addColumn<bool>("expectedValidity");+
−
+
−
    QTest::newRow("empty string")+
−
        << QString()+
−
        << false;+
−
+
−
    QTest::newRow("A number")+
−
        << QString::fromLatin1("1")+
−
        << false;+
−
+
−
    QTest::newRow("Simple valid string")+
−
        << QString::fromLatin1("abc")+
−
        << true;+
−
+
−
    QTest::newRow("Simple valid string")+
−
        << QString::fromLatin1("abc.123")+
−
        << true;+
−
}+
−
+
−
void tst_QXmlName::isNCNameSignature() const+
−
{+
−
    const QString constQString;+
−
+
−
    /* Verify that we can take a const QString. */+
−
    QXmlName::isNCName(constQString);+
−
+
−
    /* Verify that we can take a temporary QString. */+
−
    QXmlName::isNCName(QString());+
−
}+
−
+
−
void tst_QXmlName::fromClarkName() const+
−
{+
−
    QFETCH(QString,         input);+
−
    QFETCH(QXmlName,        expected);+
−
    QFETCH(QXmlNamePool,    namePool);+
−
+
−
    QCOMPARE(QXmlName::fromClarkName(input, namePool), expected);+
−
}+
−
+
−
void tst_QXmlName::fromClarkName_data() const+
−
{+
−
    QTest::addColumn<QString>("input");+
−
    QTest::addColumn<QXmlName>("expected");+
−
    QTest::addColumn<QXmlNamePool>("namePool");+
−
+
−
    QXmlNamePool np;+
−
+
−
    QTest::newRow("A null string")+
−
        << QString()+
−
        << QXmlName()+
−
        << np;+
−
+
−
    QTest::newRow("An empty string")+
−
        << QString(QLatin1String(""))+
−
        << QXmlName()+
−
        << np;+
−
+
−
    QTest::newRow("A single local name")+
−
        << QString(QLatin1String("foo"))+
−
        << QXmlName(np, QLatin1String("foo"))+
−
        << np;+
−
+
−
    QTest::newRow("Has prefix, but no namespace, that's invalid")+
−
        << QString(QLatin1String("prefix:foo"))+
−
        << QXmlName()+
−
        << np;+
−
+
−
    QTest::newRow("Namespace, local name, no prefix")+
−
        << QString(QLatin1String("{def}abc"))+
−
        << QXmlName(np, QLatin1String("abc"), QLatin1String("def"))+
−
        << np;+
−
+
−
    QTest::newRow("Namespace, local name, prefix")+
−
        << QString(QLatin1String("{def}p:abc"))+
−
        << QXmlName(np, QLatin1String("abc"), QLatin1String("def"), QLatin1String("p"))+
−
        << np;+
−
+
−
    QTest::newRow("Namespace, local name, prefix syntax error")+
−
        << QString(QLatin1String("{def}:abc"))+
−
        << QXmlName()+
−
        << np;+
−
+
−
    QTest::newRow("Namespace, local name syntax error, prefix")+
−
        << QString(QLatin1String("{def}p:"))+
−
        << QXmlName()+
−
        << np;+
−
+
−
    QTest::newRow("Only local name which is invalid")+
−
        << QString(QLatin1String(":::"))+
−
        << QXmlName()+
−
        << np;+
−
+
−
    QTest::newRow("Namespace, invalid local name")+
−
        << QString(QLatin1String("{def}a|bc"))+
−
        << QXmlName()+
−
        << np;+
−
+
−
    QTest::newRow("Namespace, local name, invalid prefix")+
−
        << QString(QLatin1String("{def}a|b:c"))+
−
        << QXmlName()+
−
        << np;+
−
+
−
    QTest::newRow("A single left curly, invalid")+
−
        << QString(QLatin1String("{"))+
−
        << QXmlName()+
−
        << np;+
−
+
−
    QTest::newRow("A single left curly, invalid")+
−
        << QString(QLatin1String("{aaswd"))+
−
        << QXmlName()+
−
        << np;+
−
}+
−
+
−
void tst_QXmlName::fromClarkNameSignature() const+
−
{+
−
    /* We should take const references. */+
−
    const QXmlNamePool np;+
−
    const QString in;+
−
+
−
    QXmlName::fromClarkName(in, np);+
−
}+
−
+
−
QTEST_MAIN(tst_QXmlName)+
−
+
−
#include "tst_qxmlname.moc"+
−
#else+
−
QTEST_NOOP_MAIN+
−
#endif+
−
// vim: et:ts=4:sw=4:sts=4+
−