##// END OF EJS Templates
GIT_REPOSITORIES » LPP » PythonQt
RSS

Clone from https://github.com/Orochimarufan/PythonQt.git

added experimental compacting to avoid generation of hundreds of files that all include the same stuff...
added experimental compacting to avoid generation of hundreds of files that all include the same stuff git-svn-id: svn://svn.code.sf.net/p/pythonqt/code/trunk@128 ea8d5007-eb21-0410-b261-ccb3ea6e24a9
florianlink - - Load All Authors

File last commit:

r86:d9124d642ab2
r92:f97ec94c87a9
Show More
PythonQtTests.h
515 lines | 14.9 KiB | text/x-c | CLexer
/ tests / PythonQtTests.h
History | Annotation | Raw |Copy content |Copy permalink
#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"
#include <QPen>
#include <QColor>
#include <QBrush>
#include <QCursor>
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();
void testQColorDecorators();
void testQtNamespace();
void testConnects();
void testProperties();
void testDynamicProperties();
private:
PythonQtTestApiHelper* _helper;
PythonQtObjectPtr _main;
};
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; }
};
//! 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() { _height = 0; }
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:
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);
}
int getH(PQCppObjectNoWrap* obj) { return obj->getHeight(); }
};
//! 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();
}
TestEnumFlag testEnumFlag1(PQCppObject2* obj, TestEnumFlag flag);
PQCppObject2::TestEnumFlag testEnumFlag2(PQCppObject2* obj, PQCppObject2::TestEnumFlag flag);
// with int overload
TestEnumFlag testEnumFlag3(PQCppObject2* obj, int flag);
TestEnumFlag testEnumFlag3(PQCppObject2* obj, TestEnumFlag flag);
};
class PQUnknownValueObject
{
public:
PQUnknownValueObject() {};
};
class PQUnknownButRegisteredValueObject
{
public:
PQUnknownButRegisteredValueObject() {};
};
//! test the calling of slots
class PythonQtTestSlotCalling : public QObject
{
Q_OBJECT
private slots:
void initTestCase();
void init();
void testNoArgSlotCall();
void testPODSlotCalls();
void testCPPSlotCalls();
void testQVariantSlotCalls();
void testObjectSlotCalls();
void testMultiArgsSlotCall();
void testPyObjectSlotCall();
void testOverloadedCall();
void testCppFactory();
void testInheritance();
void testAutoConversion();
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; }
// 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; }
QColor getQColor4(const QVariant& color) { _called = true; return qVariantValue<QColor>(color); }
QColor* getQColor5() { _called = true; static QColor c(1,2,3); return &c; }
PyObject* getPyObject(PyObject* obj) { _called = true; return obj; }
PyObject* getPyObjectFromVariant(const QVariant& val) { _called = true; return PythonQtObjectPtr(val); };
QVariant getPyObjectFromVariant2(const QVariant& val) { _called = true; return val; };
// this does not yet work but is not required to work:
//PyObject* getPyObjectFromPtr(const PythonQtObjectPtr& val) { _called = true; return val; };
//! 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; }
//! 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(); }
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; }
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; };
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 emitEnumSignal(PQCppObject2::TestEnumFlag flag) { _passed = false; emit enumSignal(flag); 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 enumSignal(PQCppObject2::TestEnumFlag flag);
void signal1(int);
void signal2(const QString&);
void signal3(float);
private:
bool _passed;
QVariant _v;
PythonQtTestSignalHandler* _test;
};
#endif