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

**

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the test suite of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

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

#include <QtTest/QtTest>

#include <stdio.h>

#include <qobject.h>

#include "using-namespaces.h"

#include "assign-namespace.h"

#include "no-keywords.h"

#include "single_function_keyword.h"

#include "backslash-newlines.h"

#include "slots-with-void-template.h"

#include "pure-virtual-signals.h"

#include "qinvokable.h"

// msvc and friends crap out on it

#if !defined(Q_CC_GNU) || defined(Q_OS_IRIX) || defined(Q_OS_WIN)

#define SKIP_NEWLINE_TEST

#endif

#if !defined(SKIP_NEWLINE_TEST)

#include "os9-newlines.h"

// msvc and friends crap out on this file too,

// it seems to contain Mac 9 EOLs, and not windows EOLs.

#include "win-newlines.h"

#endif

#include "escapes-in-string-literals.h"

#include "cstyle-enums.h"

#if defined(PARSE_BOOST)

#include "parse-boost.h"

#endif

// No such thing as "long long" in Microsoft's compiler 13.0 and before

#if defined Q_CC_MSVC && _MSC_VER <= 1310

#  define NOLONGLONG

#endif

QT_USE_NAMESPACE

struct MyStruct {};

struct MyStruct2 {};

struct SuperClass {};

// Try to avoid inserting for instance a comment with a quote between the following line and the Q_OBJECT

// That will make the test give a false positive.

const char* test_multiple_number_of_escapes =   "\\\"";

namespace MyNamespace

{

    class TestSuperClass : public QObject

    {

        Q_OBJECT

        public:

            inline TestSuperClass() {}

    };

}

namespace String

{

    typedef QString Type;

}

namespace Int

{

    typedef int Type;

}

typedef struct {

    int doNotConfuseMoc;

} OldStyleCStruct;

class Sender : public QObject

{

    Q_OBJECT

public:

    void sendValue(const String::Type& value)

    {

        emit send(value);

    }

    void sendValue(const Int::Type& value)

    {

        emit send(value);

    }

signals:

    void send(const String::Type&);

    void send(const Int::Type&);

};

class Receiver : public QObject

{

    Q_OBJECT

public:

    Receiver() : stringCallCount(0), intCallCount(0) {}

    int stringCallCount;

    int intCallCount;

public slots:

    void receive(const String::Type&) { stringCallCount++; }

    void receive(const Int::Type&)    { intCallCount++; }

};

#define MACRO_WITH_POSSIBLE_COMPILER_SPECIFIC_ATTRIBUTES

#define DONT_CONFUSE_MOC(klass) klass

#define DONT_CONFUSE_MOC_EVEN_MORE(klass, dummy, dummy2) klass

Q_DECLARE_METATYPE(MyStruct)

Q_DECLARE_METATYPE(MyStruct*)

namespace myNS {

    struct Points

    {

        Points() : p1(0xBEEF), p2(0xBABE) { }

        int p1, p2;

    };

}

Q_DECLARE_METATYPE(myNS::Points)

class TestClassinfoWithEscapes: public QObject

{

    Q_OBJECT

    Q_CLASSINFO("escaped", "\"bar\"")

    Q_CLASSINFO("\"escaped\"", "foo")

public slots:

    void slotWithAReallyLongName(int)

    { }

};

struct ForwardDeclaredStruct;

struct StructQObject : public QObject

{

    Q_OBJECT

public:

    void foo(struct ForwardDeclaredStruct *);

};

void StructQObject::foo(struct ForwardDeclaredStruct *)

{

    struct Inner {

        bool field;

    };

    struct Inner unusedVariable;

}

class TestClass : public MyNamespace::TestSuperClass, public DONT_CONFUSE_MOC(MyStruct),

                  public DONT_CONFUSE_MOC_EVEN_MORE(MyStruct2, dummy, ignored)

{

    Q_OBJECT

    Q_CLASSINFO("help", QT_TR_NOOP("Opening this will let you configure something"))

    Q_PROPERTY(short int shortIntProperty READ shortIntProperty)

    Q_PROPERTY(unsigned short int unsignedShortIntProperty READ unsignedShortIntProperty)

    Q_PROPERTY(signed short int signedShortIntProperty READ signedShortIntProperty)

    Q_PROPERTY(long int longIntProperty READ longIntProperty)

    Q_PROPERTY(unsigned long int unsignedLongIntProperty READ unsignedLongIntProperty)

    Q_PROPERTY(signed long int signedLongIntProperty READ signedLongIntProperty)

    Q_PROPERTY(long double longDoubleProperty READ longDoubleProperty)

    Q_PROPERTY(myNS::Points points READ points WRITE setPoints)

    Q_CLASSINFO("Multi"

                "line",

                ""

                "This is a "

                "multiline Q_CLASSINFO"

                "")

    // a really really long string that we have to cut into pieces in the generated stringdata

    // table, otherwise msvc craps out

    Q_CLASSINFO("D-Bus Introspection", ""

"  <interface name=\"org.kde.KCookieServer\" >\n"

"    <method name=\"findCookies\" >\n"

"      <arg direction=\"in\" type=\"s\" name=\"url\" />\n"

"      <arg direction=\"in\" type=\"x\" name=\"windowId\" />\n"

"      <arg direction=\"out\" type=\"s\" name=\"cookies\" />\n"

"    </method>\n"

"    <method name=\"findDomains\" >\n"

"      <arg direction=\"out\" type=\"as\" name=\"domains\" />\n"

"    </method>\n"

"    <method name=\"findCookies\" >\n"

"      <arg direction=\"in\" type=\"ai\" name=\"fields\" />\n"

"      <arg direction=\"in\" type=\"s\" name=\"domain\" />\n"

"      <arg direction=\"in\" type=\"s\" name=\"fqdn\" />\n"

"      <arg direction=\"in\" type=\"s\" name=\"path\" />\n"

"      <arg direction=\"in\" type=\"s\" name=\"name\" />\n"

"      <arg direction=\"out\" type=\"as\" name=\"cookies\" />\n"

"      <annotation value=\"QList&lt;int>\" name=\"com.trolltech.QtDBus.QtTypeName.In0\" />\n"

"    </method>\n"

"    <method name=\"findDOMCookies\" >\n"

"      <arg direction=\"in\" type=\"s\" name=\"url\" />\n"

"      <arg direction=\"in\" type=\"x\" name=\"windowId\" />\n"

"      <arg direction=\"out\" type=\"s\" name=\"cookies\" />\n"

"    </method>\n"

"    <method name=\"addCookies\" >\n"

"      <arg direction=\"in\" type=\"s\" name=\"url\" />\n"

"      <arg direction=\"in\" type=\"ay\" name=\"cookieHeader\" />\n"

"      <arg direction=\"in\" type=\"x\" name=\"windowId\"  />\n"

"    </method>\n"

"    <method name=\"deleteCookie\" >\n"

"      <arg direction=\"in\" type=\"s\" name=\"domain\" />\n"

"      <arg direction=\"in\" type=\"s\" name=\"fqdn\" />\n"

"      <arg direction=\"in\" type=\"s\" name=\"path\" />\n"

"      <arg direction=\"in\" type=\"s\" name=\"name\" />\n"

"    </method>\n"

"    <method name=\"deleteCookiesFromDomain\" >\n"

"      <arg direction=\"in\" type=\"s\" name=\"domain\" />\n"

"    </method>\n"

"    <method name=\"deleteSessionCookies\" >\n"

"      <arg direction=\"in\" type=\"x\" name=\"windowId\" />\n"

"    </method>\n"

"    <method name=\"deleteSessionCookiesFor\" >\n"

"      <arg direction=\"in\" type=\"s\" name=\"fqdn\" />\n"

"      <arg direction=\"in\" type=\"x\" name=\"windowId\" />\n"

"    </method>\n"

"    <method name=\"deleteAllCookies\" />\n"

"    <method name=\"addDOMCookies\" >\n"

"      <arg direction=\"in\" type=\"s\" name=\"url\" />\n"

"      <arg direction=\"in\" type=\"ay\" name=\"cookieHeader\" />\n"

"      <arg direction=\"in\" type=\"x\" name=\"windowId\" />\n"

"    </method>\n"

"    <method name=\"setDomainAdvice\" >\n"

"      <arg direction=\"in\" type=\"s\" name=\"url\" />\n"

"      <arg direction=\"in\" type=\"s\" name=\"advice\" />\n"

"    </method>\n"

"    <method name=\"getDomainAdvice\" >\n"

"      <arg direction=\"in\" type=\"s\" name=\"url\" />\n"

"      <arg direction=\"out\" type=\"s\" name=\"advice\" />\n"

"    </method>\n"

"    <method name=\"reloadPolicy\" />\n"

"    <method name=\"shutdown\" />\n"

"  </interface>\n"

        "")

public:

    inline TestClass() {}

private slots:

    inline void dummy1() MACRO_WITH_POSSIBLE_COMPILER_SPECIFIC_ATTRIBUTES {}

    inline void dummy2() MACRO_WITH_POSSIBLE_COMPILER_SPECIFIC_ATTRIBUTES const {}

    inline void dummy3() const MACRO_WITH_POSSIBLE_COMPILER_SPECIFIC_ATTRIBUTES {}

#ifndef NOLONGLONG

    void slotWithULongLong(unsigned long long) {}

    void slotWithULongLongP(unsigned long long*) {}

    void slotWithULong(unsigned long) {}

    void slotWithLongLong(long long) {}

    void slotWithLong(long) {}

#endif

    void slotWithColonColonType(::Int::Type) {}

    TestClass &slotWithReferenceReturnType() { return *this; }

#if (0 && 1) || 1

    void expressionEvaluationShortcut1() {}

#endif

#if (1 || 0) && 0

#else

    void expressionEvaluationShortcut2() {}

#endif

public slots:

    void slotWithArray(const double[3]) {}

    void slotWithNamedArray(const double namedArray[3]) {}

    void slotWithMultiArray(const double[3][4]) {}

    short int shortIntProperty() { return 0; }

    unsigned short int unsignedShortIntProperty() { return 0; }

    signed short int signedShortIntProperty() { return 0; }

    long int longIntProperty() { return 0; }

    unsigned long int unsignedLongIntProperty() { return 0; }

    signed long int signedLongIntProperty() { return 0; }

    long double longDoubleProperty() { return 0.0; }

    myNS::Points points() { return m_points; }

    void setPoints(myNS::Points points) { m_points = points; }

signals:

    void signalWithArray(const double[3]);

    void signalWithNamedArray(const double namedArray[3]);

private slots:

    // for tst_Moc::preprocessorConditionals

#if 0

    void invalidSlot() {}

#else

    void slotInElse() {}

#endif

#if 1

    void slotInIf() {}

#else

    void invalidSlot() {}

#endif

#if 0

    void invalidSlot() {}

#elif 0

#else

    void slotInLastElse() {}

#endif

#if 0

    void invalidSlot() {}

#elif 1

    void slotInElif() {}

#else

    void invalidSlot() {}

#endif

    friend class Receiver; // task #85783

signals:

    friend class Sender; // task #85783

public slots:

    void const slotWithSillyConst() {}

public:

    Q_INVOKABLE void const slotWithSillyConst2() {}

    // that one however should be fine

public slots:

    void slotWithVoidStar(void *) {}

private:

     myNS::Points m_points;

private slots:

     inline virtual void blub1() {}

     virtual inline void blub2() {}

};

class PropertyTestClass : public QObject

{

    Q_OBJECT

public:

    enum TestEnum { One, Two, Three };

    Q_ENUMS(TestEnum)

};

class PropertyUseClass : public QObject

{

    Q_OBJECT

    Q_PROPERTY(PropertyTestClass::TestEnum foo READ foo)

public:

    inline PropertyTestClass::TestEnum foo() const { return PropertyTestClass::One; }

};

#if defined(Q_MOC_RUN)

// Task #119503

#define _TASK_119503

#if !_TASK_119503

#endif

#endif

static QString srcify(const char *path)

{

#ifndef Q_OS_IRIX

    return QString(SRCDIR) + QLatin1Char('/') + QLatin1String(path);

#else

    return QString(QLatin1String(path));

#endif

}

class CtorTestClass : public QObject

{

    Q_OBJECT

public:

    Q_INVOKABLE CtorTestClass(QObject *parent = 0);

    CtorTestClass(int foo);

    inline Q_INVOKABLE CtorTestClass(const QString &str)

        { m_str = str; }

    QString m_str;

protected:

    CtorTestClass(int foo, int bar, int baz);

private:

    CtorTestClass(float, float) {}

};

CtorTestClass::CtorTestClass(QObject *parent)

    : QObject(parent) {}

CtorTestClass::CtorTestClass(int, int, int) {}

class tst_Moc : public QObject

{

    Q_OBJECT

    Q_PROPERTY(bool user1 READ user1 USER true )

    Q_PROPERTY(bool user2 READ user2 USER false)

    Q_PROPERTY(bool user3 READ user3 USER userFunction())

public:

    inline tst_Moc() {}

private slots:

    void initTestCase();

    void slotWithException() throw(MyStruct);

    void dontStripNamespaces();

    void oldStyleCasts();

    void warnOnExtraSignalSlotQualifiaction();

    void uLongLong();

    void inputFileNameWithDotsButNoExtension();

    void userProperties();

    void supportConstSignals();

    void task87883();

    void multilineComments();

    void classinfoWithEscapes();

    void trNoopInClassInfo();

    void ppExpressionEvaluation();

    void arrayArguments();

    void preprocessorConditionals();

    void blackslashNewlines();

    void slotWithSillyConst();

    void testExtraData();

    void namespaceTypeProperty();

    void slotsWithVoidTemplate();

    void structQObject();

    void namespacedFlags();

    void warnOnMultipleInheritance();

    void forgottenQInterface();

    void os9Newline();

    void winNewline();

    void escapesInStringLiterals();

    void frameworkSearchPath();

    void cstyleEnums();

    void defineMacroViaCmdline();

    void invokable();

    void singleFunctionKeywordSignalAndSlot();

    void templateGtGt();

    void qprivateslots();

    void inlineSlotsWithThrowDeclaration();

    void warnOnPropertyWithoutREAD();

    void constructors();

    void typenameWithUnsigned();

    void warnOnVirtualSignal();

    void QTBUG5590_dummyProperty();

signals:

    void sigWithUnsignedArg(unsigned foo);

    void sigWithSignedArg(signed foo);

    void sigWithConstSignedArg(const signed foo);

    void sigWithVolatileConstSignedArg(volatile const signed foo);

    void sigWithCustomType(const MyStruct);

    void constSignal1() const;

    void constSignal2(int arg) const;

private:

    bool user1() { return true; };

    bool user2() { return false; };

    bool user3() { return false; };

    bool userFunction(){ return false; };

private:

    QString qtIncludePath;

};

void tst_Moc::initTestCase()

{

#if defined(Q_OS_UNIX) && !defined(QT_NO_PROCESS)

    QProcess proc;

    proc.start("qmake", QStringList() << "-query" << "QT_INSTALL_HEADERS");

    QVERIFY(proc.waitForFinished());

    QCOMPARE(proc.exitCode(), 0);

    QByteArray output = proc.readAllStandardOutput();

    QVERIFY(!output.isEmpty());

    QCOMPARE(proc.readAllStandardError(), QByteArray());

    qtIncludePath = QString::fromLocal8Bit(output).trimmed();

    QFileInfo fi(qtIncludePath);

    QVERIFY(fi.exists());

    QVERIFY(fi.isDir());

#endif

}