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

**

** 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>

#include <QtXml/QtXml>

#if defined(Q_OS_WINCE)

#include <QtGui/QFontDatabase>

#endif

//TESTED_CLASS=QCss

//TESTED_FILES=gui/text/qcssparser.cpp gui/text/qcssparser_p.h

#include "private/qcssparser_p.h"

class tst_QCssParser : public QObject

{

    Q_OBJECT

public slots:

    void initTestCase();

    void cleanupTestCase();

private slots:

    void scanner_data();

    void scanner();

    void term_data();

    void term();

    void expr_data();

    void expr();

    void import();

    void media();

    void page();

    void ruleset();

    void selector_data();

    void selector();

    void prio();

    void escapes();

    void malformedDeclarations_data();

    void malformedDeclarations();

    void invalidAtKeywords();

    void marginValue();

    void marginValue_data();

    void colorValue_data();

    void colorValue();

    void styleSelector_data();

    void styleSelector();

    void specificity_data();

    void specificity();

    void specificitySort_data();

    void specificitySort();

    void rulesForNode_data();

    void rulesForNode();

    void shorthandBackgroundProperty_data();

    void shorthandBackgroundProperty();

    void pseudoElement_data();

    void pseudoElement();

    void gradient_data();

    void gradient();

    void extractFontFamily_data();

    void extractFontFamily();

    void extractBorder_data();

    void extractBorder();

    void noTextDecoration();

    void quotedAndUnquotedIdentifiers();

private:

#if defined(Q_OS_WINCE)

    int m_timesFontId;

#endif

};

void tst_QCssParser::initTestCase()

{

#if defined(Q_OS_WINCE)

    QFontDatabase fontDB;

    m_timesFontId = -1;

    if (!fontDB.families().contains("Times New Roman")) {

        m_timesFontId = QFontDatabase::addApplicationFont("times.ttf");

        QVERIFY(m_timesFontId != -1);

    }

#endif

}

void tst_QCssParser::cleanupTestCase()

{

#if defined(Q_OS_WINCE)

    if (m_timesFontId != -1)

        QFontDatabase::removeApplicationFont(m_timesFontId);

#endif

}

void tst_QCssParser::scanner_data()

{

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

    QTest::addColumn<QString>("output");

#if !defined(Q_OS_IRIX) && !defined(Q_OS_WINCE) && !defined(Q_OS_SYMBIAN)

    QDir d(SRCDIR);

#else

    QDir d(QDir::current());

#endif

    d.cd("testdata");

    d.cd("scanner");

    foreach (QFileInfo test, d.entryInfoList(QDir::Dirs | QDir::NoDotAndDotDot)) {

        QString dir = test.absoluteFilePath() + QDir::separator();

        QTest::newRow(qPrintable(test.baseName()))

            << dir + "input"

            << dir + "output"

            ;

    }

}

static char *tokenName(QCss::TokenType t)

{

    switch (t) {

        case QCss::NONE: return "NONE";

        case QCss::S: return "S";

        case QCss::CDO: return "CDO";

        case QCss::CDC: return "CDC";

        case QCss::INCLUDES: return "INCLUDES";

        case QCss::DASHMATCH: return "DASHMATCH";

        case QCss::LBRACE: return "LBRACE";

        case QCss::PLUS: return "PLUS";

        case QCss::GREATER: return "GREATER";

        case QCss::COMMA: return "COMMA";

        case QCss::STRING: return "STRING";

        case QCss::INVALID: return "INVALID";

        case QCss::IDENT: return "IDENT";

        case QCss::HASH: return "HASH";

        case QCss::ATKEYWORD_SYM: return "ATKEYWORD_SYM";

        case QCss::EXCLAMATION_SYM: return "EXCLAMATION_SYM";

        case QCss::LENGTH: return "LENGTH";

        case QCss::PERCENTAGE: return "PERCENTAGE";

        case QCss::NUMBER: return "NUMBER";

        case QCss::FUNCTION: return "FUNCTION";

        case QCss::COLON: return "COLON";

        case QCss::SEMICOLON: return "SEMICOLON";

        case QCss::RBRACE: return "RBRACE";

        case QCss::SLASH: return "SLASH";

        case QCss::MINUS: return "MINUS";

        case QCss::DOT: return "DOT";

        case QCss::STAR: return "STAR";

        case QCss::LBRACKET: return "LBRACKET";

        case QCss::RBRACKET: return "RBRACKET";

        case QCss::EQUAL: return "EQUAL";

        case QCss::LPAREN: return "LPAREN";

        case QCss::RPAREN: return "RPAREN";

        case QCss::OR: return "OR";

    }

    return "";

}

static void debug(const QVector<QCss::Symbol> &symbols, int index = -1)

{

    qDebug() << "all symbols:";

    for (int i = 0; i < symbols.count(); ++i)

        qDebug() << "(" << i << "); Token:" << tokenName(symbols.at(i).token) << "; Lexem:" << symbols.at(i).lexem();

    if (index != -1)

        qDebug() << "failure at index" << index;

}

//static void debug(const QCss::Parser &p) { debug(p.symbols); }

void tst_QCssParser::scanner()

{

    QFETCH(QString, input);

    QFETCH(QString, output);

    QFile inputFile(input);

    QVERIFY(inputFile.open(QIODevice::ReadOnly|QIODevice::Text));

    QVector<QCss::Symbol> symbols;

    QCss::Scanner::scan(QCss::Scanner::preprocess(QString::fromUtf8(inputFile.readAll())), &symbols);

    QVERIFY(symbols.count() > 1);

    QVERIFY(symbols.last().token == QCss::S);

    QVERIFY(symbols.last().lexem() == QLatin1String("\n"));

    symbols.remove(symbols.count() - 1, 1);

    QFile outputFile(output);

    QVERIFY(outputFile.open(QIODevice::ReadOnly|QIODevice::Text));

    QStringList lines;

    while (!outputFile.atEnd()) {

        QString line = QString::fromUtf8(outputFile.readLine());

        if (line.endsWith(QLatin1Char('\n')))

            line.chop(1);

        lines.append(line);

    }

    if (lines.count() != symbols.count()) {

        debug(symbols);

        QCOMPARE(lines.count(), symbols.count());

    }

    for (int i = 0; i < lines.count(); ++i) {

        QStringList l = lines.at(i).split(QChar::fromLatin1('|'));

        QCOMPARE(l.count(), 2);

        const QString expectedToken = l.at(0);

        const QString expectedLexem = l.at(1);

        QString actualToken = QString::fromLatin1(tokenName(symbols.at(i).token));

        if (actualToken != expectedToken) {

            debug(symbols, i);

            QCOMPARE(actualToken, expectedToken);

        }

        if (symbols.at(i).lexem() != expectedLexem) {

            debug(symbols, i);

            QCOMPARE(symbols.at(i).lexem(), expectedLexem);

        }

    }

}

Q_DECLARE_METATYPE(QCss::Value)

void tst_QCssParser::term_data()

{

    QTest::addColumn<bool>("parseSuccess");

    QTest::addColumn<QString>("css");

    QTest::addColumn<QCss::Value>("expectedValue");

    QCss::Value val;

    val.type = QCss::Value::Percentage;

    val.variant = QVariant(double(200));

    QTest::newRow("percentage") << true << "200%" << val;

    val.type = QCss::Value::Length;

    val.variant = QString("10px");

    QTest::newRow("px") << true << "10px" << val;

    val.type = QCss::Value::Length;

    val.variant = QString("10cm");

    QTest::newRow("cm") << true << "10cm" << val;

    val.type = QCss::Value::Length;

    val.variant = QString("10mm");

    QTest::newRow("mm") << true << "10mm" << val;

    val.type = QCss::Value::Length;

    val.variant = QString("10pt");

    QTest::newRow("pt") << true << "10pt" << val;

    val.type = QCss::Value::Length;

    val.variant = QString("10pc");

    QTest::newRow("pc") << true << "10pc" << val;

    val.type = QCss::Value::Length;

    val.variant = QString("42in");

    QTest::newRow("inch") << true << "42in" << val;

    val.type = QCss::Value::Length;

    val.variant = QString("10deg");

    QTest::newRow("deg") << true << "10deg" << val;

    val.type = QCss::Value::Length;

    val.variant = QString("10rad");

    QTest::newRow("rad") << true << "10rad" << val;

    val.type = QCss::Value::Length;

    val.variant = QString("10grad");

    QTest::newRow("grad") << true << "10grad" << val;

    val.type = QCss::Value::Length;

    val.variant = QString("10ms");

    QTest::newRow("time") << true << "10ms" << val;

    val.type = QCss::Value::Length;

    val.variant = QString("10s");

    QTest::newRow("times") << true << "10s" << val;

    val.type = QCss::Value::Length;

    val.variant = QString("10hz");

    QTest::newRow("hz") << true << "10hz" << val;

    val.type = QCss::Value::Length;

    val.variant = QString("10khz");

    QTest::newRow("khz") << true << "10khz" << val;

    val.type = QCss::Value::Length;

    val.variant = QString("10myunit");

    QTest::newRow("dimension") << true << "10myunit" << val;

    val.type = QCss::Value::Percentage;

    val.type = QCss::Value::Percentage;

    val.variant = QVariant(double(-200));

    QTest::newRow("minuspercentage") << true << "-200%" << val;

    val.type = QCss::Value::Length;

    val.variant = QString("10em");

    QTest::newRow("ems") << true << "10em" << val;

    val.type = QCss::Value::String;

    val.variant = QVariant(QString("foo"));

    QTest::newRow("string") << true << "\"foo\"" << val;

    val.type = QCss::Value::Function;

    val.variant = QVariant(QStringList() << "myFunc" << "23, (nested text)");

    QTest::newRow("function") << true << "myFunc(23, (nested text))" << val;

    QTest::newRow("function_failure") << false << "myFunction((blah)" << val;

    QTest::newRow("function_failure2") << false << "+myFunc(23, (nested text))" << val;

    val.type = QCss::Value::Color;

    val.variant = QVariant(QColor("#12ff34"));

    QTest::newRow("hexcolor") << true << "#12ff34" << val;

    val.type = QCss::Value::Color;

    val.variant = QVariant(QColor("#ffbb00"));

    QTest::newRow("hexcolor2") << true << "#fb0" << val;

    QTest::ignoreMessage(QtWarningMsg, "QCssParser::parseHexColor: Unknown color name '#cafebabe'");

    QTest::newRow("hexcolor_failure") << false << "#cafebabe" << val;

    val.type = QCss::Value::Uri;

    val.variant = QString("www.kde.org");

    QTest::newRow("uri1") << true << "url(\"www.kde.org\")" << val;

    QTest::newRow("uri2") << true << "url(www.kde.org)" << val;

    val.type = QCss::Value::KnownIdentifier;

    val.variant = int(QCss::Value_Italic);

    QTest::newRow("italic") << true << "italic" << val;

    val.type = QCss::Value::KnownIdentifier;

    val.variant = int(QCss::Value_Italic);

    QTest::newRow("ItaLIc") << true << "ItaLIc" << val;

}

void tst_QCssParser::term()

{

    QFETCH(bool, parseSuccess);

    QFETCH(QString, css);

    QFETCH(QCss::Value, expectedValue);

    QCss::Parser parser(css);

    QCss::Value val;

    QVERIFY(parser.testTerm());

    QCOMPARE(parser.parseTerm(&val), parseSuccess);

    if (parseSuccess) {

        QCOMPARE(int(val.type), int(expectedValue.type));

        if (val.variant != expectedValue.variant) {

            qDebug() << "val.variant:" << val.variant << "expectedValue.variant:" << expectedValue.variant;

            QCOMPARE(val.variant, expectedValue.variant);

        }

    }

}

Q_DECLARE_METATYPE(QVector<QCss::Value>)

void tst_QCssParser::expr_data()

{

    QTest::addColumn<bool>("parseSuccess");

    QTest::addColumn<QString>("css");

    QTest::addColumn<QVector<QCss::Value> >("expectedValues");

    QVector<QCss::Value> values;

    QCss::Value val;

    QCss::Value comma;

    comma.type = QCss::Value::TermOperatorComma;

    val.type = QCss::Value::Identifier;

    val.variant = QLatin1String("foo");

    values << val;

    values << comma;

    val.variant = QLatin1String("bar");

    values << val;

    values << comma;

    val.variant = QLatin1String("baz");

    values << val;

    QTest::newRow("list") << true << "foo, bar, baz" << values;

    values.clear();

}

void tst_QCssParser::expr()

{

    QFETCH(bool, parseSuccess);

    QFETCH(QString, css);

    QFETCH(QVector<QCss::Value>, expectedValues);

    QCss::Parser parser(css);

    QVector<QCss::Value> values;

    QVERIFY(parser.testExpr());

    QCOMPARE(parser.parseExpr(&values), parseSuccess);

    if (parseSuccess) {

        QCOMPARE(values.count(), expectedValues.count());

        for (int i = 0; i < values.count(); ++i) {

            QCOMPARE(int(values.at(i).type), int(expectedValues.at(i).type));

            QCOMPARE(values.at(i).variant, expectedValues.at(i).variant);

        }

    }

}

void tst_QCssParser::import()

{

    QCss::Parser parser("@import \"plainstring\";");

    QVERIFY(parser.testImport());

    QCss::ImportRule rule;

    QVERIFY(parser.parseImport(&rule));

    QCOMPARE(rule.href, QString("plainstring"));

    parser = QCss::Parser("@import url(\"www.kde.org\") print/*comment*/,screen;");

    QVERIFY(parser.testImport());

    QVERIFY(parser.parseImport(&rule));

    QCOMPARE(rule.href, QString("www.kde.org"));

    QCOMPARE(rule.media.count(), 2);

    QCOMPARE(rule.media.at(0), QString("print"));

    QCOMPARE(rule.media.at(1), QString("screen"));

}

void tst_QCssParser::media()

{

    QCss::Parser parser("@media print/*comment*/,screen /*comment to ignore*/{ }");

    QVERIFY(parser.testMedia());

    QCss::MediaRule rule;

    QVERIFY(parser.parseMedia(&rule));

    QCOMPARE(rule.media.count(), 2);

    QCOMPARE(rule.media.at(0), QString("print"));

    QCOMPARE(rule.media.at(1), QString("screen"));

    QVERIFY(rule.styleRules.isEmpty());

}

void tst_QCssParser::page()

{

    QCss::Parser parser("@page :first/*comment to ignore*/{ }");

    QVERIFY(parser.testPage());

    QCss::PageRule rule;

    QVERIFY(parser.parsePage(&rule));

    QCOMPARE(rule.selector, QString("first"));

    QVERIFY(rule.declarations.isEmpty());

}

void tst_QCssParser::ruleset()

{

    {

        QCss::Parser parser("p/*foo*/{ }");

        QVERIFY(parser.testRuleset());

        QCss::StyleRule rule;

        QVERIFY(parser.parseRuleset(&rule));

        QCOMPARE(rule.selectors.count(), 1);

        QCOMPARE(rule.selectors.at(0).basicSelectors.count(), 1);

        QCOMPARE(rule.selectors.at(0).basicSelectors.at(0).elementName, QString("p"));

        QVERIFY(rule.declarations.isEmpty());

    }

    {

        QCss::Parser parser("p/*comment*/,div{ }");

        QVERIFY(parser.testRuleset());

        QCss::StyleRule rule;

        QVERIFY(parser.parseRuleset(&rule));

        QCOMPARE(rule.selectors.count(), 2);

        QCOMPARE(rule.selectors.at(0).basicSelectors.count(), 1);

        QCOMPARE(rule.selectors.at(0).basicSelectors.at(0).elementName, QString("p"));

        QCOMPARE(rule.selectors.at(1).basicSelectors.count(), 1);

        QCOMPARE(rule.selectors.at(1).basicSelectors.at(0).elementName, QString("div"));

        QVERIFY(rule.declarations.isEmpty());

    }

    {

        QCss::Parser parser(":before, :after { }");

        QVERIFY(parser.testRuleset());

        QCss::StyleRule rule;

        QVERIFY(parser.parseRuleset(&rule));

        QCOMPARE(rule.selectors.count(), 2);

        QCOMPARE(rule.selectors.at(0).basicSelectors.count(), 1);

        QCOMPARE(rule.selectors.at(0).basicSelectors.at(0).pseudos.count(), 1);

        QCOMPARE(rule.selectors.at(0).basicSelectors.at(0).pseudos.at(0).name, QString("before"));

        QCOMPARE(rule.selectors.at(1).basicSelectors.count(), 1);

        QCOMPARE(rule.selectors.at(1).basicSelectors.at(0).pseudos.count(), 1);

        QCOMPARE(rule.selectors.at(1).basicSelectors.at(0).pseudos.at(0).name, QString("after"));

        QVERIFY(rule.declarations.isEmpty());

    }

}

Q_DECLARE_METATYPE(QCss::Selector)

void tst_QCssParser::selector_data()

{

    QTest::addColumn<QString>("css");

    QTest::addColumn<QCss::Selector>("expectedSelector");

    {

        QCss::Selector sel;

        QCss::BasicSelector basic;

        basic.elementName = "p";