#include <QtCore/QString>
#include <QtCore/QStringList>
#include <QtCore/QDebug>

const char * some_char_pointer_indirection(const char *)
{
    return nullptr;
}

const char * some_char_pointer()
{
    return nullptr;
}

void test()
{
    QString s1;
    const char *cstring = "foo";
    s1.contains(QLatin1String("string")); // Warning
    s1.contains(some_char_pointer()); // OK

    QString s2 = QStringLiteral("string"); // Warning
    QString s3 = QStringLiteral("string"); // OK
    QString s4(some_char_pointer()); // OK

    s1 += QLatin1String("foo"); // Warning
    s1 += QStringLiteral("foo"); // OK
    s1 += QLatin1String("foo"); // OK

    QString s5 = QStringLiteral("BAR"); // Warning
    QString s6 = QStringLiteral("BAR"); // Warning
    QString s7 = QString::fromLatin1(some_char_pointer()); // OK
    QString s8 = QString::fromUtf8(some_char_pointer()); // OK
    QString s81 = QString::fromUtf8(some_char_pointer_indirection("foo")); // OK
    QString s123 = QString::fromLatin1(some_char_pointer_indirection("foo")); // OK

    QString s9 = QStringLiteral("string"); // Warning
    s9 =  QStringLiteral("string"); // Warning
    s9 =  QLatin1String(some_char_pointer_indirection("foo")); // OK
    QString s10 = true ? QStringLiteral("string1") : QStringLiteral("string2"); // Warning
    s10 = true ? QStringLiteral("string1") :  QStringLiteral("string2"); // Warning

    QString s11 = QStringLiteral("foo"); // Warning
    QStringList stringList;
    stringList << QString::fromLatin1("foo", 1); // OK
    QString s12 = QLatin1String(""); // OK, QString is optimized for the empty case
    QString s = QLatin1String(cstring + sizeof("foo")); // OK
    s = QStringLiteral("bar %1").arg(1); // Warning
    s = QString::fromLatin1(true ? "foo" : "foo2").arg(1); // Warning
    s += QLatin1String(  // Warning: Multi-line, to test FIXIT
        "foo" );
    QString::fromLatin1(true ? cstring : "cstring"); // OK
    QString escaped = QStringLiteral("\\\\"); // Warning
    QString s13 = QStringLiteral("foo"); // Warning
    QString s14 = QLatin1String(""); // Warning
    QString s15 = QLatin1String(""); // Warning
    s15.startsWith(QLatin1String("ff")); // OK
    s15.startsWith(QLatin1String("ff")); // Warning, should be QLatin1String
    s15.contains(QLatin1String("ff")); // Warning, should be QStringLiteral
    s15.indexOf(QLatin1String("ff")); // Warning, should be QStringLiteral
}








struct A
{
    A() : member(QStringLiteral("foo")) {} // Warning
    QString member;
};

struct A2
{
    A2() : member(QStringLiteral("foo")) // OK
         , member2(QStringLiteral("foo")) {} // Warning
    void  test(const QString &calendarType = QStringLiteral("gregorian") ); // Warning
    QString member;
    QString member2;
};

void test3()
{
    QString s;
    if (s == QLatin1String("foo")) // Warning
        return;
    if (s == QStringLiteral("foo %1").arg(1)) // Warning
        return;
}

void test4(const QString &) {}

void test5()
{
    test4(QStringLiteral("foo")); // Warning
    QString s;
    s.contains(QLatin1String("a")); // Warning
    s.compare(QStringLiteral("a"), QLatin1String("a")); // Warning
}

#include <exception>
void exceptionTest() // Just to test a crash
{
    try {

    } catch (std::exception e) {

    }
}

QStringList returns_stringlist(QString) { return {}; }

void test_foreach()
{
    foreach (const QString &s, returns_stringlist(QLatin1String("bar"))) // Warning
    {
    }
}

void testCharsets()
{
    QString s = QStringLiteral("é");
    s += QStringLiteral("é");
    s += QLatin1String("e");
    s.compare(QStringLiteral("é"), QStringLiteral("e"));
    s.startsWith(QStringLiteral("é"));
    s.startsWith(QLatin1String("e"));
    foreach (const QString &s, returns_stringlist(QLatin1String("éÈ"))) { }
    QString s11 = QLatin1String("é");

    if (s == QLatin1String("foó"))
        return;
    if (s == QString::fromLatin1("foó %1").arg(1))
        return;
    s.contains(QLatin1String("é"));
    s += QLatin1String(
        "fóó" );
    QString s123 = QString::fromLatin1(some_char_pointer_indirection("fóó"));
    QString s9 = QLatin1String("stringéééé");
}

struct TestCharsets
{
    TestCharsets() : member(QStringLiteral("é"))
         , member2(QLatin1String("é")) {} // Warning
    void  test(const QString &calendarType = QLatin1String("éééé´e") );
    void test2();
    QString member;
    QString member2;
};











void moreShouldBeQLatin1String()
{
    QString s;
    bool b = (s == QLatin1String("="));
    if (s.startsWith(QLatin1String("Version=5"))) {}
    if (s.startsWith(QLatin1String("Version=5"))) {} // OK
    QString result = QLatin1String("Enum") + s;
}

void TestCharsets::test2()
{
    QString s = QString::fromLatin1("é"); // Can't fix this weird one
    QString s2 = QStringLiteral("é");
    s2 += QLatin1String("é");
    s2 += QStringLiteral("é");
    s = QStringLiteral("á");
    s += QStringLiteral("á");
    QStringLiteral("á");
    QStringList slist;
    slist << QStringLiteral("á") << QStringLiteral("a");
}





#include <QtCore/QRegExp>
void testBlacklistedQRegExp()
{
    QRegExp exp1("literal");
    QRegExp exp2(QLatin1String("literal"));
}


void charsetEdgeCase()
{
    test4(QLatin1String("ááá"));
}

void testQDebug()
{
    qDebug() << "test"; // OK
}

void testEmpty()
{
    QStringList list = QStringList() << QStringLiteral("foo") << QLatin1String("");
}


void test_bug358732()
{
    QStringLiteral("foo").sprintf("0x%02X", 0x1E); // Warn and use QSL
    QStringLiteral("").sprintf("0x%02X", 0x1E); // Warn and use QSL
}


struct QTestData {};

template<typename T>
QTestData &operator<<(QTestData &data, const T &value);

void test_QTestData()
{
    QTestData t;
    t << QStringLiteral("foo");
}

void test_QStringList_streamOp()
{
    QStringList list;
    list << QStringLiteral("foo") << QStringLiteral("foo") << QStringLiteral("foo") << QStringLiteral("foo");
    list += QStringLiteral("foo");
    list += QStringLiteral("foo");
    list += QStringLiteral("foo");
    list += QStringLiteral("foo");
}

void testQLatin1String2Args()
{
    QString s2 = QLatin1String("foo", 3);
}

QString s = QStringLiteral("ö");
QString s2 = QString::fromUtf8("\xc3\xb6");
QString s3 = true ? "ö" : "\xc3\xb6";


// bug #391807
Q_GLOBAL_STATIC_WITH_ARGS(const QString, strUnit, (QLatin1String("unit"))) // OK, since QStringLiteral doesn't work inside Q_GLOBAL_STATIC_WITH_ARGS