PythonQtTests.h
332 lines
| 9.5 KiB
| text/x-c
|
CLexer
/ tests / PythonQtTests.h
ezust
|
r0 | #ifndef _PYTHONQTTESTS_H | ||
#define _PYTHONQTTESTS_H | ||||
/* | ||||
* | ||||
* Copyright (C) 2006 MeVis Research GmbH All Rights Reserved. | ||||
* | ||||
* 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 | ||||
* | ||||
* Contact information: MeVis Research GmbH, Universitaetsallee 29, | ||||
* 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" | ||||
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(); | ||||
private: | ||||
PythonQtTestApiHelper* _helper; | ||||
}; | ||||
//! 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; | ||||
}; | ||||
// 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: | ||||
PQCppObjectNoWrap(int h) { _height = h; } | ||||
int getHeight() { return _height; } | ||||
void setHeight(int h) { _height = h; } | ||||
private: | ||||
int _height; | ||||
}; | ||||
class PQCppObjectNoWrapDecorator : public QObject { | ||||
Q_OBJECT | ||||
public slots: | ||||
int getH(PQCppObjectNoWrap* obj) { return obj->getHeight(); } | ||||
}; | ||||
//! test the calling of slots | ||||
class PythonQtTestSlotCalling : public QObject | ||||
{ | ||||
Q_OBJECT | ||||
private slots: | ||||
void initTestCase(); | ||||
void init(); | ||||
void testNoArgSlotCall(); | ||||
void testPODSlotCalls(); | ||||
void testQVariantSlotCalls(); | ||||
void testObjectSlotCalls(); | ||||
void testMultiArgsSlotCall(); | ||||
void testOverloadedCall(); | ||||
void testCppFactory(); | ||||
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; } | ||||
//! 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); } | ||||
// more exotic, not yet tested | ||||
//void setByteArray(QByteArray array) { qDebug() << array.data(); } | ||||
//void setCharPtr(char* data) { qDebug() << data; } | ||||
//! 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; } | ||||
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; }; | ||||
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); | ||||
void signal1(int); | ||||
void signal2(const QString&); | ||||
void signal3(float); | ||||
private: | ||||
bool _passed; | ||||
QVariant _v; | ||||
PythonQtTestSignalHandler* _test; | ||||
}; | ||||
#endif | ||||