File indexing completed on 2024-11-17 03:42:07

 /*
   This file is part of the KTextTemplate library
 
   SPDX-FileCopyrightText: 2009, 2010 Stephen Kelly <steveire@gmail.com>
 
   SPDX-License-Identifier: LGPL-2.1-or-later
 
 */
 
 #ifndef BUILTINSTEST_H
 #define BUILTINSTEST_H
 
 #include <QDebug>
 #include <QFileInfo>
 #include <QTest>
 
 #include "cachingloaderdecorator.h"
 #include "context.h"
 #include "engine.h"
 #include "filterexpression.h"
 #include "ktexttemplate_paths.h"
 #include "template.h"
 #include "util.h"
 #include <metaenumvariable_p.h>
 
 using Dict = QHash<QString, QVariant>;
 
 Q_DECLARE_METATYPE(KTextTemplate::Error)
 
 using namespace KTextTemplate;
 
 /**
   For use with tests.
 */
 class OtherClass : public QObject
 {
     Q_OBJECT
     Q_PROPERTY(QString method READ method)
     Q_PROPERTY(Animals animals READ animals)
 public:
     enum Animals { Lions, Tigers, Bears };
     Q_ENUMS(Animals)
 
     OtherClass(QObject *parent = {})
         : QObject(parent)
     {
     }
     OtherClass(Animals animals, QObject *parent = {})
         : QObject(parent)
         , m_animals(animals)
     {
     }
 
     Animals animals() const
     {
         return m_animals;
     }
 
     QString method() const
     {
         return QStringLiteral("OtherClass::method");
     }
 
 private:
     Animals m_animals = Tigers;
 };
 
 /**
   For use with tests.
 */
 class SomeClass : public QObject
 {
     Q_OBJECT
     Q_PROPERTY(QString method READ method)
     Q_PROPERTY(QVariant otherClass READ otherClass)
 
 public:
     enum FirstEnum { Employee, Employer, Manager };
 
     enum SecondEnum { Voter = 2, Consumer = 4, Citizen = 8 };
 
     Q_ENUMS(FirstEnum SecondEnum)
 
     SomeClass(QObject *parent = {})
         : QObject(parent)
         , m_other(new OtherClass(this))
     {
     }
 
     QString method() const
     {
         return QStringLiteral("SomeClass::method");
     }
 
     QVariant otherClass() const
     {
         return QVariant::fromValue(m_other);
     }
 
     QString nonAccessibleMethod(const QString &str)
     {
         return str;
     }
 
 private:
     QObject *m_other;
 };
 
 /**
   For use with tests.
  */
 class GadgetClass
 {
     Q_GADGET
     Q_PROPERTY(PersonName personName READ personName)
 public:
     enum PersonName { Mike = 0, Natalie, Oliver };
     Q_ENUM(PersonName)
 
     GadgetClass() = default;
     GadgetClass(PersonName pn)
         : m_personName(pn)
     {
     }
 
     PersonName personName() const
     {
         return m_personName;
     }
 
 private:
     PersonName m_personName = Oliver;
 };
 Q_DECLARE_METATYPE(GadgetClass)
 
 class NoEscapeOutputStream : public OutputStream
 {
 public:
     NoEscapeOutputStream()
     {
     }
 
     NoEscapeOutputStream(QTextStream *stream)
         : OutputStream(stream)
     {
     }
 
     QSharedPointer<OutputStream> clone(QTextStream *stream) const override
     {
         return QSharedPointer<NoEscapeOutputStream>::create(stream);
     }
 
     QString escape(const QString &input) const override
     {
         return input;
     }
 };
 
 class JSOutputStream : public OutputStream
 {
 public:
     JSOutputStream()
     {
     }
 
     JSOutputStream(QTextStream *stream)
         : OutputStream(stream)
     {
     }
 
     QSharedPointer<OutputStream> clone(QTextStream *stream) const override
     {
         return QSharedPointer<JSOutputStream>::create(stream);
     }
 
     QString escape(const QString &input) const override
     {
         QList<std::pair<QString, QString>> jsEscapes;
         jsEscapes << std::pair<QString, QString>(QChar::fromLatin1('\\'), QStringLiteral("\\u005C"))
                   << std::pair<QString, QString>(QChar::fromLatin1('\''), QStringLiteral("\\u0027"))
                   << std::pair<QString, QString>(QChar::fromLatin1('\"'), QStringLiteral("\\u0022"))
                   << std::pair<QString, QString>(QChar::fromLatin1('>'), QStringLiteral("\\u003E"))
                   << std::pair<QString, QString>(QChar::fromLatin1('<'), QStringLiteral("\\u003C"))
                   << std::pair<QString, QString>(QChar::fromLatin1('&'), QStringLiteral("\\u0026"))
                   << std::pair<QString, QString>(QChar::fromLatin1('='), QStringLiteral("\\u003D"))
                   << std::pair<QString, QString>(QChar::fromLatin1('-'), QStringLiteral("\\u002D"))
                   << std::pair<QString, QString>(QChar::fromLatin1(';'), QStringLiteral("\\u003B"))
                   << std::pair<QString, QString>(QChar(0x2028), QStringLiteral("\\u2028"))
                   << std::pair<QString, QString>(QChar(0x2029), QStringLiteral("\\u2029"));
 
         for (auto i = 0; i < 32; ++i) {
             jsEscapes << std::pair<QString, QString>(QChar(i), QStringLiteral("\\u00") + QStringLiteral("%1").arg(i, 2, 16, QLatin1Char('0')).toUpper());
         }
 
         auto retString = input;
         for (const auto &escape : std::as_const(jsEscapes)) {
             retString = retString.replace(escape.first, escape.second);
         }
         return retString;
     }
 };
 
 class TestBuiltinSyntax : public QObject
 {
     Q_OBJECT
 
 private Q_SLOTS:
     void initTestCase();
 
     void testObjects();
 
     void testTruthiness_data();
     void testTruthiness();
 
     void testRenderAfterError();
 
     void testBasicSyntax_data();
     void testBasicSyntax()
     {
         doTest();
     }
 
     void testEnums_data();
     void testEnums()
     {
         doTest();
     }
 
     void testListIndex_data();
     void testListIndex()
     {
         doTest();
     }
 
     void testFilterSyntax_data();
     void testFilterSyntax()
     {
         doTest();
     }
 
     void testCommentSyntax_data();
     void testCommentSyntax()
     {
         doTest();
     }
 
     void testMultiline_data();
     void testMultiline()
     {
         doTest();
     }
 
     void testEscaping_data();
     void testEscaping()
     {
         doTest();
     }
 
     void testTypeAccessors_data();
     void testTypeAccessors()
     {
         doTest();
     }
     void testTypeAccessorsUnordered_data();
     void testTypeAccessorsUnordered();
 
     void testMultipleStates();
     void testAlternativeEscaping();
 
     void testTemplatePathSafety_data();
     void testTemplatePathSafety();
 
     void testMediaPathSafety_data();
     void testMediaPathSafety();
 
     void testDynamicProperties_data();
     void testDynamicProperties()
     {
         doTest();
     }
 
     void testGarbageInput_data();
     void testGarbageInput();
 
     void testInsignificantWhitespace_data();
     void testInsignificantWhitespace();
 
     void cleanupTestCase();
 
 private:
     Engine *m_engine;
 
     QSharedPointer<InMemoryTemplateLoader> m_loader;
 
     Engine *getEngine();
 
     void doTest();
 };
 
 void TestBuiltinSyntax::testObjects()
 {
     {
         auto loader = QSharedPointer<KTextTemplate::FileSystemTemplateLoader>::create();
         loader->setTemplateDirs({QStringLiteral("/path/one"), QStringLiteral("/path/two")});
 
         auto cache = QSharedPointer<KTextTemplate::CachingLoaderDecorator>::create(loader);
     }
 
     Context c1, c2;
     c1 = c1;
     c1 = c2;
     Context c3(c1);
     Q_UNUSED(c3);
 
     FilterExpression f1, f2;
     f1 = f1;
     f1 = f2;
     FilterExpression f3(f1);
     Q_UNUSED(f3);
 
     Variable v1;
     v1 = v1;
     v1 = f1.variable();
     Variable v3(v1);
     Q_UNUSED(v3);
     QVERIFY(!v1.isTrue(&c1));
     QVERIFY(!v1.isLocalized());
 
     c1.setMutating(true);
     QVERIFY(c1.isMutating());
 
     SafeString s1, s2;
     s1 = s1;
     s2 = s1;
     SafeString s3(s1);
     Q_UNUSED(s3);
 
     QMetaType{qMetaTypeId<MetaEnumVariable>()}.create(nullptr);
 }
 
 void TestBuiltinSyntax::testTruthiness_data()
 {
     QTest::addColumn<QVariant>("input");
     QTest::addColumn<bool>("expected");
 
     QTest::newRow("truthtest-01") << QVariant() << false;
     QTest::newRow("truthtest-02") << QVariant(false) << false;
     QTest::newRow("truthtest-03") << QVariant(true) << true;
 
     QTest::newRow("truthtest-04") << QVariant(0) << false;
     QTest::newRow("truthtest-05") << QVariant(1) << true;
 
     {
         auto falseV = QVariant::fromValue<int>(0);
         QTest::newRow("truthtest-06") << falseV << false;
         auto trueV = QVariant::fromValue<int>(1);
         QTest::newRow("truthtest-07") << trueV << true;
     }
     {
         auto falseV = QVariant::fromValue<uint>(0);
         QTest::newRow("truthtest-08") << falseV << false;
         auto trueV = QVariant::fromValue<uint>(1);
         QTest::newRow("truthtest-09") << trueV << true;
     }
     {
         auto falseV = QVariant::fromValue<qlonglong>(0);
         QTest::newRow("truthtest-10") << falseV << false;
         auto trueV = QVariant::fromValue<qlonglong>(1);
         QTest::newRow("truthtest-11") << trueV << true;
     }
     {
         auto falseV = QVariant::fromValue<qulonglong>(0);
         QTest::newRow("truthtest-12") << falseV << false;
         auto trueV = QVariant::fromValue<qulonglong>(1);
         QTest::newRow("truthtest-13") << trueV << true;
     }
     {
         auto falseV = QVariant::fromValue<double>(0);
         QTest::newRow("truthtest-14") << falseV << false;
         auto trueV = QVariant::fromValue<double>(1);
         QTest::newRow("truthtest-15") << trueV << true;
     }
     {
         auto falseV = QVariant::fromValue<float>(0);
         QTest::newRow("truthtest-16") << falseV << false;
         auto trueV = QVariant::fromValue<float>(1);
         QTest::newRow("truthtest-17") << trueV << true;
     }
     {
         auto falseV = QVariant::fromValue<char>(0);
         QTest::newRow("truthtest-18") << falseV << false;
         auto trueV = QVariant::fromValue<char>(1);
         QTest::newRow("truthtest-19") << trueV << true;
     }
 
     QTest::newRow("truthtest-20") << QVariant::fromValue(QString()) << false;
     QTest::newRow("truthtest-21") << QVariant::fromValue(QStringLiteral("")) << false;
     QTest::newRow("truthtest-22") << QVariant::fromValue(QStringLiteral("false")) << true;
     QTest::newRow("truthtest-23") << QVariant::fromValue(QStringLiteral("true")) << true;
     QTest::newRow("truthtest-24") << QVariant::fromValue(QStringLiteral("anystring")) << true;
 
     {
         QVariantList l;
         QTest::newRow("truthtest-25") << QVariant::fromValue(l) << false;
         l.append(1);
         QTest::newRow("truthtest-26") << QVariant::fromValue(l) << true;
     }
     {
         QVariantHash h;
         QTest::newRow("truthtest-27") << QVariant::fromValue(h) << false;
         h.insert(QStringLiteral("value"), 1);
         QTest::newRow("truthtest-28") << QVariant::fromValue(h) << true;
     }
 
     {
         QTest::newRow("truthtest-29") << QVariant::fromValue<QObject *>(nullptr) << false;
         auto plainO = new QObject(this);
         QTest::newRow("truthtest-30") << QVariant::fromValue(plainO) << true;
         auto trueO = new QObject(this);
         trueO->setProperty("__true__", true);
         QTest::newRow("truthtest-31") << QVariant::fromValue(trueO) << true;
         auto falseO = new QObject(this);
         falseO->setProperty("__true__", false);
         QTest::newRow("truthtest-32") << QVariant::fromValue(falseO) << false;
     }
 }
 
 void TestBuiltinSyntax::testTruthiness()
 {
     QFETCH(QVariant, input);
     QFETCH(bool, expected);
 
     QVERIFY(variantIsTrue(input) == expected);
 }
 
 void TestBuiltinSyntax::testRenderAfterError()
 {
     Engine engine;
     engine.setPluginPaths({QStringLiteral(KTEXTTEMPLATE_PLUGIN_PATH)});
 
     QSharedPointer<InMemoryTemplateLoader> loader(new InMemoryTemplateLoader);
     loader->setTemplate(QStringLiteral("template1"), QStringLiteral("This template has an error {{ va>r }}"));
     loader->setTemplate(QStringLiteral("template2"), QStringLiteral("Ok"));
     loader->setTemplate(QStringLiteral("main"), QStringLiteral("{% include template_var %}"));
 
     engine.addTemplateLoader(loader);
 
     Context c;
     Template t;
 
     t = engine.loadByName(QStringLiteral("main"));
 
     c.insert(QStringLiteral("template_var"), QLatin1String("template1"));
     auto output = t->render(&c);
     QCOMPARE(output, QString());
     QCOMPARE(t->error(), TagSyntaxError);
 
     c.insert(QStringLiteral("template_var"), QLatin1String("template2"));
     QCOMPARE(t->render(&c), QLatin1String("Ok"));
     QCOMPARE(t->error(), NoError);
 }
 
 void TestBuiltinSyntax::initTestCase()
 {
     m_engine = getEngine();
     m_loader = QSharedPointer<InMemoryTemplateLoader>(new InMemoryTemplateLoader());
     m_engine->addTemplateLoader(m_loader);
     QVERIFY(m_engine->templateLoaders().contains(m_loader));
 }
 
 Engine *TestBuiltinSyntax::getEngine()
 {
     auto engine = new Engine(this);
     engine->setPluginPaths({QStringLiteral(KTEXTTEMPLATE_PLUGIN_PATH)});
     return engine;
 }
 
 void TestBuiltinSyntax::cleanupTestCase()
 {
     delete m_engine;
 }
 
 void TestBuiltinSyntax::doTest()
 {
     QFETCH(QString, input);
     QFETCH(Dict, dict);
     QFETCH(QString, output);
     QFETCH(KTextTemplate::Error, error);
 
     auto t = m_engine->newTemplate(input, QLatin1String(QTest::currentDataTag()));
 
     if (t->error() != NoError) {
         if (t->error() != error)
             qDebug() << t->errorString();
         QCOMPARE(t->error(), error);
         return;
     }
 
     Context context(dict);
 
     auto result = t->render(&context);
     if (t->error() != NoError) {
         if (t->error() != error)
             qDebug() << t->errorString();
         QCOMPARE(t->error(), error);
         return;
     }
 
     QCOMPARE(t->error(), NoError);
 
     // Didn't catch any errors, so make sure I didn't expect any.
     QCOMPARE(NoError, error);
 
     QCOMPARE(result, output);
 }
 
 void TestBuiltinSyntax::testBasicSyntax_data()
 {
     QTest::addColumn<QString>("input");
     QTest::addColumn<Dict>("dict");
     QTest::addColumn<QString>("output");
     QTest::addColumn<KTextTemplate::Error>("error");
 
     Dict dict;
 
     QTest::newRow("basic-syntax00") << QString() << dict << QString() << NoError;
 
     // Plain text should go through the template parser untouched
     QTest::newRow("basic-syntax01") << QStringLiteral("something cool") << dict << QStringLiteral("something cool") << NoError;
 
     // Variables should be replaced with their value in the current
     // context
     dict.insert(QStringLiteral("headline"), QStringLiteral("Success"));
     QTest::newRow("basic-syntax02") << QStringLiteral("{{ headline }}") << dict << QStringLiteral("Success") << NoError;
 
     dict.clear();
     dict.insert(QStringLiteral("first"), 1);
     dict.insert(QStringLiteral("second"), 2);
 
     // More than one replacement variable is allowed in a template
     QTest::newRow("basic-syntax03") << QStringLiteral("{{ first }} --- {{ second }}") << dict << QStringLiteral("1 --- 2") << NoError;
 
     dict.clear();
     // Fail silently when a variable is not found in the current context
     QTest::newRow("basic-syntax04") << QStringLiteral("as{{ missing }}df") << dict << QStringLiteral("asdf") << NoError;
 
     // A variable may not contain more than one word
     QTest::newRow("basic-syntax06") << QStringLiteral("{{ multi word variable }}") << dict << QString() << TagSyntaxError;
     // Raise TemplateSyntaxError for empty variable tags
     QTest::newRow("basic-syntax07") << QStringLiteral("{{ }}") << dict << QString() << EmptyVariableError;
     QTest::newRow("basic-syntax08") << QStringLiteral("{{        }}") << dict << QString() << EmptyVariableError;
 
     // Attribute syntax allows a template to call an object's attribute
 
     auto someClass = new SomeClass(this);
     dict.insert(QStringLiteral("var"), QVariant::fromValue(someClass));
 
     QTest::newRow("basic-syntax09") << QStringLiteral("{{ var.method }}") << dict << QStringLiteral("SomeClass::method") << NoError;
 
     // Multiple levels of attribute access are allowed
     QTest::newRow("basic-syntax10") << QStringLiteral("{{ var.otherClass.method }}") << dict << QStringLiteral("OtherClass::method") << NoError;
 
     // Fail silently when a variable's attribute isn't found
     QTest::newRow("basic-syntax11") << QStringLiteral("{{ var.blech }}") << dict << QString() << NoError;
 
     // TODO: Needed?
     // Raise TemplateSyntaxError when trying to access a variable beginning with
     // an underscore
     // #C# {"var": SomeClass()}
     dict.clear();
     QVariantHash hash;
     hash.insert(QStringLiteral("__dict__"), QStringLiteral("foo"));
     dict.insert(QStringLiteral("var"), hash);
     QTest::newRow("basic-syntax12") << QStringLiteral("{{ var.__dict__ }}") << dict << QString() << TagSyntaxError;
 
     dict.clear();
     // Raise TemplateSyntaxError when trying to access a variable containing an
     // illegal character
     QTest::newRow("basic-syntax13") << QStringLiteral("{{ va>r }}") << dict << QString() << TagSyntaxError;
     QTest::newRow("basic-syntax14") << QStringLiteral("{{ (var.r) }}") << dict << QString() << TagSyntaxError;
     QTest::newRow("basic-syntax15") << QStringLiteral("{{ sp%am }}") << dict << QString() << TagSyntaxError;
     QTest::newRow("basic-syntax16") << QStringLiteral("{{ eggs! }}") << dict << QString() << TagSyntaxError;
     QTest::newRow("basic-syntax17") << QStringLiteral("{{ moo? }}") << dict << QString() << TagSyntaxError;
     QTest::newRow("basic-syntax-error01") << QStringLiteral("{{ moo:arg }}") << dict << QString() << TagSyntaxError;
     QTest::newRow("basic-syntax-error02") << QStringLiteral("{{ moo|cut:'foo':'bar' }}") << dict << QString() << TagSyntaxError;
 
     // Attribute syntax allows a template to call a dictionary key's value
 
     hash.clear();
     hash.insert(QStringLiteral("bar"), QStringLiteral("baz"));
     dict.insert(QStringLiteral("foo"), hash);
     QTest::newRow("basic-syntax18") << QStringLiteral("{{ foo.bar }}") << dict << QStringLiteral("baz") << NoError;
 
     // Fail silently when a variable's dictionary key isn't found
     QTest::newRow("basic-syntax19") << QStringLiteral("{{ foo.spam }}") << dict << QString() << NoError;
 
     dict.clear();
     dict.insert(QStringLiteral("var"), QVariant::fromValue(someClass));
     // Fail silently when attempting to access an unavailable method
     QTest::newRow("basic-syntax20") << QStringLiteral("{{ var.nonAccessibleMethod }}") << dict << QString() << NoError;
 
     dict.clear();
     // Don't get confused when parsing something that is almost, but not
     // quite, a template tag.
     QTest::newRow("basic-syntax21") << QStringLiteral("a {{ moo %} b") << dict << QStringLiteral("a {{ moo %} b") << NoError;
     QTest::newRow("basic-syntax22") << QStringLiteral("{{ moo #}") << dict << QStringLiteral("{{ moo #}") << NoError;
 
     dict.insert(QStringLiteral("cow"), QStringLiteral("cow"));
     // Will try to treat "moo #} {{ cow" as the variable. Not ideal, but
     // costly to work around, so this triggers an error.
     QTest::newRow("basic-syntax23") << QStringLiteral("{{ moo #} {{ cow }}") << dict << QString() << TagSyntaxError;
 
     dict.clear();
     // Embedded newlines make it not-a-tag.
     QTest::newRow("basic-syntax24") << "{{ moo\n }}" << dict << "{{ moo\n }}" << NoError;
     // Literal strings are permitted inside variables, mostly for i18n
     // purposes.
     QTest::newRow("basic-syntax25") << "{{ \"fred\" }}" << dict << QStringLiteral("fred") << NoError;
     QTest::newRow("basic-syntax26") << R"({{ "\"fred\"" }})" << dict << "\"fred\"" << NoError;
     QTest::newRow("basic-syntax27") << R"({{ _("\"fred\"") }})" << dict << "&quot;fred&quot;" << NoError;
 
     dict.clear();
     hash.clear();
     QVariantHash innerHash;
     innerHash.insert(QStringLiteral("3"), QStringLiteral("d"));
     hash.insert(QStringLiteral("2"), innerHash);
     dict.insert(QStringLiteral("1"), hash);
 
     QTest::newRow("basic-syntax28") << QStringLiteral("{{ 1.2.3 }}") << dict << QStringLiteral("d") << NoError;
 
     dict.clear();
     hash.clear();
     QVariantList list{QStringLiteral("a"), QStringLiteral("b"), QStringLiteral("c"), QStringLiteral("d")};
     hash.insert(QStringLiteral("2"), list);
     dict.insert(QStringLiteral("1"), hash);
     QTest::newRow("basic-syntax29") << QStringLiteral("{{ 1.2.3 }}") << dict << QStringLiteral("d") << NoError;
 
     dict.clear();
     list.clear();
     QVariantList innerList{QStringLiteral("x"), QStringLiteral("x"), QStringLiteral("x"), QStringLiteral("x")};
     list.append(QVariant(innerList));
     innerList = {QStringLiteral("y"), QStringLiteral("y"), QStringLiteral("y"), QStringLiteral("y")};
     list.append(QVariant(innerList));
     innerList = {QStringLiteral("a"), QStringLiteral("b"), QStringLiteral("c"), QStringLiteral("d")};
     list.append(QVariant(innerList));
     dict.insert(QStringLiteral("1"), list);
 
     QTest::newRow("basic-syntax30") << QStringLiteral("{{ 1.2.3 }}") << dict << QStringLiteral("d") << NoError;
 
     dict.clear();
     list.clear();
     innerList = {QStringLiteral("x"), QStringLiteral("x"), QStringLiteral("x"), QStringLiteral("x")};
     list.append(QVariant(innerList));
     innerList = {QStringLiteral("y"), QStringLiteral("y"), QStringLiteral("y"), QStringLiteral("y")};
     list.append(QVariant(innerList));
     innerList = {QStringLiteral("a"), QStringLiteral("b"), QStringLiteral("c"), QStringLiteral("d")};
     list.append(QVariant(innerList));
     dict.insert(QStringLiteral("1"), list);
 
     QTest::newRow("basic-syntax31") << QStringLiteral("{{ 1.2.3 }}") << dict << QStringLiteral("d") << NoError;
 
     dict.clear();
     list.clear();
     hash.clear();
     hash.insert(QStringLiteral("x"), QStringLiteral("x"));
     list.append(hash);
     hash.clear();
     hash.insert(QStringLiteral("y"), QStringLiteral("y"));
     list.append(hash);
     hash.clear();
     hash.insert(QStringLiteral("3"), QStringLiteral("d"));
     list.append(hash);
 
     dict.insert(QStringLiteral("1"), list);
 
     QTest::newRow("basic-syntax32") << QStringLiteral("{{ 1.2.3 }}") << dict << QStringLiteral("d") << NoError;
 
     dict.clear();
 
     dict.insert(QStringLiteral("1"), QStringLiteral("abc"));
     QTest::newRow("basic-syntax33") << QStringLiteral("{{ 1 }}") << dict << QStringLiteral("1") << NoError;
     QTest::newRow("basic-syntax34") << QStringLiteral("{{ 1.2 }}") << dict << QStringLiteral("1.2") << NoError;
 
     dict.clear();
 
     dict.insert(QStringLiteral("abc"), QStringLiteral("def"));
 
     QTest::newRow("basic-syntax35") << QStringLiteral("{{ abc._something }} {{ abc._something|upper }}") << dict << QString() << TagSyntaxError;
 
     QTest::newRow("basic-syntax36") << "{{ \"fred }}" << dict << QString() << TagSyntaxError;
     QTest::newRow("basic-syntax37") << "{{ \'fred }}" << dict << QString() << TagSyntaxError;
     QTest::newRow("basic-syntax38") << "{{ \"fred\' }}" << dict << QString() << TagSyntaxError;
     QTest::newRow("basic-syntax39") << "{{ \'fred\" }}" << dict << QString() << TagSyntaxError;
     QTest::newRow("basic-syntax40") << "{{ _(\'fred }}" << dict << QString() << TagSyntaxError;
     QTest::newRow("basic-syntax41") << "{{ abc|removetags:_(\'fred }}" << dict << QString() << TagSyntaxError;
 }
 
 void TestBuiltinSyntax::testEnums_data()
 {
     QTest::addColumn<QString>("input");
     QTest::addColumn<Dict>("dict");
     QTest::addColumn<QString>("output");
     QTest::addColumn<KTextTemplate::Error>("error");
 
     Dict dict;
 
     auto otherClass = new OtherClass(this);
     dict.insert(QStringLiteral("var"), QVariant::fromValue(otherClass));
 
     QTest::newRow("class-enums01") << QStringLiteral("{{ var.Lions }}") << dict << QStringLiteral("0") << NoError;
     QTest::newRow("class-enums02") << QStringLiteral("{{ var.Tigers }}") << dict << QStringLiteral("1") << NoError;
     QTest::newRow("class-enums03") << QStringLiteral("{{ var.Bears }}") << dict << QStringLiteral("2") << NoError;
     QTest::newRow("class-enums04") << QStringLiteral("{{ var.Hamsters }}") << dict << QString() << NoError;
     QTest::newRow("class-enums05") << QStringLiteral("{{ var.Tigers.name }}") << dict << QStringLiteral("Animals") << NoError;
     QTest::newRow("class-enums06") << QStringLiteral("{{ var.Tigers.scope }}") << dict << QStringLiteral("OtherClass") << NoError;
     QTest::newRow("class-enums07") << QStringLiteral("{{ var.Tigers.value }}") << dict << QStringLiteral("1") << NoError;
     QTest::newRow("class-enums08") << QStringLiteral("{{ var.Tigers.key }}") << dict << QStringLiteral("Tigers") << NoError;
     QTest::newRow("class-enums09") << QStringLiteral("{{ var.animals }}") << dict << QStringLiteral("1") << NoError;
     QTest::newRow("class-enums10") << QStringLiteral("{{ var.animals.name }}") << dict << QStringLiteral("Animals") << NoError;
     QTest::newRow("class-enums11") << QStringLiteral("{{ var.animals.scope }}") << dict << QStringLiteral("OtherClass") << NoError;
     QTest::newRow("class-enums12") << QStringLiteral("{{ var.animals.value }}") << dict << QStringLiteral("1") << NoError;
     QTest::newRow("class-enums13") << QStringLiteral("{{ var.animals.key }}") << dict << QStringLiteral("Tigers") << NoError;
     QTest::newRow("class-enums14") << QStringLiteral("{{ var.Animals.0 }}") << dict << QStringLiteral("0") << NoError;
     QTest::newRow("class-enums15") << QStringLiteral("{{ var.Animals.2 }}") << dict << QStringLiteral("2") << NoError;
     QTest::newRow("class-enums16") << QStringLiteral("{{ var.Animals.3 }}") << dict << QString() << NoError;
     QTest::newRow("class-enums17") << QStringLiteral("{{ var.Animals.0.name }}") << dict << QStringLiteral("Animals") << NoError;
     QTest::newRow("class-enums18") << QStringLiteral("{{ var.Animals.0.scope }}") << dict << QStringLiteral("OtherClass") << NoError;
     QTest::newRow("class-enums19") << QStringLiteral("{{ var.Animals.0.value }}") << dict << QStringLiteral("0") << NoError;
     QTest::newRow("class-enums20") << QStringLiteral("{{ var.Animals.0.key }}") << dict << QStringLiteral("Lions") << NoError;
     QTest::newRow("class-enums21") << QStringLiteral("{{ var.Animals.2.key }}") << dict << QStringLiteral("Bears") << NoError;
     QTest::newRow("class-enums22") << QStringLiteral("{{ var.Tigers.samba }}") << dict << QString() << NoError;
     QTest::newRow("class-enums23") << QStringLiteral(
         "{% with var.animals as result %}{{ result.key }},{{ "
         "result }},{{ result.scope }}{% endwith %}")
                                    << dict << QStringLiteral("Tigers,1,OtherClass") << NoError;
     QTest::newRow("class-enums24") << QStringLiteral(
         "{% with var.Animals.2 as result %}{{ result.key }},{{ "
         "result }},{{ result.scope }}{% endwith %}")
                                    << dict << QStringLiteral("Bears,2,OtherClass") << NoError;
     QTest::newRow("class-enums25") << QStringLiteral(
         "{% with var.Bears as result %}{{ result.key }},{{ "
         "result }},{{ result.scope }}{% endwith %}")
                                    << dict << QStringLiteral("Bears,2,OtherClass") << NoError;
     QTest::newRow("class-enums26") << QStringLiteral(
         "{% with var.Animals as result %}{{ result.0.key }},{{ "
         "result.1.key }},{{ result.2.key }}{% endwith %}")
                                    << dict << QStringLiteral("Lions,Tigers,Bears") << NoError;
 
     dict.clear();
 
     auto someClass = new SomeClass(this);
     dict.insert(QStringLiteral("var"), QVariant::fromValue(someClass));
 
     QTest::newRow("class-enums27") << QStringLiteral("{{ var.Employee }}") << dict << QStringLiteral("0") << NoError;
     QTest::newRow("class-enums28") << QStringLiteral("{{ var.Employer }}") << dict << QStringLiteral("1") << NoError;
     QTest::newRow("class-enums29") << QStringLiteral("{{ var.Manager }}") << dict << QStringLiteral("2") << NoError;
     QTest::newRow("class-enums30") << QStringLiteral("{{ var.Voter }}") << dict << QStringLiteral("2") << NoError;
     QTest::newRow("class-enums31") << QStringLiteral("{{ var.Consumer }}") << dict << QStringLiteral("4") << NoError;
     QTest::newRow("class-enums32") << QStringLiteral("{{ var.Citizen }}") << dict << QStringLiteral("8") << NoError;
     QTest::newRow("class-enums33") << QStringLiteral("{{ var.FirstEnum }}") << dict << QString() << NoError;
     QTest::newRow("class-enums34") << QStringLiteral("{{ var.SecondEnum }}") << dict << QString() << NoError;
 
     QTest::newRow("class-enums35") << QString::fromLatin1(
         "{% with var.SecondEnum as result %}"
         "{{ result.0 }},{{ result.1 }},{{ result.2 }},"
         "{{ result.0.key }},{{ result.1.key }},{{ result.2.key }},"
         "{{ result }},{{ result.scope }}"
         "{% endwith %}") << dict << QStringLiteral("2,4,8,Voter,Consumer,Citizen,,SomeClass")
                                    << NoError;
 
     QTest::newRow("class-enums36") << QStringLiteral("{% ifequal var.Employee 2 %}{% endifequal %}") << dict << QString() << NoError;
 
     dict.insert(QStringLiteral("var"), QVariant::fromValue(otherClass));
 
     QTest::newRow("enums-loops01") << QString::fromLatin1(
         "{% for enum in var.Animals %}{% ifequal enum var.Tigers %}"
         "<b>{{ enum.key }}</b>{% else %}{{ enum.key }}{% endifequal %},"
         "{% empty %}No content{% endfor %}")
                                    << dict << QStringLiteral("Lions,<b>Tigers</b>,Bears,") << NoError;
 
     QTest::newRow("enums-loops02") << QString::fromLatin1(
         "{% for enum in var.Tigers %}"
         "{% ifequal enum result %}<b>{{ enum.key }}</b>"
         "{% else %}{{ enum.key }}{% endifequal %},"
         "{% empty %}No content"
         "{% endfor %}") << dict << QStringLiteral("No content")
                                    << NoError;
 
     QTest::newRow("enums-loops03") << QString::fromLatin1(
         "{% with var.animals as result %}"
         "{% for enum in var.Animals %}"
         "{% ifequal enum result %}<b>{{ enum.key }}</b>"
         "{% else %}{{ enum.key }}{% endifequal %},"
         "{% empty %}No content"
         "{% endfor %}"
         "{% endwith %}") << dict << QStringLiteral("Lions,<b>Tigers</b>,Bears,")
                                    << NoError;
 
     QTest::newRow("enums-keycount01") << QStringLiteral("{{ var.Animals.keyCount }}") << dict << QStringLiteral("3") << NoError;
     QTest::newRow("enums-keycount02") << QStringLiteral("{{ var.Lions.keyCount }}") << dict << QStringLiteral("3") << NoError;
     QTest::newRow("enums-keycount02") << QStringLiteral("{{ var.animals.keyCount }}") << dict << QStringLiteral("3") << NoError;
 
     auto otherClass2 = new OtherClass(OtherClass::Lions, this);
     dict.insert(QStringLiteral("var2"), QVariant::fromValue(otherClass2));
 
     auto otherClass3 = new OtherClass(this);
     dict.insert(QStringLiteral("var3"), QVariant::fromValue(otherClass3));
 
     QTest::newRow("enums-compare01") << QStringLiteral("{% if var.animals == var3.animals %}true{% else %}false{% endif %}") << dict << QStringLiteral("true")
                                      << NoError;
 
     QTest::newRow("enums-compare02") << QStringLiteral("{% if var.animals == var2.animals %}true{% else %}false{% endif %}") << dict << QStringLiteral("false")
                                      << NoError;
 
     QTest::newRow("enums-compare03") << QStringLiteral("{% if var.animals >= var3.animals %}true{% else %}false{% endif %}") << dict << QStringLiteral("true")
                                      << NoError;
 
     QTest::newRow("enums-compare04") << QStringLiteral("{% if var.animals >= var2.animals %}true{% else %}false{% endif %}") << dict << QStringLiteral("true")
                                      << NoError;
 
     QTest::newRow("enums-compare05") << QStringLiteral("{% if var.animals > var3.animals %}true{% else %}false{% endif %}") << dict << QStringLiteral("false")
                                      << NoError;
 
     QTest::newRow("enums-compare06") << QStringLiteral("{% if var.animals > var2.animals %}true{% else %}false{% endif %}") << dict << QStringLiteral("true")
                                      << NoError;
 
     QTest::newRow("enums-compare07") << QStringLiteral("{% if var.animals <= var3.animals %}true{% else %}false{% endif %}") << dict << QStringLiteral("true")
                                      << NoError;
 
     QTest::newRow("enums-compare08") << QStringLiteral("{% if var.animals <= var2.animals %}true{% else %}false{% endif %}") << dict << QStringLiteral("false")
                                      << NoError;
 
     QTest::newRow("enums-compare09") << QStringLiteral("{% if var.animals < var3.animals %}true{% else %}false{% endif %}") << dict << QStringLiteral("false")
                                      << NoError;
 
     QTest::newRow("enums-compare10") << QStringLiteral("{% if var.animals < var2.animals %}true{% else %}false{% endif %}") << dict << QStringLiteral("false")
                                      << NoError;
 
     QTest::newRow("qt-enums01") << QStringLiteral("{{ Qt.AlignRight }}") << dict << QStringLiteral("2") << NoError;
     QTest::newRow("qt-enums02") << QStringLiteral("{{ Qt.AlignRight.scope }}") << dict << QStringLiteral("Qt") << NoError;
     QTest::newRow("qt-enums03") << QStringLiteral("{{ Qt.AlignRight.name }}") << dict << QStringLiteral("Alignment") << NoError;
     QTest::newRow("qt-enums04") << QStringLiteral("{{ Qt.AlignRight.value }}") << dict << QStringLiteral("2") << NoError;
     QTest::newRow("qt-enums05") << QStringLiteral("{{ Qt.AlignRight.key }}") << dict << QStringLiteral("AlignRight") << NoError;
     QTest::newRow("qt-enums06") << QStringLiteral("{{ Qt.Alignment.2.key }}") << dict << QStringLiteral("AlignRight") << NoError;
     QTest::newRow("qt-enums07") << QStringLiteral("{{ Qt.DoesNotExist }}") << dict << QString() << NoError;
     QTest::newRow("qt-enums08") << QStringLiteral("{{ Qt }}") << dict << QString() << NoError;
 
     dict.clear();
 
     GadgetClass gadgetClasss;
     dict.insert(QStringLiteral("var"), QVariant::fromValue(gadgetClasss));
 
     QTest::newRow("gadget-enums01") << QStringLiteral("{{ var.Mike }}") << dict << QStringLiteral("0") << NoError;
     QTest::newRow("gadget-enums02") << QStringLiteral("{{ var.Natalie }}") << dict << QStringLiteral("1") << NoError;
     QTest::newRow("gadget-enums03") << QStringLiteral("{{ var.Oliver }}") << dict << QStringLiteral("2") << NoError;
     QTest::newRow("gadget-enums04") << QStringLiteral("{{ var.Patricia }}") << dict << QString() << NoError;
     QTest::newRow("gadget-enums05") << QStringLiteral("{{ var.Natalie.name }}") << dict << QStringLiteral("PersonName") << NoError;
     QTest::newRow("gadget-enums06") << QStringLiteral("{{ var.Natalie.scope }}") << dict << QStringLiteral("GadgetClass") << NoError;
     QTest::newRow("gadget-enums07") << QStringLiteral("{{ var.Natalie.value }}") << dict << QStringLiteral("1") << NoError;
     QTest::newRow("gadget-enums08") << QStringLiteral("{{ var.Natalie.key }}") << dict << QStringLiteral("Natalie") << NoError;
     QTest::newRow("gadget-enums09") << QStringLiteral("{{ var.personName }}") << dict << QStringLiteral("2") << NoError;
     QTest::newRow("gadget-enums10") << QStringLiteral("{{ var.personName.name }}") << dict << QStringLiteral("PersonName") << NoError;
     QTest::newRow("gadget-enums11") << QStringLiteral("{{ var.personName.scope }}") << dict << QStringLiteral("GadgetClass") << NoError;
     QTest::newRow("gadget-enums12") << QStringLiteral("{{ var.personName.value }}") << dict << QStringLiteral("2") << NoError;
     QTest::newRow("gadget-enums13") << QStringLiteral("{{ var.personName.key }}") << dict << QStringLiteral("Oliver") << NoError;
     QTest::newRow("gadget-enums14") << QStringLiteral("{{ var.PersonName.0 }}") << dict << QStringLiteral("0") << NoError;
     QTest::newRow("gadget-enums15") << QStringLiteral("{{ var.PersonName.2 }}") << dict << QStringLiteral("2") << NoError;
     QTest::newRow("gadget-enums16") << QStringLiteral("{{ var.PersonName.3 }}") << dict << QString() << NoError;
     QTest::newRow("gadget-enums17") << QStringLiteral("{{ var.PersonName.0.name }}") << dict << QStringLiteral("PersonName") << NoError;
     QTest::newRow("gadget-enums18") << QStringLiteral("{{ var.PersonName.0.scope }}") << dict << QStringLiteral("GadgetClass") << NoError;
     QTest::newRow("gadget-enums19") << QStringLiteral("{{ var.PersonName.0.value }}") << dict << QStringLiteral("0") << NoError;
     QTest::newRow("gadget-enums20") << QStringLiteral("{{ var.PersonName.0.key }}") << dict << QStringLiteral("Mike") << NoError;
     QTest::newRow("gadget-enums21") << QStringLiteral("{{ var.PersonName.2.key }}") << dict << QStringLiteral("Oliver") << NoError;
     QTest::newRow("gadget-enums22") << QStringLiteral("{{ var.PersonName.samba }}") << dict << QString() << NoError;
     QTest::newRow("gadget-enums23") << QStringLiteral(
         "{% with var.personName as result %}{{ result.key }},{{ "
         "result }},{{ result.scope }}{% endwith %}")
                                     << dict << QStringLiteral("Oliver,2,GadgetClass") << NoError;
     QTest::newRow("gadget-enums24") << QStringLiteral(
         "{% with var.PersonName.2 as result %}{{ result.key }},{{ "
         "result }},{{ result.scope }}{% endwith %}")
                                     << dict << QStringLiteral("Oliver,2,GadgetClass") << NoError;
     QTest::newRow("gadget-enums25") << QStringLiteral(
         "{% with var.Oliver as result %}{{ result.key }},{{ "
         "result }},{{ result.scope }}{% endwith %}")
                                     << dict << QStringLiteral("Oliver,2,GadgetClass") << NoError;
     QTest::newRow("gadget-enums26") << QStringLiteral(
         "{% with var.PersonName as result %}{{ result.0.key }},{{ "
         "result.1.key }},{{ result.2.key }}{% endwith %}")
                                     << dict << QStringLiteral("Mike,Natalie,Oliver") << NoError;
 
     QTest::newRow("gadget-enums-loops01") << QString::fromLatin1(
         "{% for enum in var.PersonName %}{% ifequal enum var.Natalie %}"
         "<b>{{ enum.key }}</b>{% else %}{{ enum.key }}{% endifequal %},"
         "{% empty %}No content{% endfor %}")
                                           << dict << QStringLiteral("Mike,<b>Natalie</b>,Oliver,") << NoError;
 
     QTest::newRow("gadget-enums-loops02") << QString::fromLatin1(
         "{% for enum in var.Tigers %}"
         "{% ifequal enum result %}<b>{{ enum.key }}</b>"
         "{% else %}{{ enum.key }}{% endifequal %},"
         "{% empty %}No content"
         "{% endfor %}") << dict << QStringLiteral("No content")
                                           << NoError;
 
     QTest::newRow("gadget-enums-loops03") << QString::fromLatin1(
         "{% with var.personName as result %}"
         "{% for enum in var.PersonName %}"
         "{% ifequal enum result %}<b>{{ enum.key }}</b>"
         "{% else %}{{ enum.key }}{% endifequal %},"
         "{% empty %}No content"
         "{% endfor %}"
         "{% endwith %}") << dict << QStringLiteral("Mike,Natalie,<b>Oliver</b>,")
                                           << NoError;
 
     QTest::newRow("gadget-enums-keycount01") << QStringLiteral("{{ var.PersonName.keyCount }}") << dict << QStringLiteral("3") << NoError;
     QTest::newRow("gadget-enums-keycount02") << QStringLiteral("{{ var.personName.keyCount }}") << dict << QStringLiteral("3") << NoError;
 
     GadgetClass gadgetClass2(GadgetClass::Natalie);
     dict.insert(QStringLiteral("var2"), QVariant::fromValue(gadgetClass2));
 
     GadgetClass gadgetClass3;
     dict.insert(QStringLiteral("var3"), QVariant::fromValue(gadgetClass3));
 
     QTest::newRow("gadget-enums-compare01") << QStringLiteral(
         "{% if var.personName == var3.personName %}true{% else "
         "%}false{% endif %}") << dict << QStringLiteral("true")
                                             << NoError;
 
     QTest::newRow("gadget-enums-compare02") << QStringLiteral(
         "{% if var.personName == var2.personName %}true{% else "
         "%}false{% endif %}") << dict << QStringLiteral("false")
                                             << NoError;
 
     QTest::newRow("gadget-enums-compare03") << QStringLiteral(
         "{% if var.personName >= var3.personName %}true{% else "
         "%}false{% endif %}") << dict << QStringLiteral("true")
                                             << NoError;
 
     QTest::newRow("gadget-enums-compare04") << QStringLiteral(
         "{% if var.personName >= var2.personName %}true{% else "
         "%}false{% endif %}") << dict << QStringLiteral("true")
                                             << NoError;
 
     QTest::newRow("gadget-enums-compare05") << QStringLiteral("{% if var.personName > var3.personName %}true{% else %}false{% endif %}") << dict
                                             << QStringLiteral("false") << NoError;
 
     QTest::newRow("gadget-enums-compare06") << QStringLiteral("{% if var.personName > var2.personName %}true{% else %}false{% endif %}") << dict
                                             << QStringLiteral("true") << NoError;
 
     QTest::newRow("gadget-enums-compare07") << QStringLiteral(
         "{% if var.personName <= var3.personName %}true{% else "
         "%}false{% endif %}") << dict << QStringLiteral("true")
                                             << NoError;
 
     QTest::newRow("gadget-enums-compare08") << QStringLiteral(
         "{% if var.personName <= var2.personName %}true{% else "
         "%}false{% endif %}") << dict << QStringLiteral("false")
                                             << NoError;
 
     QTest::newRow("gadget-enums-compare09") << QStringLiteral("{% if var.personName < var3.personName %}true{% else %}false{% endif %}") << dict
                                             << QStringLiteral("false") << NoError;
 
     QTest::newRow("gadget-enums-compare10") << QStringLiteral("{% if var.personName < var2.personName %}true{% else %}false{% endif %}") << dict
                                             << QStringLiteral("false") << NoError;
 }
 
 void TestBuiltinSyntax::testListIndex_data()
 {
     QTest::addColumn<QString>("input");
     QTest::addColumn<Dict>("dict");
     QTest::addColumn<QString>("output");
     QTest::addColumn<KTextTemplate::Error>("error");
 
     Dict dict;
 
     QVariantList l{QStringLiteral("first item"), QStringLiteral("second item")};
 
     dict.insert(QStringLiteral("var"), l);
 
     // List-index syntax allows a template to access a certain item of a
     // subscriptable object.
     QTest::newRow("list-index01") << QStringLiteral("{{ var.1 }}") << dict << QStringLiteral("second item") << NoError;
     // Fail silently when the list index is out of range.
     QTest::newRow("list-index02") << QStringLiteral("{{ var.5 }}") << dict << QString() << NoError;
 
     dict.clear();
     dict.insert(QStringLiteral("var"), QVariant());
 
     // Fail silently when the variable is not a subscriptable object.
     QTest::newRow("list-index03") << QStringLiteral("{{ var.1 }}") << dict << QString() << NoError;
 
     dict.clear();
     dict.insert(QStringLiteral("var"), QVariantHash());
     // Fail silently when variable is a dict without the specified key.
     QTest::newRow("list-index04") << QStringLiteral("{{ var.1 }}") << dict << QString() << NoError;
 
     dict.clear();
 
     QVariantHash hash;
     hash.insert(QStringLiteral("1"), QStringLiteral("hello"));
     dict.insert(QStringLiteral("var"), hash);
     // Dictionary lookup wins out when dict's key is a string.
     QTest::newRow("list-index05") << QStringLiteral("{{ var.1 }}") << dict << QStringLiteral("hello") << NoError;
 
     // QVariantHash can only use strings as keys, so list-index06 and
     // list-index07
     // are not valid.
 
     dict.clear();
 
     QStringList sl;
     sl.append(QStringLiteral("hello"));
     sl.append(QStringLiteral("world"));
     dict.insert(QStringLiteral("var"), sl);
     // QStringList lookup
     QTest::newRow("list-index08") << QStringLiteral("{{ var.0 }}, {{ var.1 }}!") << dict << QStringLiteral("hello, world!") << NoError;
 }
 
 void TestBuiltinSyntax::testFilterSyntax_data()
 {
     QTest::addColumn<QString>("input");
     QTest::addColumn<Dict>("dict");
     QTest::addColumn<QString>("output");
     QTest::addColumn<KTextTemplate::Error>("error");
 
     Dict dict;
 
     // Basic filter usage
     dict.insert(QStringLiteral("var"), QStringLiteral("Django is the greatest!"));
     QTest::newRow("filter-syntax01") << QStringLiteral("{{ var|upper }}") << dict << QStringLiteral("DJANGO IS THE GREATEST!") << NoError;
 
     // Chained filters
     QTest::newRow("filter-syntax02") << QStringLiteral("{{ var|upper|lower }}") << dict << QStringLiteral("django is the greatest!") << NoError;
 
     // Raise TemplateSyntaxError for space between a variable and filter pipe
     dict.clear();
     QTest::newRow("filter-syntax03") << QStringLiteral("{{ var |upper }}") << dict << QString() << TagSyntaxError;
 
     // Raise TemplateSyntaxError for space after a filter pipe
     QTest::newRow("filter-syntax04") << QStringLiteral("{{ var| upper }}") << dict << QString() << TagSyntaxError;
 
     // Raise TemplateSyntaxError for a nonexistent filter
     QTest::newRow("filter-syntax05") << QStringLiteral("{{ var|does_not_exist }}") << dict << QString() << UnknownFilterError;
 
     // Raise TemplateSyntaxError when trying to access a filter containing an
     // illegal character
     QTest::newRow("filter-syntax06") << QStringLiteral("{{ var|fil(ter) }}") << dict << QString() << UnknownFilterError;
 
     // Raise TemplateSyntaxError for invalid block tags
     QTest::newRow("filter-syntax07") << QStringLiteral("{% nothing_to_see_here %}") << dict << QString() << InvalidBlockTagError;
     // Raise TemplateSyntaxError for empty block tags
     QTest::newRow("filter-syntax08") << QStringLiteral("{% %}") << dict << QString() << EmptyBlockTagError;
 
     // Chained filters, with an argument to the first one
     dict.insert(QStringLiteral("var"), QStringLiteral("<b><i>Yes</i></b>"));
     QTest::newRow("filter-syntax09") << "{{ var|removetags:\"b i\"|upper|lower }}" << dict << QStringLiteral("yes") << NoError;
     // Literal string as argument is always "safe" from auto-escaping..
     dict.clear();
     dict.insert(QStringLiteral("var"), QVariant());
     QTest::newRow("filter-syntax10") << R"({{ var|default_if_none:" endquote\" hah" }})" << dict << " endquote\" hah" << NoError;
     // Variable as argument
     dict.insert(QStringLiteral("var2"), QStringLiteral("happy"));
     QTest::newRow("filter-syntax11") << QStringLiteral("{{ var|default_if_none:var2 }}") << dict << QStringLiteral("happy") << NoError;
     // Default argument testing
     dict.clear();
     dict.insert(QStringLiteral("var"), true);
     QTest::newRow("filter-syntax12") << "{{ var|yesno:\"yup,nup,mup\" }} {{ var|yesno }}" << dict << QStringLiteral("yup yes") << NoError;
 
     // Fail silently for methods that raise an exception with a
     // "silent_variable_failure" attribute
     //   dict.clear();
     //   QObject *someClass = new SomeClass(this);
     //   dict.insert( QStringLiteral("var"), QVariant::fromValue(someClass));
     //   QTest::newRow("filter-syntax13") << QString::fromLatin1( "1{{
     //   var.method3
     //   }}2" ) << dict << QString::fromLatin1( "12" ) << NoError;
     //   // In methods that raise an exception without a
     //   // "silent_variable_attribute" set to True, the exception propagates
     //   // #C# SomeOtherException)
     //   QTest::newRow("filter-syntax14") << QString::fromLatin1( "var" ) <<
     //   dict
     //   << QString() << TagSyntaxError;
 
     // Escaped backslash in argument
     dict.clear();
     dict.insert(QStringLiteral("var"), QVariant());
     QTest::newRow("filter-syntax15") << R"({{ var|default_if_none:"foo\bar" }})" << dict << "foo\\bar" << NoError;
     // Escaped backslash using known escape char
     QTest::newRow("filter-syntax16") << R"({{ var|default_if_none:"foo\now" }})" << dict << "foo\\now" << NoError;
     // Empty strings can be passed as arguments to filters
     dict.clear();
     dict.insert(QStringLiteral("var"), QVariantList{QStringLiteral("a"), QStringLiteral("b"), QStringLiteral("c")});
     QTest::newRow("filter-syntax17") << "{{ var|join:\"\" }}" << dict << QStringLiteral("abc") << NoError;
 
     // Make sure that any unicode strings are converted to bytestrings
     // in the final output.
     //   FAIL'filter-syntax18': (r'{{ var }}', {'var': UTF8Class()},
     //   u'\u0160\u0110\u0106\u017d\u0107\u017e\u0161\u0111'),
 
     // Numbers as filter arguments should work
     dict.clear();
     dict.insert(QStringLiteral("var"), QStringLiteral("hello world"));
     QTest::newRow("filter-syntax19") << QStringLiteral("{{ var|truncatewords:1 }}") << dict << QStringLiteral("hello ...") << NoError;
     // filters should accept empty string constants
     dict.clear();
     QTest::newRow("filter-syntax20") << R"({{ ""|default_if_none:"was none" }})" << dict << QString() << NoError;
 
     QTest::newRow("filter-syntax21") << "{{ \"\"|default_if_none:|truncatewords }}" << dict << QString() << EmptyVariableError;
 }
 
 void TestBuiltinSyntax::testCommentSyntax_data()
 {
     QTest::addColumn<QString>("input");
     QTest::addColumn<Dict>("dict");
     QTest::addColumn<QString>("output");
     QTest::addColumn<KTextTemplate::Error>("error");
 
     Dict dict;
 
     QTest::newRow("comment-syntax01") << QStringLiteral("{# this is hidden #}hello") << dict << QStringLiteral("hello") << NoError;
     QTest::newRow("comment-syntax02") << QStringLiteral("{# this is hidden #}hello{# foo #}") << dict << QStringLiteral("hello") << NoError;
     // Comments can contain invalid stuff.
     QTest::newRow("comment-syntax03") << QStringLiteral("foo{#  {% if %}  #}") << dict << QStringLiteral("foo") << NoError;
     QTest::newRow("comment-syntax04") << QStringLiteral("foo{#  {% endblock %}  #}") << dict << QStringLiteral("foo") << NoError;
     QTest::newRow("comment-syntax05") << QStringLiteral("foo{#  {% somerandomtag %}  #}") << dict << QStringLiteral("foo") << NoError;
     QTest::newRow("comment-syntax06") << QStringLiteral("foo{# {% #}") << dict << QStringLiteral("foo") << NoError;
     QTest::newRow("comment-syntax07") << QStringLiteral("foo{# %} #}") << dict << QStringLiteral("foo") << NoError;
     QTest::newRow("comment-syntax08") << QStringLiteral("foo{# %} #}bar") << dict << QStringLiteral("foobar") << NoError;
     QTest::newRow("comment-syntax09") << QStringLiteral("foo{# {{ #}") << dict << QStringLiteral("foo") << NoError;
     QTest::newRow("comment-syntax10") << QStringLiteral("foo{# }} #}") << dict << QStringLiteral("foo") << NoError;
     QTest::newRow("comment-syntax11") << QStringLiteral("foo{# { #}") << dict << QStringLiteral("foo") << NoError;
     QTest::newRow("comment-syntax12") << QStringLiteral("foo{# } #}") << dict << QStringLiteral("foo") << NoError;
 }
 
 void TestBuiltinSyntax::testMultiline_data()
 {
     QTest::addColumn<QString>("input");
     QTest::addColumn<Dict>("dict");
     QTest::addColumn<QString>("output");
     QTest::addColumn<KTextTemplate::Error>("error");
 
     Dict dict;
 
     QTest::newRow("multiline01") << "Hello,\nboys.\nHow\nare\nyou\ngentlemen?" << dict << "Hello,\nboys.\nHow\nare\nyou\ngentlemen?" << NoError;
 }
 
 void TestBuiltinSyntax::testEscaping_data()
 {
     QTest::addColumn<QString>("input");
     QTest::addColumn<Dict>("dict");
     QTest::addColumn<QString>("output");
     QTest::addColumn<KTextTemplate::Error>("error");
 
     Dict dict;
 
     // html escaping is not to be confused with for example url escaping.
     dict.insert(QStringLiteral("var"), QStringLiteral("< > & \" \' # = % $"));
     QTest::newRow("escape01") << QStringLiteral("{{ var }}") << dict << "&lt; &gt; &amp; &quot; &#39; # = % $" << NoError;
 
     dict.clear();
     dict.insert(QStringLiteral("var"), QStringLiteral("this & that"));
     QTest::newRow("escape02") << QStringLiteral("{{ var }}") << dict << QStringLiteral("this &amp; that") << NoError;
 
     // Strings are compared unescaped.
     QTest::newRow("escape03") << "{% ifequal var \"this & that\" %}yes{% endifequal %}" << dict << QStringLiteral("yes") << NoError;
 
     // Arguments to filters are 'safe' and manipulate their input unescaped.
     QTest::newRow("escape04") << "{{ var|cut:\"&\" }}" << dict << QStringLiteral("this  that") << NoError;
 
     dict.insert(QStringLiteral("varList"), QVariantList{QStringLiteral("Tom"), QStringLiteral("Dick"), QStringLiteral("Harry")});
     QTest::newRow("escape05") << "{{ varList|join:\" & \" }}" << dict << QStringLiteral("Tom & Dick & Harry") << NoError;
 
     // Unlike variable args.
     dict.insert(QStringLiteral("amp"), QStringLiteral(" & "));
     QTest::newRow("escape06") << QStringLiteral("{{ varList|join:amp }}") << dict << QStringLiteral("Tom &amp; Dick &amp; Harry") << NoError;
 
     // Literal strings are safe.
     QTest::newRow("escape07") << "{{ \"this & that\" }}" << dict << QStringLiteral("this & that") << NoError;
 
     // Iterating outputs safe characters.
     dict.clear();
     QVariantList list{QStringLiteral("K"), QStringLiteral("&"), QStringLiteral("R")};
     dict.insert(QStringLiteral("list"), list);
     QTest::newRow("escape08") << QStringLiteral("{% for letter in list %}{{ letter }},{% endfor %}") << dict << QStringLiteral("K,&amp;,R,") << NoError;
 
     dict.clear();
     // escape requirement survives lookup.
     QVariantHash hash;
     hash.insert(QStringLiteral("key"), QStringLiteral("this & that"));
     dict.insert(QStringLiteral("var"), hash);
     QTest::newRow("escape09") << QStringLiteral("{{ var.key }}") << dict << QStringLiteral("this &amp; that") << NoError;
 
     dict.clear();
 }
 
 void TestBuiltinSyntax::testMultipleStates()
 {
     auto engine1 = getEngine();
 
     auto loader1 = QSharedPointer<InMemoryTemplateLoader>(new InMemoryTemplateLoader());
 
     loader1->setTemplate(QStringLiteral("template1"), QStringLiteral("Template 1"));
     engine1->addTemplateLoader(loader1);
 
     auto t1 = engine1->newTemplate(QStringLiteral("{% include \"template1\" %}"), QStringLiteral("\"template1\""));
 
     auto engine2 = getEngine();
 
     auto loader2 = QSharedPointer<InMemoryTemplateLoader>(new InMemoryTemplateLoader());
 
     loader2->setTemplate(QStringLiteral("template2"), QStringLiteral("Template 2"));
 
     engine2->addTemplateLoader(loader2);
 
     auto t2 = engine2->newTemplate(QStringLiteral("{% include \"template2\" %}"), QStringLiteral("\"template2\""));
 
     auto engine3 = getEngine();
 
     auto loader3 = QSharedPointer<InMemoryTemplateLoader>(new InMemoryTemplateLoader());
 
     loader3->setTemplate(QStringLiteral("template3"), QStringLiteral("Template 3"));
 
     engine3->addTemplateLoader(loader3);
 
     auto t3 = engine3->newTemplate(QStringLiteral("{% include var %}"), QStringLiteral("var"));
 
     QVariantHash h;
     h.insert(QStringLiteral("var"), QStringLiteral("template3"));
     Context c(h);
     t1->render(&c);
 
     auto expected1 = QStringLiteral("Template 1");
     auto expected2 = QStringLiteral("Template 2");
     auto expected3 = QStringLiteral("Template 3");
     QCOMPARE(t1->render(&c), expected1);
     QCOMPARE(t2->render(&c), expected2);
     QCOMPARE(t3->render(&c), expected3);
 }
 
 void TestBuiltinSyntax::testAlternativeEscaping()
 {
     auto engine1 = getEngine();
 
     auto t1 = engine1->newTemplate(QStringLiteral("{{ var }} {% spaceless %}{{ var }}{% endspaceless %}"), QStringLiteral("\"template1\""));
 
     auto input = QStringLiteral("< > \r\n & \" \' # = % $");
 
     QVariantHash h;
     h.insert(QStringLiteral("var"), input);
     Context c(h);
 
     QString output;
     QTextStream ts(&output);
 
     NoEscapeOutputStream noEscapeOs(&ts);
 
     t1->render(&noEscapeOs, &c);
 
     QCOMPARE(output, QString(input + QLatin1String(" ") + input));
     output.clear();
 
     JSOutputStream jsOs(&ts);
 
     t1->render(&jsOs, &c);
 
     QString jsOutput(QStringLiteral("\\u003C \\u003E \\u000D\\u000A \\u0026 \\u0022 \\u0027 # \\u003D % $"));
 
     jsOutput = jsOutput + QLatin1String(" ") + jsOutput;
 
     QCOMPARE(output, jsOutput);
 }
 
 void TestBuiltinSyntax::testTemplatePathSafety_data()
 {
     QTest::addColumn<QString>("inputPath");
     QTest::addColumn<QString>("output");
 
     QTest::newRow("template-path-safety01") << QStringLiteral("visible_file") << QStringLiteral("visible_file");
     QTest::newRow("template-path-safety02") << QStringLiteral("../invisible_file") << QString();
 }
 
 void TestBuiltinSyntax::testTemplatePathSafety()
 {
     QFETCH(QString, inputPath);
     QFETCH(QString, output);
 
     auto loader = new FileSystemTemplateLoader();
 
     loader->setTemplateDirs({QStringLiteral(".")});
 
     QFile f(inputPath);
     auto opened = f.open(QFile::WriteOnly | QFile::Text);
     QVERIFY(opened);
     f.write(inputPath.toUtf8());
     f.close();
 
     auto t = loader->loadByName(inputPath, m_engine);
     Context c;
     if (output.isEmpty())
         QVERIFY(!t);
     else
         QCOMPARE(t->render(&c), inputPath);
 
     delete loader;
     f.remove();
 }
 
 void TestBuiltinSyntax::testMediaPathSafety_data()
 {
     QTest::addColumn<QString>("inputPath");
     QTest::addColumn<QString>("output");
 
     QTest::newRow("media-path-safety01") << QStringLiteral("visible_file") << QStringLiteral("./visible_file");
     QTest::newRow("media-path-safety02") << QStringLiteral("../invisible_file") << QString();
 }
 
 void TestBuiltinSyntax::testMediaPathSafety()
 {
     QFETCH(QString, inputPath);
     QFETCH(QString, output);
 
     auto loader = new FileSystemTemplateLoader();
 
     loader->setTemplateDirs({QStringLiteral(".")});
 
     QFile f(inputPath);
     auto opened = f.open(QFile::WriteOnly | QFile::Text);
     QVERIFY(opened);
     f.write(inputPath.toUtf8());
     f.close();
 
     auto uri = loader->getMediaUri(inputPath);
     if (output.isEmpty())
         QVERIFY(uri.second.isEmpty());
     else
         QCOMPARE(QFileInfo(uri.first + uri.second).absoluteFilePath(), QFileInfo(output).absoluteFilePath());
 
     delete loader;
     f.remove();
 }
 
 void TestBuiltinSyntax::testTypeAccessorsUnordered()
 {
     QFETCH(QString, input);
     QFETCH(Dict, dict);
     QFETCH(QStringList, output);
     QFETCH(KTextTemplate::Error, error);
 
     auto t = m_engine->newTemplate(input, QLatin1String(QTest::currentDataTag()));
 
     Context context(dict);
 
     auto result = t->render(&context);
     if (t->error() != NoError) {
         if (t->error() != error)
             qDebug() << t->errorString();
         QCOMPARE(t->error(), error);
         return;
     }
 
     QCOMPARE(t->error(), NoError);
 
     // Didn't catch any errors, so make sure I didn't expect any.
     QCOMPARE(NoError, error);
 
     for (const QString &s : output) {
         QVERIFY(result.contains(s));
     }
 
     QCOMPARE(result.length(), output.join(QString()).length());
 }
 
 void TestBuiltinSyntax::testTypeAccessorsUnordered_data()
 {
     QTest::addColumn<QString>("input");
     QTest::addColumn<Dict>("dict");
     QTest::addColumn<QStringList>("output");
     QTest::addColumn<KTextTemplate::Error>("error");
 
     Dict dict;
 
     QVariantHash itemsHash;
     itemsHash.insert(QStringLiteral("one"), 1);
     itemsHash.insert(QStringLiteral("two"), 2);
     itemsHash.insert(QStringLiteral("three"), 3);
 
     dict.insert(QStringLiteral("hash"), itemsHash);
 
     QTest::newRow("type-accessors-hash-unordered01") << QStringLiteral(
         "{% for key,value in hash.items %}{{ key }}:{{ value "
         "}};{% endfor %}") << dict << QStringList{QStringLiteral("one:1;"), QStringLiteral("two:2;"), QStringLiteral("three:3;")}
                                                      << NoError;
     QTest::newRow("type-accessors-hash-unordered02") << QStringLiteral("{% for key in hash.keys %}{{ key }};{% endfor %}") << dict
                                                      << QStringList{QStringLiteral("one;"), QStringLiteral("two;"), QStringLiteral("three;")} << NoError;
     QTest::newRow("type-accessors-hash-unordered03") << QStringLiteral("{% for value in hash.values %}{{ value }};{% endfor %}") << dict
                                                      << QStringList{QStringLiteral("1;"), QStringLiteral("2;"), QStringLiteral("3;")} << NoError;
 }
 
 void TestBuiltinSyntax::testTypeAccessors_data()
 {
     QTest::addColumn<QString>("input");
     QTest::addColumn<Dict>("dict");
     QTest::addColumn<QString>("output");
     QTest::addColumn<KTextTemplate::Error>("error");
 
     Dict dict;
 
     QVariantHash itemsHash;
     itemsHash.insert(QStringLiteral("one"), 1);
     itemsHash.insert(QStringLiteral("two"), 2);
     itemsHash.insert(QStringLiteral("three"), 3);
 
     dict.insert(QStringLiteral("hash"), itemsHash);
 
     QTest::newRow("type-accessors-hash01") << QStringLiteral("{{ hash.items|length }}") << dict << QStringLiteral("3") << NoError;
     QTest::newRow("type-accessors-hash02") << QStringLiteral("{{ hash.keys|length }}") << dict << QStringLiteral("3") << NoError;
     QTest::newRow("type-accessors-hash03") << QStringLiteral("{{ hash.values|length }}") << dict << QStringLiteral("3") << NoError;
 
     dict.clear();
     dict.insert(QStringLiteral("str1"), QStringLiteral("my string"));
     dict.insert(QStringLiteral("str2"), QStringLiteral("mystring"));
 
     QTest::newRow("type-accessors-string01") << QStringLiteral("{{ str1.capitalize }}") << dict << QStringLiteral("My string") << NoError;
     QTest::newRow("type-accessors-string02") << QStringLiteral("{{ str2.capitalize }}") << dict << QStringLiteral("Mystring") << NoError;
 
     dict.clear();
     dict.insert(QStringLiteral("str1"), QStringLiteral("de24335fre"));
     dict.insert(QStringLiteral("str2"), QStringLiteral("de435f3.-5r"));
 
     QTest::newRow("type-accessors-string03") << QStringLiteral("{{ str1.isalnum }}") << dict << QStringLiteral("True") << NoError;
     QTest::newRow("type-accessors-string04") << QStringLiteral("{{ str2.isalnum }}") << dict << QStringLiteral("False") << NoError;
 
     dict.clear();
     dict.insert(QStringLiteral("str1"), QStringLiteral("24335"));
     dict.insert(QStringLiteral("str2"), QStringLiteral("de435f35r"));
     dict.insert(QStringLiteral("str3"), QStringLiteral("de435f3.-5r"));
 
     QTest::newRow("type-accessors-string05") << QStringLiteral("{{ str1.isdigit }}") << dict << QStringLiteral("True") << NoError;
     QTest::newRow("type-accessors-string06") << QStringLiteral("{{ str2.isdigit }}") << dict << QStringLiteral("False") << NoError;
     QTest::newRow("type-accessors-string07") << QStringLiteral("{{ str3.isdigit }}") << dict << QStringLiteral("False") << NoError;
 
     dict.clear();
     dict.insert(QStringLiteral("str"), QStringLiteral("MyString"));
     dict.insert(QStringLiteral("lowerStr"), QStringLiteral("mystring"));
 
     QTest::newRow("type-accessors-string08") << QStringLiteral("{{ str.islower }}") << dict << QStringLiteral("False") << NoError;
     QTest::newRow("type-accessors-string09") << QStringLiteral("{{ lowerStr.islower }}") << dict << QStringLiteral("True") << NoError;
 
     dict.clear();
     dict.insert(QStringLiteral("str1"), QStringLiteral("        "));
     dict.insert(QStringLiteral("str2"), QStringLiteral("     r  "));
     dict.insert(QStringLiteral("str3"), QStringLiteral(" \t\nr  "));
     dict.insert(QStringLiteral("str4"), QStringLiteral(" \t\n   "));
 
     QTest::newRow("type-accessors-string10") << QStringLiteral("{{ str1.isspace }}") << dict << QStringLiteral("True") << NoError;
     QTest::newRow("type-accessors-string11") << QStringLiteral("{{ str2.isspace }}") << dict << QStringLiteral("False") << NoError;
     QTest::newRow("type-accessors-string12") << QStringLiteral("{{ str3.isspace }}") << dict << QStringLiteral("False") << NoError;
     QTest::newRow("type-accessors-string13") << QStringLiteral("{{ str4.isspace }}") << dict << QStringLiteral("True") << NoError;
 
     dict.clear();
     dict.insert(QStringLiteral("str1"), QStringLiteral("My String"));
     dict.insert(QStringLiteral("str2"), QStringLiteral("Mystring"));
     dict.insert(QStringLiteral("str3"), QStringLiteral("My string"));
     dict.insert(QStringLiteral("str4"), QStringLiteral("my string"));
 
     QTest::newRow("type-accessors-string14") << QStringLiteral("{{ str1.istitle }}") << dict << QStringLiteral("True") << NoError;
     QTest::newRow("type-accessors-string15") << QStringLiteral("{{ str2.istitle }}") << dict << QStringLiteral("True") << NoError;
     QTest::newRow("type-accessors-string16") << QStringLiteral("{{ str3.istitle }}") << dict << QStringLiteral("False") << NoError;
     QTest::newRow("type-accessors-string17") << QStringLiteral("{{ str4.istitle }}") << dict << QStringLiteral("False") << NoError;
 
     dict.clear();
     dict.insert(QStringLiteral("str"), QStringLiteral("MyString"));
     dict.insert(QStringLiteral("upperStr"), QStringLiteral("MYSTRING"));
 
     QTest::newRow("type-accessors-string18") << QStringLiteral("{{ str.isupper }}") << dict << QStringLiteral("False") << NoError;
     QTest::newRow("type-accessors-string19") << QStringLiteral("{{ upperStr.isupper }}") << dict << QStringLiteral("True") << NoError;
 
     dict.clear();
     dict.insert(QStringLiteral("str1"), QStringLiteral("My String"));
     dict.insert(QStringLiteral("str2"), QStringLiteral("MYSTRING"));
     dict.insert(QStringLiteral("str3"), QStringLiteral("MY STRING"));
 
     QTest::newRow("type-accessors-string20") << QStringLiteral("{{ str1.lower }}") << dict << QStringLiteral("my string") << NoError;
     QTest::newRow("type-accessors-string21") << QStringLiteral("{{ str2.lower }}") << dict << QStringLiteral("mystring") << NoError;
     QTest::newRow("type-accessors-string22") << QStringLiteral("{{ str3.lower }}") << dict << QStringLiteral("my string") << NoError;
 
     dict.clear();
     dict.insert(QStringLiteral("str"), QStringLiteral("one\ntwo three\nfour"));
 
     QTest::newRow("type-accessors-string23") << QStringLiteral("{% for line in str.splitlines %}{{ line }};{% endfor %}") << dict
                                              << QStringLiteral("one;two three;four;") << NoError;
 
     dict.clear();
     dict.insert(QStringLiteral("str1"), QStringLiteral("          one"));
     dict.insert(QStringLiteral("str2"), QStringLiteral("     one     "));
     dict.insert(QStringLiteral("str3"), QStringLiteral("one          "));
     dict.insert(QStringLiteral("str4"), QStringLiteral("             "));
     dict.insert(QStringLiteral("str5"), QStringLiteral(""));
 
     QTest::newRow("type-accessors-string24") << QStringLiteral("{{ str1.strip }}") << dict << QStringLiteral("one") << NoError;
     QTest::newRow("type-accessors-string25") << QStringLiteral("{{ str2.strip }}") << dict << QStringLiteral("one") << NoError;
     QTest::newRow("type-accessors-string26") << QStringLiteral("{{ str3.strip }}") << dict << QStringLiteral("one") << NoError;
     QTest::newRow("type-accessors-string27") << QStringLiteral("{{ str4.strip }}") << dict << QString() << NoError;
     QTest::newRow("type-accessors-string28") << QStringLiteral("{{ str5.strip }}") << dict << QString() << NoError;
 
     dict.clear();
     dict.insert(QStringLiteral("str1"), QStringLiteral("My String"));
     dict.insert(QStringLiteral("str2"), QStringLiteral("mY sTRING"));
     dict.insert(QStringLiteral("str3"), QStringLiteral("My StrInG"));
     dict.insert(QStringLiteral("str4"), QStringLiteral("my string"));
     dict.insert(QStringLiteral("str5"), QStringLiteral("MY STRING"));
 
     // Yes, this really is a python built-in.
     QTest::newRow("type-accessors-string29") << QStringLiteral("{{ str1.swapcase }}") << dict << QStringLiteral("mY sTRING") << NoError;
     QTest::newRow("type-accessors-string30") << QStringLiteral("{{ str2.swapcase }}") << dict << QStringLiteral("My String") << NoError;
     QTest::newRow("type-accessors-string31") << QStringLiteral("{{ str3.swapcase }}") << dict << QStringLiteral("mY sTRiNg") << NoError;
     QTest::newRow("type-accessors-string32") << QStringLiteral("{{ str4.swapcase }}") << dict << QStringLiteral("MY STRING") << NoError;
     QTest::newRow("type-accessors-string33") << QStringLiteral("{{ str5.swapcase }}") << dict << QStringLiteral("my string") << NoError;
 
     dict.clear();
     dict.insert(QStringLiteral("str1"), QStringLiteral("My String"));
     dict.insert(QStringLiteral("str2"), QStringLiteral("mystring"));
     dict.insert(QStringLiteral("str3"), QStringLiteral("my string"));
     dict.insert(QStringLiteral("str4"), QStringLiteral("my String"));
     dict.insert(QStringLiteral("str5"), QStringLiteral("My string"));
     dict.insert(QStringLiteral("str6"), QStringLiteral("123"));
     dict.insert(QStringLiteral("str7"), QString());
 
     QTest::newRow("type-accessors-string34") << QStringLiteral("{{ str1.title }}") << dict << QStringLiteral("My String") << NoError;
     QTest::newRow("type-accessors-string35") << QStringLiteral("{{ str2.title }}") << dict << QStringLiteral("Mystring") << NoError;
     QTest::newRow("type-accessors-string36") << QStringLiteral("{{ str3.title }}") << dict << QStringLiteral("My String") << NoError;
     QTest::newRow("type-accessors-string37") << QStringLiteral("{{ str4.title }}") << dict << QStringLiteral("My String") << NoError;
     QTest::newRow("type-accessors-string38") << QStringLiteral("{{ str5.title }}") << dict << QStringLiteral("My String") << NoError;
 
     QTest::newRow("type-accessors-string39") << QStringLiteral("{{ str1.upper }}") << dict << QStringLiteral("MY STRING") << NoError;
     QTest::newRow("type-accessors-string40") << QStringLiteral("{{ str2.upper }}") << dict << QStringLiteral("MYSTRING") << NoError;
     QTest::newRow("type-accessors-string41") << QStringLiteral("{{ str3.upper }}") << dict << QStringLiteral("MY STRING") << NoError;
     QTest::newRow("type-accessors-string42") << QStringLiteral("{{ str3.dne }}") << dict << QString() << NoError;
     QTest::newRow("type-accessors-string43") << QStringLiteral("{{ str2.isalpha }}") << dict << QStringLiteral("True") << NoError;
     QTest::newRow("type-accessors-string44") << QStringLiteral("{{ str3.isalpha }}") << dict << QStringLiteral("False") << NoError;
     QTest::newRow("type-accessors-string45") << QStringLiteral("{{ str6.isalpha }}") << dict << QStringLiteral("False") << NoError;
     QTest::newRow("type-accessors-string46") << QStringLiteral("{{ str7.isalpha }}") << dict << QStringLiteral("False") << NoError;
 
     dict.clear();
 
 #define SON(obj) obj->setObjectName(QStringLiteral(#obj))
 
     auto obj1 = new QObject(this);
     SON(obj1);
     auto obj2 = new QObject(this);
     SON(obj2);
     obj2->setParent(obj1);
     auto obj3 = new QObject(this);
     obj3->setParent(obj2);
     SON(obj3);
     auto obj4 = new QObject(this);
     obj4->setParent(obj2);
     SON(obj4);
 
     dict.insert(QStringLiteral("object"), QVariant::fromValue(obj1));
 
     QTest::newRow("type-accessors-qobject01") << QStringLiteral("{{ object.objectName }}") << dict << QStringLiteral("obj1") << NoError;
 
     const QLatin1String objectDumper(
         "<li>{{ object.objectName }}</li>"
         "{% if object.children %}"
         "<ul>"
         "{% for object in object.children %}"
         "{% include 'objectdumper.html' %}"
         "{% endfor %}"
         "</ul>"
         "{% endif %}");
 
     m_loader->setTemplate(QStringLiteral("objectdumper.html"), objectDumper);
 
     QTest::newRow("type-accessors-qobject02") << QStringLiteral("<ul>{% include 'objectdumper.html' %}</ul>") << dict
                                               << QString::fromLatin1(
                                                      "<ul>"
                                                      "<li>obj1</li>"
                                                      "<ul>"
                                                      "<li>obj2</li>"
                                                      "<ul>"
                                                      "<li>obj3</li>"
                                                      "<li>obj4</li>"
                                                      "</ul>"
                                                      "</ul>"
                                                      "</ul>")
                                               << NoError;
 }
 
 void TestBuiltinSyntax::testDynamicProperties_data()
 {
     QTest::addColumn<QString>("input");
     QTest::addColumn<Dict>("dict");
     QTest::addColumn<QString>("output");
     QTest::addColumn<KTextTemplate::Error>("error");
 
     Dict dict;
 
     auto obj = new QObject(this);
     obj->setProperty("prop", 7);
     dict.insert(QStringLiteral("var"), QVariant::fromValue(static_cast<QObject *>(obj)));
 
     QTest::newRow("dynamic-properties01") << QStringLiteral("{{ var.prop }}") << dict << QStringLiteral("7") << NoError;
 }
 
 void TestBuiltinSyntax::testGarbageInput()
 {
     QFETCH(QString, input);
 
     auto t = m_engine->newTemplate(input, QLatin1String(QTest::currentDataTag()));
 
     Dict dict;
 
     Context context(dict);
 
     auto result = t->render(&context);
 
     QCOMPARE(t->error(), NoError);
 
     QCOMPARE(result, input);
 }
 
 void TestBuiltinSyntax::testGarbageInput_data()
 {
     QTest::addColumn<QString>("input");
 
     Dict dict;
 
     QTest::newRow("garbage-input01") << QStringLiteral("content %}");
     QTest::newRow("garbage-input02") << QStringLiteral(" content %}");
     QTest::newRow("garbage-input03") << QStringLiteral("content #}");
     QTest::newRow("garbage-input04") << QStringLiteral(" content #}");
     QTest::newRow("garbage-input05") << QStringLiteral("content }}");
     QTest::newRow("garbage-input06") << QStringLiteral(" content }}");
     QTest::newRow("garbage-input07") << QStringLiteral("% content %}");
     QTest::newRow("garbage-input08") << QStringLiteral("# content #}");
     QTest::newRow("garbage-input09") << QStringLiteral("{ content }}");
     QTest::newRow("garbage-input10") << QStringLiteral("{% content }");
     QTest::newRow("garbage-input11") << QStringLiteral("{% content %");
     QTest::newRow("garbage-input12") << QStringLiteral("{# content }");
     QTest::newRow("garbage-input13") << QStringLiteral("{# content #");
     QTest::newRow("garbage-input14") << QStringLiteral("{{ content }");
     QTest::newRow("garbage-input15") << QStringLiteral("{{ content }");
     QTest::newRow("garbage-input16") << QStringLiteral("{{ content %}");
     QTest::newRow("garbage-input17") << QStringLiteral("{% content }}");
     QTest::newRow("garbage-input18") << QStringLiteral("{{ content #}");
     QTest::newRow("garbage-input19") << QStringLiteral("{# content }}");
     QTest::newRow("garbage-input20") << QStringLiteral("{{ con #} tent #}");
     QTest::newRow("garbage-input21") << QStringLiteral("{{ con %} tent #}");
     QTest::newRow("garbage-input22") << QStringLiteral("{{ con #} tent %}");
     QTest::newRow("garbage-input23") << QStringLiteral("{{ con %} tent %}");
     QTest::newRow("garbage-input24") << QStringLiteral("{% con #} tent #}");
     QTest::newRow("garbage-input25") << QStringLiteral("{% con }} tent #}");
     QTest::newRow("garbage-input26") << QStringLiteral("{% con #} tent }}");
     QTest::newRow("garbage-input27") << QStringLiteral("{% con }} tent }}");
     QTest::newRow("garbage-input28") << QStringLiteral("{# con %} tent %}");
     QTest::newRow("garbage-input29") << QStringLiteral("{# con }} tent %}");
     QTest::newRow("garbage-input30") << QStringLiteral("{# con %} tent }}");
     QTest::newRow("garbage-input31") << QStringLiteral("{# con }} tent }}");
     QTest::newRow("garbage-input32") << QStringLiteral("{# con {# tent }}");
     QTest::newRow("garbage-input33") << QStringLiteral("{# con {% tent }}");
     QTest::newRow("garbage-input34") << QStringLiteral("{% con {% tent }}");
     QTest::newRow("garbage-input35") << QStringLiteral("{ { content }}");
     QTest::newRow("garbage-input36") << QStringLiteral("{ % content %}");
     QTest::newRow("garbage-input37") << QStringLiteral("{ # content #}");
     QTest::newRow("garbage-input38") << QStringLiteral("{\n{ content }}");
     QTest::newRow("garbage-input39") << QStringLiteral("{\n# content #}");
     QTest::newRow("garbage-input40") << QStringLiteral("{\n% content %}");
     QTest::newRow("garbage-input41") << QStringLiteral("{{\n content }}");
     QTest::newRow("garbage-input42") << QStringLiteral("{#\n content #}");
     QTest::newRow("garbage-input43") << QStringLiteral("{%\n content %}");
     QTest::newRow("garbage-input44") << QStringLiteral("{{ content \n}}");
     QTest::newRow("garbage-input45") << QStringLiteral("{# content \n#}");
     QTest::newRow("garbage-input46") << QStringLiteral("{% content \n%}");
     QTest::newRow("garbage-input47") << QStringLiteral("{{ content }\n}");
     QTest::newRow("garbage-input48") << QStringLiteral("{# content #\n}");
     QTest::newRow("garbage-input49") << QStringLiteral("{% content %\n}");
     QTest::newRow("garbage-input50") << QStringLiteral("{{ content } }");
     QTest::newRow("garbage-input51") << QStringLiteral("{% content % }");
     QTest::newRow("garbage-input52") << QStringLiteral("{# content # }");
     QTest::newRow("garbage-input53") << QStringLiteral("{ { content } }");
     QTest::newRow("garbage-input54") << QStringLiteral("{ % content % }");
     QTest::newRow("garbage-input55") << QStringLiteral("{ # content # }");
     QTest::newRow("garbage-input56") << QStringLiteral("{{ content }%");
     QTest::newRow("garbage-input57") << QStringLiteral("{# content #%");
     QTest::newRow("garbage-input58") << QStringLiteral("{% content %%");
     QTest::newRow("garbage-input59") << QStringLiteral("{{ content }A");
     QTest::newRow("garbage-input60") << QStringLiteral("{# content #A");
     QTest::newRow("garbage-input61") << QStringLiteral("{% content %A");
     QTest::newRow("garbage-input62") << QStringLiteral("{{ content A}");
     QTest::newRow("garbage-input63") << QStringLiteral("{# content A#");
     QTest::newRow("garbage-input64") << QStringLiteral("{% content A%");
     QTest::newRow("garbage-input65") << QStringLiteral("{# content A}");
     QTest::newRow("garbage-input66") << QStringLiteral("{% content A}");
     QTest::newRow("garbage-input67") << QStringLiteral("A{ content }}");
     QTest::newRow("garbage-input68") << QStringLiteral("A# content #}");
     QTest::newRow("garbage-input69") << QStringLiteral("A% content %}");
     QTest::newRow("garbage-input60") << QStringLiteral("{A content }}");
     QTest::newRow("garbage-input71") << QStringLiteral("{A content #}");
     QTest::newRow("garbage-input72") << QStringLiteral("{A content %}");
     QTest::newRow("garbage-input73") << QStringLiteral("{A content #}");
     QTest::newRow("garbage-input74") << QStringLiteral("{A content %}");
     QTest::newRow("garbage-input75") << QStringLiteral("{A content A}");
     QTest::newRow("garbage-input76") << QStringLiteral("}} content }}");
     QTest::newRow("garbage-input77") << QStringLiteral("}} content {{");
     QTest::newRow("garbage-input78") << QStringLiteral("#} content #}");
     QTest::newRow("garbage-input79") << QStringLiteral("#} content {#");
     QTest::newRow("garbage-input80") << QStringLiteral("%} content %}");
     QTest::newRow("garbage-input81") << QStringLiteral("%} content {%");
     QTest::newRow("garbage-input82") << QStringLiteral("#{ content }#");
     QTest::newRow("garbage-input83") << QStringLiteral("%{ content }%");
 }
 
 void TestBuiltinSyntax::testInsignificantWhitespace()
 {
     QFETCH(QString, input);
     QFETCH(Dict, dict);
     QFETCH(QString, stripped_output);
     QFETCH(QString, unstripped_output);
 
     Context context(dict);
 
     QVERIFY(!m_engine->smartTrimEnabled());
     m_engine->setSmartTrimEnabled(true);
     QVERIFY(m_engine->smartTrimEnabled());
 
     {
         auto t = m_engine->newTemplate(input, QLatin1String(QTest::currentDataTag()));
 
         auto result = t->render(&context);
 
         QCOMPARE(t->error(), NoError);
 
         QCOMPARE(result, stripped_output);
     }
     m_engine->setSmartTrimEnabled(false);
     {
         auto t = m_engine->newTemplate(input, QLatin1String(QTest::currentDataTag()));
 
         auto result = t->render(&context);
 
         QCOMPARE(t->error(), NoError);
 
         QCOMPARE(result, unstripped_output);
     }
 }
 
 void TestBuiltinSyntax::testInsignificantWhitespace_data()
 {
     QTest::addColumn<QString>("input");
     QTest::addColumn<Dict>("dict");
     QTest::addColumn<QString>("stripped_output");
     QTest::addColumn<QString>("unstripped_output");
 
     Dict dict;
 
     QTest::newRow("insignificant-whitespace01") << QStringLiteral("\n {% templatetag openblock %}\n") << dict << QStringLiteral("{%\n")
                                                 << QStringLiteral("\n {%\n");
 
     QTest::newRow("insignificant-whitespace02") << QStringLiteral("\n{% templatetag openblock %}\n") << dict << QStringLiteral("{%\n")
                                                 << QStringLiteral("\n{%\n");
 
     QTest::newRow("insignificant-whitespace03") << QStringLiteral("{% templatetag openblock %}\n") << dict << QStringLiteral("{%\n") << QStringLiteral("{%\n");
 
     QTest::newRow("insignificant-whitespace04") << QStringLiteral("\n\t \t {% templatetag openblock %}\n") << dict << QStringLiteral("{%\n")
                                                 << QStringLiteral("\n\t \t {%\n");
 
     // Leading whitespace with text before single template tag
     QTest::newRow("insignificant-whitespace05") << QStringLiteral("\n some\ttext {% templatetag openblock %}\n") << dict << QStringLiteral("\n some\ttext {%\n")
                                                 << QStringLiteral("\n some\ttext {%\n");
 
     // Leading line with text before single template tag
     QTest::newRow("insignificant-whitespace06") << QStringLiteral("\n some\ttext\n {% templatetag openblock %}\n") << dict
                                                 << QStringLiteral("\n some\ttext{%\n") << QStringLiteral("\n some\ttext\n {%\n");
     QTest::newRow("insignificant-whitespace07") << QStringLiteral("\n some\ttext \n \t {% templatetag openblock %}\n") << dict
                                                 << QStringLiteral("\n some\ttext {%\n") << QStringLiteral("\n some\ttext \n \t {%\n");
 
     // whitespace leading /before/ the newline is not stripped.
     QTest::newRow("insignificant-whitespace08") << QStringLiteral("\n some\ttext \t \n {% templatetag openblock %}\n") << dict
                                                 << QStringLiteral("\n some\ttext \t {%\n") << QStringLiteral("\n some\ttext \t \n {%\n");
 
     // Multiple text lines before tag
     QTest::newRow("insignificant-whitespace09") << QStringLiteral("\n some\ntext \t \n {% templatetag openblock %}\n") << dict
                                                 << QStringLiteral("\n some\ntext \t {%\n") << QStringLiteral("\n some\ntext \t \n {%\n");
     QTest::newRow("insignificant-whitespace10") << QStringLiteral("\n some \t \n \t text \t \n {% templatetag openblock %}\n") << dict
                                                 << QStringLiteral("\n some \t \n \t text \t {%\n") << QStringLiteral("\n some \t \n \t text \t \n {%\n");
 
     // Leading whitespace before tag, some text after
     QTest::newRow("insignificant-whitespace11") << QStringLiteral("\n   \t {% templatetag openblock %} some text\n") << dict
                                                 << QStringLiteral("\n   \t {% some text\n") << QStringLiteral("\n   \t {% some text\n");
 
     // Leading whitespace before tag, some text with trailing whitespace after
     QTest::newRow("insignificant-whitespace12") << QStringLiteral("\n   \t {% templatetag openblock %} some text  \t \n") << dict
                                                 << QStringLiteral("\n   \t {% some text  \t \n") << QStringLiteral("\n   \t {% some text  \t \n");
 
     // Whitespace after tag is not removed
     QTest::newRow("insignificant-whitespace13") << QStringLiteral("\n \t {% templatetag openblock %} \t \n \t some text  \t \n") << dict
                                                 << QStringLiteral("{% \t \n \t some text  \t \n") << QStringLiteral("\n \t {% \t \n \t some text  \t \n");
 
     // Multiple lines of leading whitespace. Only one leading newline is removed
     QTest::newRow("insignificant-whitespace14") << QStringLiteral("\n\n\n{% templatetag openblock %}\n some text\n") << dict
                                                 << QStringLiteral("\n\n{%\n some text\n") << QStringLiteral("\n\n\n{%\n some text\n");
 
     // Trailing whitespace after tag
     QTest::newRow("insignificant-whitespace15") << QStringLiteral("\n\n\n{% templatetag openblock %}\t \t \t\n some text\n") << dict
                                                 << QStringLiteral("\n\n{%\t \t \t\n some text\n") << QStringLiteral("\n\n\n{%\t \t \t\n some text\n");
 
     // Removable newline followed by leading whitespace
     QTest::newRow("insignificant-whitespace16") << QStringLiteral("\n\n\n\t \t \t{% templatetag openblock %}\n some text\n") << dict
                                                 << QStringLiteral("\n\n{%\n some text\n") << QStringLiteral("\n\n\n\t \t \t{%\n some text\n");
 
     // Removable leading whitespace and trailing whitespace
     QTest::newRow("insignificant-whitespace17") << QStringLiteral("\n\n\n\t \t \t{% templatetag openblock %}\t \t \t\n some text\n") << dict
                                                 << QStringLiteral("\n\n{%\t \t \t\n some text\n") << QStringLiteral("\n\n\n\t \t \t{%\t \t \t\n some text\n");
 
     // Multiple lines of trailing whitespace. No trailing newline is removed.
     QTest::newRow("insignificant-whitespace18") << QStringLiteral("\n{% templatetag openblock %}\n\n\n some text\n") << dict
                                                 << QStringLiteral("{%\n\n\n some text\n") << QStringLiteral("\n{%\n\n\n some text\n");
     QTest::newRow("insignificant-whitespace19") << QStringLiteral("\n{% templatetag openblock %}\t \n\n\n some text\n") << dict
                                                 << QStringLiteral("{%\t \n\n\n some text\n") << QStringLiteral("\n{%\t \n\n\n some text\n");
 
     // Consecutive trimmed lines with tags strips one newline each
     QTest::newRow("insignificant-whitespace20") << QStringLiteral(
         "\n{% templatetag openblock %}\n{% templatetag openblock %}\n{% "
         "templatetag openblock %}\n some text\n")
                                                 << dict << QStringLiteral("{%{%{%\n some text\n") << QStringLiteral("\n{%\n{%\n{%\n some text\n");
 
     // Consecutive trimmed lines with tags strips one newline each. Intermediate
     // newlines are preserved
     QTest::newRow("insignificant-whitespace21") << QStringLiteral(
         "\n\n{% templatetag openblock %}\n\n{% templatetag openblock "
         "%}\n\n{% templatetag openblock %}\n\n some text\n")
                                                 << dict << QStringLiteral("\n{%\n{%\n{%\n\n some text\n")
                                                 << QStringLiteral("\n\n{%\n\n{%\n\n{%\n\n some text\n");
 
     // Consecutive trimmed lines with tags strips one newline each. Leading
     // whitespace is stripped but trailing is not
     QTest::newRow("insignificant-whitespace22") << QStringLiteral(
         "\n\n\t {% templatetag openblock %}\t \n\n\t {% "
         "templatetag openblock %}\t \n\n\t {% templatetag "
         "openblock %}\t \n some text\n") << dict << QStringLiteral("\n{%\t \n{%\t \n{%\t \n some text\n")
                                                 << QStringLiteral("\n\n\t {%\t \n\n\t {%\t \n\n\t {%\t \n some text\n");
 
     // Consecutive trimmed lines with tags strips one newline each. Intermediate
     // whitespace is stripped
     QTest::newRow("insignificant-whitespace23") << QStringLiteral(
         "\n\t {% templatetag openblock %}\t \n\t {% templatetag openblock "
         "%}\t \n\t {% templatetag openblock %}\t \n some text\n")
                                                 << dict << QStringLiteral("{%\t {%\t {%\t \n some text\n")
                                                 << QStringLiteral("\n\t {%\t \n\t {%\t \n\t {%\t \n some text\n");
 
     // Intermediate whitespace on one line is preserved
     // Consecutive tags on one line do not have intermediate whitespace or
     // leading
     // whitespace stripped
     QTest::newRow("insignificant-whitespace24") << QStringLiteral(
         "\n\t {% templatetag openblock %}\t \t {% templatetag openblock "
         "%}\t \t {% templatetag openblock %}\t \n some text\n")
                                                 << dict << QStringLiteral("\n\t {%\t \t {%\t \t {%\t \n some text\n")
                                                 << QStringLiteral("\n\t {%\t \t {%\t \t {%\t \n some text\n");
 
     // Still, only one leading newline is removed.
     QTest::newRow("insignificant-whitespace25") << QStringLiteral(
         "\n\n {% templatetag openblock %}\n \t {% templatetag openblock "
         "%}\n \t {% templatetag openblock %}\n some text\n")
                                                 << dict << QStringLiteral("\n{%{%{%\n some text\n") << QStringLiteral("\n\n {%\n \t {%\n \t {%\n some text\n");
 
     // Lines with {# comments #} have the same stripping behavior
     QTest::newRow("insignificant-whitespace26") << QStringLiteral(
         "\n\n {% templatetag openblock %}\n \t {# some comment "
         "#}\n some text\n") << dict << QStringLiteral("\n{%\n some text\n")
                                                 << QStringLiteral("\n\n {%\n \t \n some text\n");
 
     // Only {# comments #}
     QTest::newRow("insignificant-whitespace27") << QStringLiteral("\n\n {# a comment #}\n \t {# some comment #}\n some text\n") << dict
                                                 << QStringLiteral("\n\n some text\n") << QStringLiteral("\n\n \n \t \n some text\n");
 
     // Consecutive newlines with tags and comments
     QTest::newRow("insignificant-whitespace28") << QStringLiteral(
         "\n\t {% templatetag openblock %}\t \n\t {# some comment #}\t "
         "\n\t {% templatetag openblock %}\t \n some text\n")
                                                 << dict << QStringLiteral("{%\t \t {%\t \n some text\n")
                                                 << QStringLiteral("\n\t {%\t \n\t \t \n\t {%\t \n some text\n");
 
     dict.insert(QStringLiteral("spam"), QStringLiteral("ham"));
     // Lines with only {{ values }} have the same stripping behavior
     QTest::newRow("insignificant-whitespace29") << QStringLiteral(
         "\n {% templatetag openblock %}\t\n \t {{ spam }}\t \n "
         "\t {% templatetag openblock %}\t \n some text\n")
                                                 << dict << QStringLiteral("{%\tham\t {%\t \n some text\n")
                                                 << QStringLiteral("\n {%\t\n \t ham\t \n \t {%\t \n some text\n");
     QTest::newRow("insignificant-whitespace30") << QStringLiteral(
         "\n\n {% templatetag openblock %}\t\n\n \t {{ spam }}\t \n\n \t "
         "{% templatetag openblock %}\t \n some text\n")
                                                 << dict << QStringLiteral("\n{%\t\nham\t \n{%\t \n some text\n")
                                                 << QStringLiteral("\n\n {%\t\n\n \t ham\t \n\n \t {%\t \n some text\n");
 
     // Leading whitespace not stripped when followed by anything. See
     // templatetag-whitespace24
     QTest::newRow("insignificant-whitespace31") << QStringLiteral(
         "\n {% templatetag openblock %}\t \t {{ spam }}\t \t "
         "{% templatetag openblock %}\t \n some text\n")
                                                 << dict << QStringLiteral("\n {%\t \t ham\t \t {%\t \n some text\n")
                                                 << QStringLiteral("\n {%\t \t ham\t \t {%\t \n some text\n");
 
     // {{ value }} {% tag %} {{ value }} this time
     QTest::newRow("insignificant-whitespace32") << QStringLiteral(
         "\n {{ spam }}\t\n \t {% templatetag openblock %}\t \n "
         "\t {{ spam }}\t \n some text\n") << dict
                                                 << QStringLiteral("ham\t{%\t ham\t \n some text\n")
                                                 << QStringLiteral("\n ham\t\n \t {%\t \n \t ham\t \n some text\n");
 
     // Invalid stuff is still invalid
     // Newlines inside begin-end tokens, even in {# comments #}, make it not a
     // tag.
     QTest::newRow("insignificant-whitespace33") << QStringLiteral("\n\n {# \n{% templatetag openblock #}\t \n some text\n") << dict
                                                 << QStringLiteral("\n\n {# \n{% templatetag openblock #}\t \n some text\n")
                                                 << QStringLiteral("\n\n {# \n{% templatetag openblock #}\t \n some text\n");
 
     // Complete comment matching tags on one line are processed
     QTest::newRow("insignificant-whitespace34") << QStringLiteral("\n\n {# \n{# templatetag openblock #}\t \n some text\n") << dict
                                                 << QStringLiteral("\n\n {# \t \n some text\n") << QStringLiteral("\n\n {# \n\t \n some text\n");
     QTest::newRow("insignificant-whitespace35") << QStringLiteral("\n\n {# \n{# templatetag openblock\n #}\t \n some text\n") << dict
                                                 << QStringLiteral("\n\n {# \n{# templatetag openblock\n #}\t \n some text\n")
                                                 << QStringLiteral("\n\n {# \n{# templatetag openblock\n #}\t \n some text\n");
     QTest::newRow("insignificant-whitespace36") << QStringLiteral("\n\n {# \n{{ some comment #}\t \n some text\n") << dict
                                                 << QStringLiteral("\n\n {# \n{{ some comment #}\t \n some text\n")
                                                 << QStringLiteral("\n\n {# \n{{ some comment #}\t \n some text\n");
     QTest::newRow("insignificant-whitespace37") << QStringLiteral("\n\n {# \n \t {% templatetag openblock #}\t \n some text\n") << dict
                                                 << QStringLiteral("\n\n {# \n \t {% templatetag openblock #}\t \n some text\n")
                                                 << QStringLiteral("\n\n {# \n \t {% templatetag openblock #}\t \n some text\n");
     QTest::newRow("insignificant-whitespace38") << QStringLiteral("\n\n {# templatetag openblock #\n}\t \n some text\n") << dict
                                                 << QStringLiteral("\n\n {# templatetag openblock #\n}\t \n some text\n")
                                                 << QStringLiteral("\n\n {# templatetag openblock #\n}\t \n some text\n");
     QTest::newRow("insignificant-whitespace39") << QStringLiteral("\n\n {% templatetag openblock %\n}\t \n some text\n") << dict
                                                 << QStringLiteral("\n\n {% templatetag openblock %\n}\t \n some text\n")
                                                 << QStringLiteral("\n\n {% templatetag openblock %\n}\t \n some text\n");
     QTest::newRow("insignificant-whitespace40") << QStringLiteral("\n\n {{ templatetag openblock }\n}\t \n some text\n") << dict
                                                 << QStringLiteral("\n\n {{ templatetag openblock }\n}\t \n some text\n")
                                                 << QStringLiteral("\n\n {{ templatetag openblock }\n}\t \n some text\n");
     QTest::newRow("insignificant-whitespace41") << QStringLiteral("\n\n {\n# {# templatetag openblock #}\t \n some text\n") << dict
                                                 << QStringLiteral("\n\n {\n# \t \n some text\n") << QStringLiteral("\n\n {\n# \t \n some text\n");
     QTest::newRow("insignificant-whitespace42") << QStringLiteral("\n\n {\n {# templatetag openblock #}\t \n some text\n") << dict
                                                 << QStringLiteral("\n\n {\t \n some text\n") << QStringLiteral("\n\n {\n \t \n some text\n");
     QTest::newRow("insignificant-whitespace43") << QStringLiteral("\n{{# foo #};{# bar #}\n") << dict << QStringLiteral("\n{;\n") << QStringLiteral("\n{;\n");
 
     QTest::newRow("insignificant-whitespace44") << QStringLiteral("\n{{ foo }} ") << dict << QString() << QStringLiteral("\n ");
 }
 
 QTEST_MAIN(TestBuiltinSyntax)
 #include "testbuiltins.moc"
 
 #endif