PythonQtTests.h
515 lines
| 14.9 KiB
| text/x-c
|
CLexer
/ tests / PythonQtTests.h
ezust
|
r0 | #ifndef _PYTHONQTTESTS_H | ||
#define _PYTHONQTTESTS_H | ||||
/* | ||||
* | ||||
florianlink
|
r133 | * Copyright (C) 2010 MeVis Medical Solutions AG All Rights Reserved. | ||
ezust
|
r0 | * | ||
* This library is free software; you can redistribute it and/or | ||||
* modify it under the terms of the GNU Lesser General Public | ||||
* License as published by the Free Software Foundation; either | ||||
* version 2.1 of the License, or (at your option) any later version. | ||||
* | ||||
* This library is distributed in the hope that it will be useful, | ||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of | ||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||||
* Lesser General Public License for more details. | ||||
* | ||||
* Further, this software is distributed without any warranty that it is | ||||
* free of the rightful claim of any third person regarding infringement | ||||
* or the like. Any license provided herein, whether implied or | ||||
* otherwise, applies only to this software file. Patent licenses, if | ||||
* any, provided herein do not apply to combinations of this program with | ||||
* other software, or any other product whatsoever. | ||||
* | ||||
* You should have received a copy of the GNU Lesser General Public | ||||
* License along with this library; if not, write to the Free Software | ||||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||||
* | ||||
florianlink
|
r133 | * Contact information: MeVis Medical Solutions AG, Universitaetsallee 29, | ||
ezust
|
r0 | * 28359 Bremen, Germany or: | ||
* | ||||
* http://www.mevis.de | ||||
* | ||||
*/ | ||||
//---------------------------------------------------------------------------------- | ||||
/*! | ||||
// \file PythonQtTests.h | ||||
// \author Florian Link | ||||
// \author Last changed by $Author: florian $ | ||||
// \date 2006-05 | ||||
*/ | ||||
//---------------------------------------------------------------------------------- | ||||
#include "PythonQt.h" | ||||
#include <QtTest/QtTest> | ||||
#include <QVariant> | ||||
#include "PythonQtImportFileInterface.h" | ||||
#include "PythonQtCppWrapperFactory.h" | ||||
florianlink
|
r65 | #include <QPen> | ||
#include <QColor> | ||||
#include <QBrush> | ||||
#include <QCursor> | ||||
ezust
|
r0 | class PythonQtTestSlotCallingHelper; | ||
class PythonQtTestApiHelper; | ||||
class QWidget; | ||||
//! test the PythonQt api | ||||
class PythonQtTestApi : public QObject | ||||
{ | ||||
Q_OBJECT | ||||
private slots: | ||||
void initTestCase(); | ||||
void testCall(); | ||||
void testVariables(); | ||||
void testRedirect(); | ||||
void testImporter(); | ||||
florianlink
|
r37 | void testQColorDecorators(); | ||
void testQtNamespace(); | ||||
florianlink
|
r65 | void testConnects(); | ||
ezust
|
r0 | |||
florianlink
|
r86 | void testProperties(); | ||
void testDynamicProperties(); | ||||
ezust
|
r0 | private: | ||
PythonQtTestApiHelper* _helper; | ||||
florianlink
|
r37 | PythonQtObjectPtr _main; | ||
ezust
|
r0 | |||
}; | ||||
florianlink
|
r37 | class ClassA { | ||
public: | ||||
ClassA() { x = 1; } | ||||
int x; | ||||
}; | ||||
class ClassB { | ||||
public: | ||||
ClassB() { y = 2; } | ||||
int y; | ||||
virtual int type() { return 2; } | ||||
}; | ||||
class ClassC : public ClassA, public ClassB { | ||||
public: | ||||
ClassC() { z = 3; } | ||||
int z; | ||||
virtual int type() { return 3; } | ||||
}; | ||||
class ClassD : public QObject, public ClassA, public ClassB { | ||||
Q_OBJECT | ||||
public: | ||||
ClassD() { d = 4; } | ||||
public slots: | ||||
int getD() { return d; } | ||||
private: | ||||
int d; | ||||
virtual int type() { return 4; } | ||||
}; | ||||
class ClassAWrapper : public QObject { | ||||
Q_OBJECT | ||||
public slots: | ||||
ClassA* new_ClassA() { return new ClassA; } | ||||
int getX(ClassA* o) { return o->x; } | ||||
}; | ||||
class ClassBWrapper : public QObject { | ||||
Q_OBJECT | ||||
public slots: | ||||
ClassB* new_ClassB() { return new ClassB; } | ||||
int getY(ClassB* o) { return o->y; } | ||||
}; | ||||
class ClassCWrapper : public QObject { | ||||
Q_OBJECT | ||||
public slots: | ||||
ClassC* new_ClassC() { return new ClassC; } | ||||
int getZ(ClassC* o) { return o->z; } | ||||
}; | ||||
class ClassDWrapper : public QObject { | ||||
Q_OBJECT | ||||
public slots: | ||||
ClassD* new_ClassD() { return new ClassD; } | ||||
}; | ||||
ezust
|
r0 | //! test the PythonQt api (helper) | ||
class PythonQtTestApiHelper : public QObject , public PythonQtImportFileInterface | ||||
{ | ||||
Q_OBJECT | ||||
public: | ||||
PythonQtTestApiHelper() { | ||||
}; | ||||
bool call(const QString& function, const QVariantList& args, const QVariant& expectedResult); | ||||
virtual QByteArray readFileAsBytes(const QString& filename); | ||||
virtual QByteArray readSourceFile(const QString& filename, bool& ok); | ||||
virtual bool exists(const QString& filename); | ||||
virtual QDateTime lastModifiedDate(const QString& filename); | ||||
public slots: | ||||
//! call to set that the test has passed (from Python!) | ||||
void setPassed() { _passed = true; } | ||||
void stdOut(const QString&); | ||||
void stdErr(const QString&); | ||||
private: | ||||
bool _passed; | ||||
}; | ||||
florianlink
|
r37 | |||
ezust
|
r0 | // test implementation of the wrapper factory | ||
class PythonQtTestCppFactory : public PythonQtCppWrapperFactory | ||||
{ | ||||
public: | ||||
virtual QObject* create(const QByteArray& name, void *ptr); | ||||
}; | ||||
//! an cpp object to be wrapped | ||||
class PQCppObject { | ||||
public: | ||||
PQCppObject(int h) { _height = h; } | ||||
int getHeight() { return _height; } | ||||
void setHeight(int h) { _height = h; } | ||||
private: | ||||
int _height; | ||||
}; | ||||
//! an qobject that wraps the existing cpp object | ||||
class PQCppObjectWrapper : public QObject { | ||||
Q_OBJECT | ||||
public: | ||||
PQCppObjectWrapper(void* ptr) { | ||||
_ptr = (PQCppObject*)ptr; | ||||
} | ||||
public slots: | ||||
int getHeight() { return _ptr->getHeight(); } | ||||
void setHeight(int h) { _ptr->setHeight(h); } | ||||
private: | ||||
PQCppObject* _ptr; | ||||
}; | ||||
class PQCppObjectDecorator : public QObject { | ||||
Q_OBJECT | ||||
public slots: | ||||
int getH(PQCppObject* obj) { return obj->getHeight(); } | ||||
}; | ||||
//! an cpp object to be wrapped by decorators only | ||||
class PQCppObjectNoWrap { | ||||
public: | ||||
florianlink
|
r44 | PQCppObjectNoWrap() { _height = 0; } | ||
ezust
|
r0 | PQCppObjectNoWrap(int h) { _height = h; } | ||
int getHeight() { return _height; } | ||||
void setHeight(int h) { _height = h; } | ||||
private: | ||||
int _height; | ||||
}; | ||||
class PQCppObjectNoWrapDecorator : public QObject { | ||||
Q_OBJECT | ||||
florianlink
|
r50 | |||
ezust
|
r0 | public slots: | ||
florianlink
|
r42 | PQCppObjectNoWrap* new_PQCppObjectNoWrap() { | ||
return new PQCppObjectNoWrap(0); | ||||
} | ||||
PQCppObjectNoWrap* new_PQCppObjectNoWrap(const PQCppObjectNoWrap& other) { | ||||
return new PQCppObjectNoWrap(1); | ||||
} | ||||
PQCppObjectNoWrap* new_PQCppObjectNoWrap(double value) { | ||||
return new PQCppObjectNoWrap(2); | ||||
} | ||||
ezust
|
r0 | int getH(PQCppObjectNoWrap* obj) { return obj->getHeight(); } | ||
}; | ||||
florianlink
|
r50 | |||
//! an cpp object that is to be wrapped by decorators only | ||||
class PQCppObject2 { | ||||
public: | ||||
enum TestEnumFlag { | ||||
TestEnumValue1 = 0, | ||||
TestEnumValue2 = 1 | ||||
}; | ||||
PQCppObject2() {} | ||||
}; | ||||
class PQCppObject2Decorator : public QObject { | ||||
Q_OBJECT | ||||
public: | ||||
Q_ENUMS(TestEnumFlag) | ||||
Q_FLAGS(TestEnum) | ||||
enum TestEnumFlag { | ||||
TestEnumValue1 = 0, | ||||
TestEnumValue2 = 1 | ||||
}; | ||||
Q_DECLARE_FLAGS(TestEnum, TestEnumFlag) | ||||
public slots: | ||||
PQCppObject2* new_PQCppObject2() { | ||||
return new PQCppObject2(); | ||||
} | ||||
florianlink
|
r53 | TestEnumFlag testEnumFlag1(PQCppObject2* obj, TestEnumFlag flag); | ||
florianlink
|
r50 | |||
florianlink
|
r53 | PQCppObject2::TestEnumFlag testEnumFlag2(PQCppObject2* obj, PQCppObject2::TestEnumFlag flag); | ||
florianlink
|
r50 | // with int overload | ||
florianlink
|
r53 | TestEnumFlag testEnumFlag3(PQCppObject2* obj, int flag); | ||
TestEnumFlag testEnumFlag3(PQCppObject2* obj, TestEnumFlag flag); | ||||
florianlink
|
r50 | }; | ||
florianlink
|
r44 | class PQUnknownValueObject | ||
{ | ||||
public: | ||||
PQUnknownValueObject() {}; | ||||
}; | ||||
class PQUnknownButRegisteredValueObject | ||||
{ | ||||
public: | ||||
PQUnknownButRegisteredValueObject() {}; | ||||
}; | ||||
ezust
|
r0 | |||
//! test the calling of slots | ||||
class PythonQtTestSlotCalling : public QObject | ||||
{ | ||||
Q_OBJECT | ||||
private slots: | ||||
void initTestCase(); | ||||
void init(); | ||||
void testNoArgSlotCall(); | ||||
void testPODSlotCalls(); | ||||
florianlink
|
r37 | void testCPPSlotCalls(); | ||
ezust
|
r0 | void testQVariantSlotCalls(); | ||
void testObjectSlotCalls(); | ||||
void testMultiArgsSlotCall(); | ||||
florianlink
|
r37 | void testPyObjectSlotCall(); | ||
ezust
|
r0 | void testOverloadedCall(); | ||
void testCppFactory(); | ||||
florianlink
|
r37 | void testInheritance(); | ||
florianlink
|
r65 | void testAutoConversion(); | ||
ezust
|
r0 | |||
private: | ||||
PythonQtTestSlotCallingHelper* _helper; | ||||
}; | ||||
//! helper class for slot calling test | ||||
class PythonQtTestSlotCallingHelper : public QObject | ||||
{ | ||||
Q_OBJECT | ||||
public: | ||||
PythonQtTestSlotCallingHelper(PythonQtTestSlotCalling* test) { | ||||
_test = test; | ||||
}; | ||||
bool runScript(const char* script, int expectedOverload = -1); | ||||
public slots: | ||||
//! call to set that the test has passed (from Python!) | ||||
void setPassed() { _passed = true; } | ||||
//! no arguments, no return value: | ||||
void testNoArg() { _called = true; } | ||||
//! overload test! | ||||
void overload(bool a) { _calledOverload = 0; _called = true; } | ||||
void overload(float a) { _calledOverload = 1; _called = true;} | ||||
void overload(int a) { _calledOverload = 2; _called = true;} | ||||
void overload(const QString& str) { _calledOverload = 3; _called = true;} | ||||
void overload(const QStringList& str) { _calledOverload = 4; _called = true;} | ||||
void overload(QObject* str) { _calledOverload = 5; _called = true;} | ||||
void overload(float a, int b) { _calledOverload = 6; _called = true;} | ||||
//! POD values: | ||||
int getInt(int a) { _called = true; return a; } | ||||
unsigned int getUInt(unsigned int a) { _called = true; return a; } | ||||
bool getBool(bool a) { _called = true; return a; } | ||||
char getChar(char a) { _called = true; return a; } | ||||
unsigned char getUChar(unsigned char a) { _called = true; return a; } | ||||
long getLong(long a) { _called = true; return a; } | ||||
unsigned long getULong(unsigned long a) { _called = true; return a; } | ||||
short getShort(short a) { _called = true; return a; } | ||||
unsigned short getUShort(unsigned short a) { _called = true; return a; } | ||||
QChar getQChar(QChar a) { _called = true; return a; } | ||||
qint64 getLongLong(qint64 a) { _called = true; return a; } | ||||
quint64 getULongLong(quint64 a) { _called = true; return a; } | ||||
double getDouble(double d) { _called = true; return d; } | ||||
float getFloat(float d) { _called = true; return d; } | ||||
//! important qt types: | ||||
QString getQString(const QString& s) { _called = true; return s; } | ||||
QStringList getQStringList(const QStringList& l) { _called = true; return l; } | ||||
QVariant getQVariant(const QVariant& var) { _called = true; return var; } | ||||
florianlink
|
r37 | // QColor as representative for C++ value classes | ||
QColor getQColor1(const QColor& var) { _called = true; return var; } | ||||
QColor getQColor2(QColor& var) { _called = true; return var; } | ||||
QColor getQColor3(QColor* col) { _called = true; return *col; } | ||||
Orochimarufan
|
r205 | QColor getQColor4(const QVariant& color) { _called = true; return color.value<QColor>(); } | ||
florianlink
|
r37 | QColor* getQColor5() { _called = true; static QColor c(1,2,3); return &c; } | ||
PyObject* getPyObject(PyObject* obj) { _called = true; return obj; } | ||||
Orochimarufan
|
r205 | PyObject* getPyObjectFromVariant(const QVariant& val) { _called = true; return PythonQtObjectPtr(val); } | ||
QVariant getPyObjectFromVariant2(const QVariant& val) { _called = true; return val; } | ||||
florianlink
|
r37 | // this does not yet work but is not required to work: | ||
//PyObject* getPyObjectFromPtr(const PythonQtObjectPtr& val) { _called = true; return val; }; | ||||
ezust
|
r0 | //! testing pointer passing | ||
PythonQtTestSlotCallingHelper* getTestObject(PythonQtTestSlotCallingHelper* obj) { _called = true; return obj; } | ||||
//! testing inheritance checking | ||||
QObject* getQObject(QObject* obj) { _called = true; return obj; } | ||||
QWidget* getQWidget(QWidget* obj) { _called = true; return obj; } | ||||
//! testing if an object that was not wrapped is wrapped earlier is wrapped correctly | ||||
QObject* getNewObject() { _called = true; return new PythonQtTestSlotCallingHelper(NULL); } | ||||
QVariantList getMultiArgs(int a, double b, const QString& str) { _called = true; return (QVariantList() << a << b << str); } | ||||
//! cpp wrapper factory test | ||||
PQCppObject* createPQCppObject(int h) { _called = true; return new PQCppObject(h); } | ||||
//! cpp wrapper factory test | ||||
PQCppObject* getPQCppObject(PQCppObject* p) { _called = true; return p; } | ||||
//! cpp wrapper factory test | ||||
PQCppObjectNoWrap* createPQCppObjectNoWrap(int h) { _called = true; return new PQCppObjectNoWrap(h); } | ||||
//! cpp wrapper factory test | ||||
PQCppObjectNoWrap* getPQCppObjectNoWrap(PQCppObjectNoWrap* p) { _called = true; return p; } | ||||
florianlink
|
r44 | //! get a return by value PQCppObjectNoWrap | ||
PQCppObjectNoWrap getPQCppObjectNoWrapAsValue() { _called = true; return PQCppObjectNoWrap(47); } | ||||
PQUnknownButRegisteredValueObject getUnknownButRegisteredValueObjectAsValue() { _called = true; return PQUnknownButRegisteredValueObject(); } | ||||
PQUnknownValueObject getUnknownValueObjectAsValue() { _called = true; return PQUnknownValueObject(); } | ||||
PQUnknownButRegisteredValueObject* getUnknownButRegisteredValueObjectAsPtr() { _called = true; return new PQUnknownButRegisteredValueObject(); } | ||||
PQUnknownValueObject* getUnknownValueObjectAsPtr() { _called = true; return new PQUnknownValueObject(); } | ||||
florianlink
|
r37 | ClassA* getClassAPtr(ClassA* o) { _called = true; return o; } | ||
ClassB* getClassBPtr(ClassB* o) { _called = true; return o; } | ||||
ClassC* getClassCPtr(ClassC* o) { _called = true; return o; } | ||||
ClassD* getClassDPtr(ClassD* o) { _called = true; return o; } | ||||
ClassA* createClassA() { _called = true; return new ClassA; } | ||||
ClassB* createClassB() { _called = true; return new ClassB; } | ||||
ClassC* createClassC() { _called = true; return new ClassC; } | ||||
ClassD* createClassD() { _called = true; return new ClassD; } | ||||
ClassA* createClassCAsA() { _called = true; return new ClassC; } | ||||
ClassB* createClassCAsB() { _called = true; return new ClassC; } | ||||
ClassA* createClassDAsA() { _called = true; return new ClassD; } | ||||
ClassB* createClassDAsB() { _called = true; return new ClassD; } | ||||
florianlink
|
r65 | QColor setAutoConvertColor(const QColor& color) { _called = true; return color; }; | ||
QBrush setAutoConvertBrush(const QBrush& brush) { _called = true; return brush; }; | ||||
QPen setAutoConvertPen(const QPen& pen) { _called = true; return pen; }; | ||||
QCursor setAutoConvertCursor(const QCursor& cursor) { _called = true; return cursor; }; | ||||
ezust
|
r0 | private: | ||
bool _passed; | ||||
bool _called; | ||||
int _calledOverload; | ||||
PythonQtTestSlotCalling* _test; | ||||
}; | ||||
class PythonQtTestSignalHandlerHelper; | ||||
//! test the connection of signals to python | ||||
class PythonQtTestSignalHandler : public QObject | ||||
{ | ||||
Q_OBJECT | ||||
private slots: | ||||
void initTestCase(); | ||||
void testSignalHandler(); | ||||
void testRecursiveSignalHandler(); | ||||
private: | ||||
PythonQtTestSignalHandlerHelper* _helper; | ||||
}; | ||||
//! helper class for signal testing | ||||
class PythonQtTestSignalHandlerHelper : public QObject | ||||
{ | ||||
Q_OBJECT | ||||
public: | ||||
PythonQtTestSignalHandlerHelper(PythonQtTestSignalHandler* test) { | ||||
_test = test; | ||||
}; | ||||
public slots: | ||||
void setPassed() { _passed = true; } | ||||
bool emitIntSignal(int a) { _passed = false; emit intSignal(a); return _passed; }; | ||||
bool emitFloatSignal(float a) { _passed = false; emit floatSignal(a); return _passed; }; | ||||
florianlink
|
r50 | bool emitEnumSignal(PQCppObject2::TestEnumFlag flag) { _passed = false; emit enumSignal(flag); return _passed; }; | ||
ezust
|
r0 | |||
bool emitVariantSignal(const QVariant& v) { _passed = false; emit variantSignal(v); return _passed; }; | ||||
QVariant expectedVariant() { return _v; } | ||||
void setExpectedVariant(const QVariant& v) { _v = v; } | ||||
bool emitComplexSignal(int a, float b, const QStringList& l, QObject* obj) { _passed = false; emit complexSignal(a,b,l,obj); return _passed; }; | ||||
bool emitSignal1(int a) { _passed = false; emit signal1(a); return _passed; }; | ||||
bool emitSignal2(const QString& s) { _passed = false; emit signal2(s); return _passed; }; | ||||
bool emitSignal3(float a) { _passed = false; emit signal3(a); return _passed; }; | ||||
signals: | ||||
void intSignal(int); | ||||
void floatSignal(float); | ||||
void variantSignal(const QVariant& v); | ||||
void complexSignal(int a, float b, const QStringList& l, QObject* obj); | ||||
florianlink
|
r50 | void enumSignal(PQCppObject2::TestEnumFlag flag); | ||
ezust
|
r0 | |||
void signal1(int); | ||||
void signal2(const QString&); | ||||
void signal3(float); | ||||
private: | ||||
bool _passed; | ||||
QVariant _v; | ||||
PythonQtTestSignalHandler* _test; | ||||
}; | ||||
#endif | ||||