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

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

added tests for autoconversion...
florianlink -
r65:431844f0d0b5
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,519 +1,535
1 1 /*
2 2 *
3 3 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
4 4 *
5 5 * This library is free software; you can redistribute it and/or
6 6 * modify it under the terms of the GNU Lesser General Public
7 7 * License as published by the Free Software Foundation; either
8 8 * version 2.1 of the License, or (at your option) any later version.
9 9 *
10 10 * This library is distributed in the hope that it will be useful,
11 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 13 * Lesser General Public License for more details.
14 14 *
15 15 * Further, this software is distributed without any warranty that it is
16 16 * free of the rightful claim of any third person regarding infringement
17 17 * or the like. Any license provided herein, whether implied or
18 18 * otherwise, applies only to this software file. Patent licenses, if
19 19 * any, provided herein do not apply to combinations of this program with
20 20 * other software, or any other product whatsoever.
21 21 *
22 22 * You should have received a copy of the GNU Lesser General Public
23 23 * License along with this library; if not, write to the Free Software
24 24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 25 *
26 26 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
27 27 * 28359 Bremen, Germany or:
28 28 *
29 29 * http://www.mevis.de
30 30 *
31 31 */
32 32
33 33 //----------------------------------------------------------------------------------
34 34 /*!
35 35 // \file PythonQtTests.cpp
36 36 // \author Florian Link
37 37 // \author Last changed by $Author: florian $
38 38 // \date 2006-05
39 39 */
40 40 //----------------------------------------------------------------------------------
41 41
42 42 #include "PythonQtTests.h"
43 43
44 44 void PythonQtTestSlotCalling::initTestCase()
45 45 {
46 46 _helper = new PythonQtTestSlotCallingHelper(this);
47 47 PythonQtObjectPtr main = PythonQt::self()->getMainModule();
48 48 main.evalScript("import PythonQt");
49 49 PythonQt::self()->addObject(main, "obj", _helper);
50 50 }
51 51
52 52 void PythonQtTestSlotCalling::init() {
53 53
54 54 }
55 55
56 56 void* polymorphic_ClassB_Handler(const void* ptr, char** className) {
57 57 ClassB* o = (ClassB*)ptr;
58 58 if (o->type()==2) {
59 59 *className = "ClassB";
60 60 return (ClassB*)o;
61 61 }
62 62 if (o->type()==3) {
63 63 *className = "ClassC";
64 64 return (ClassC*)o;
65 65 }
66 66 if (o->type()==4) {
67 67 *className = "ClassD";
68 68 return (ClassD*)o;
69 69 }
70 70 return NULL;
71 71 }
72 72
73 73 void PythonQtTestSlotCalling::testInheritance() {
74 74 PythonQt::self()->registerCPPClass("ClassA",NULL,NULL, PythonQtCreateObject<ClassAWrapper>);
75 75 PythonQt::self()->registerCPPClass("ClassB",NULL,NULL, PythonQtCreateObject<ClassBWrapper>);
76 76 PythonQt::self()->registerCPPClass("ClassC",NULL,NULL, PythonQtCreateObject<ClassCWrapper>);
77 77 PythonQt::self()->addParentClass("ClassC", "ClassA", PythonQtUpcastingOffset<ClassC,ClassA>());
78 78 PythonQt::self()->addParentClass("ClassC", "ClassB", PythonQtUpcastingOffset<ClassC,ClassB>());
79 79 PythonQt::self()->registerClass(&ClassD::staticMetaObject, NULL, PythonQtCreateObject<ClassDWrapper>);
80 80 PythonQt::self()->addParentClass("ClassD", "ClassA", PythonQtUpcastingOffset<ClassD,ClassA>());
81 81 PythonQt::self()->addParentClass("ClassD", "ClassB", PythonQtUpcastingOffset<ClassD,ClassB>());
82 82
83 83 PythonQtObjectPtr classA = PythonQt::self()->getMainModule().getVariable("PythonQt.ClassA");
84 84 PythonQtObjectPtr classB = PythonQt::self()->getMainModule().getVariable("PythonQt.ClassB");
85 85 PythonQtObjectPtr classC = PythonQt::self()->getMainModule().getVariable("PythonQt.ClassC");
86 86 PythonQtObjectPtr classD = PythonQt::self()->getMainModule().getVariable("PythonQt.ClassD");
87 87 QVERIFY(classA);
88 88 QVERIFY(classB);
89 89 QVERIFY(classC);
90 90 QVERIFY(classD);
91 91
92 92 QVERIFY(_helper->runScript("a = PythonQt.ClassA();\nif obj.getClassAPtr(a).getX()==1: obj.setPassed();\n"));
93 93 QEXPECT_FAIL("", "ClassB can not be converted to ClassA", Continue);
94 94 QVERIFY(_helper->runScript("a = PythonQt.ClassB();\nif obj.getClassAPtr(a).getX()==1: obj.setPassed();\n"));
95 95 QVERIFY(_helper->runScript("a = PythonQt.ClassC();\nif obj.getClassAPtr(a).getX()==1: obj.setPassed();\n"));
96 96 QVERIFY(_helper->runScript("a = PythonQt.ClassD();\nif obj.getClassAPtr(a).getX()==1: obj.setPassed();\n"));
97 97
98 98 QEXPECT_FAIL("", "ClassA can not be converted to ClassB", Continue);
99 99 QVERIFY(_helper->runScript("a = PythonQt.ClassA();\nif obj.getClassBPtr(a).getY()==2: obj.setPassed();\n"));
100 100 QVERIFY(_helper->runScript("a = PythonQt.ClassB();\nif obj.getClassBPtr(a).getY()==2: obj.setPassed();\n"));
101 101 QVERIFY(_helper->runScript("a = PythonQt.ClassC();\nif obj.getClassBPtr(a).getY()==2: obj.setPassed();\n"));
102 102 QVERIFY(_helper->runScript("a = PythonQt.ClassD();\nif obj.getClassBPtr(a).getY()==2: obj.setPassed();\n"));
103 103
104 104 QEXPECT_FAIL("", "ClassA can not be converted to ClassC", Continue);
105 105 QVERIFY(_helper->runScript("a = PythonQt.ClassA();\nif obj.getClassCPtr(a).getX()==1: obj.setPassed();\n"));
106 106 QEXPECT_FAIL("", "ClassB can not be converted to ClassC", Continue);
107 107 QVERIFY(_helper->runScript("a = PythonQt.ClassB();\nif obj.getClassCPtr(a).getX()==1: obj.setPassed();\n"));
108 108 QVERIFY(_helper->runScript("a = PythonQt.ClassC();\nif obj.getClassCPtr(a).getX()==1: obj.setPassed();\n"));
109 109 QEXPECT_FAIL("", "ClassD can not be converted to ClassC", Continue);
110 110 QVERIFY(_helper->runScript("a = PythonQt.ClassD();\nif obj.getClassCPtr(a).getX()==1: obj.setPassed();\n"));
111 111
112 112 QVERIFY(_helper->runScript("if type(obj.createClassA())==PythonQt.ClassA: obj.setPassed();\n"));
113 113 QVERIFY(_helper->runScript("if type(obj.createClassB())==PythonQt.ClassB: obj.setPassed();\n"));
114 114 QVERIFY(_helper->runScript("if type(obj.createClassCAsA())==PythonQt.ClassA: obj.setPassed();\n"));
115 115 QVERIFY(_helper->runScript("if type(obj.createClassCAsB())==PythonQt.ClassB: obj.setPassed();\n"));
116 116 QVERIFY(_helper->runScript("if type(obj.createClassD())==PythonQt.ClassD: obj.setPassed();\n"));
117 117 QVERIFY(_helper->runScript("if type(obj.createClassDAsA())==PythonQt.ClassA: obj.setPassed();\n"));
118 118 QVERIFY(_helper->runScript("if type(obj.createClassDAsB())==PythonQt.ClassB: obj.setPassed();\n"));
119 119
120 120 PythonQt::self()->addPolymorphicHandler("ClassB", polymorphic_ClassB_Handler);
121 121
122 122 QVERIFY(_helper->runScript("if type(obj.getClassBPtr(obj.createClassB()))==PythonQt.ClassB: obj.setPassed();\n"));
123 123 QVERIFY(_helper->runScript("if type(obj.createClassCAsB())==PythonQt.ClassC: obj.setPassed();\n"));
124 124 QVERIFY(_helper->runScript("if type(obj.createClassDAsB())==PythonQt.ClassD: obj.setPassed();\n"));
125 125
126 126 }
127 127
128 void PythonQtTestSlotCalling::testAutoConversion() {
129 QVERIFY(_helper->runScript("if obj.setAutoConvertColor(PythonQt.QtCore.Qt.red)==PythonQt.Qt.QColor(PythonQt.QtCore.Qt.red): obj.setPassed();\n"));
130 QVERIFY(_helper->runScript("if obj.setAutoConvertBrush(PythonQt.QtCore.Qt.red)==PythonQt.Qt.QBrush(PythonQt.QtCore.Qt.red): obj.setPassed();\n"));
131 QVERIFY(_helper->runScript("if obj.setAutoConvertPen(PythonQt.QtCore.Qt.red)==PythonQt.Qt.QPen(PythonQt.QtCore.Qt.red): obj.setPassed();\n"));
132 QVERIFY(_helper->runScript("if obj.setAutoConvertBrush(PythonQt.Qt.QColor(PythonQt.QtCore.Qt.red))==PythonQt.Qt.QBrush(PythonQt.QtCore.Qt.red): obj.setPassed();\n"));
133 QVERIFY(_helper->runScript("if obj.setAutoConvertPen(PythonQt.Qt.QColor(PythonQt.QtCore.Qt.red))==PythonQt.Qt.QPen(PythonQt.QtCore.Qt.red): obj.setPassed();\n"));
134 QVERIFY(_helper->runScript("if obj.setAutoConvertCursor(PythonQt.Qt.QCursor(PythonQt.QtCore.Qt.UpArrowCursor)).shape()==PythonQt.Qt.QCursor(PythonQt.QtCore.Qt.UpArrowCursor).shape(): obj.setPassed();\n"));
135 QVERIFY(_helper->runScript("if obj.setAutoConvertCursor(PythonQt.QtCore.Qt.UpArrowCursor).shape()==PythonQt.Qt.QCursor(PythonQt.QtCore.Qt.UpArrowCursor).shape(): obj.setPassed();\n"));
136 }
137
128 138 void PythonQtTestSlotCalling::testNoArgSlotCall()
129 139 {
130 140 QVERIFY(_helper->runScript("obj.testNoArg(); obj.setPassed();\n"));
131 141 }
132 142
133 143 void PythonQtTestSlotCalling::testOverloadedCall()
134 144 {
135 145 QVERIFY(_helper->runScript("obj.overload(False); obj.setPassed();\n", 0));
136 146 QVERIFY(_helper->runScript("obj.overload(True); obj.setPassed();\n", 0));
137 147 QVERIFY(_helper->runScript("obj.overload(12.5); obj.setPassed();\n", 1));
138 148 QVERIFY(_helper->runScript("obj.overload(12); obj.setPassed();\n", 2));
139 149 QVERIFY(_helper->runScript("obj.overload('test'); obj.setPassed();\n", 3));
140 150 QVERIFY(_helper->runScript("obj.overload(u'test'); obj.setPassed();\n", 3));
141 151 QVERIFY(_helper->runScript("obj.overload(('test','test2')); obj.setPassed();\n", 4));
142 152 QVERIFY(_helper->runScript("obj.overload(obj); obj.setPassed();\n", 5));
143 153 QVERIFY(_helper->runScript("obj.overload(12,13); obj.setPassed();\n", 6));
144 154 }
145 155
146 156 void PythonQtTestSlotCalling::testPyObjectSlotCall()
147 157 {
148 158 QVERIFY(_helper->runScript("if obj.getPyObject(PythonQt)==PythonQt: obj.setPassed();\n"));
149 159 QVERIFY(_helper->runScript("if obj.getPyObject('Hello')=='Hello': obj.setPassed();\n"));
150 160 QVERIFY(_helper->runScript("if obj.getPyObjectFromVariant(PythonQt)==PythonQt: obj.setPassed();\n"));
151 161 QVERIFY(_helper->runScript("if obj.getPyObjectFromVariant2(PythonQt)==PythonQt: obj.setPassed();\n"));
152 162 // QVERIFY(_helper->runScript("if obj.getPyObjectFromPtr(PythonQt)==PythonQt: obj.setPassed();\n"));
153 163 }
154 164
155 165 void PythonQtTestSlotCalling::testCPPSlotCalls()
156 166 {
157 167 // test QColor compare operation
158 168 QVERIFY(_helper->runScript("if PythonQt.QtGui.QColor(1,2,3)==PythonQt.QtGui.QColor(1,2,3): obj.setPassed();obj.testNoArg()\n"));
159 169 QVERIFY(_helper->runScript("if PythonQt.QtGui.QColor(1,2,3)!=PythonQt.QtGui.QColor(3,2,1): obj.setPassed();obj.testNoArg()\n"));
160 170
161 171 // test passing/returning QColors
162 172 QVERIFY(_helper->runScript("if obj.getQColor1(PythonQt.QtGui.QColor(1,2,3))==PythonQt.QtGui.QColor(1,2,3): obj.setPassed();\n"));
163 173 QVERIFY(_helper->runScript("if obj.getQColor2(PythonQt.QtGui.QColor(1,2,3))==PythonQt.QtGui.QColor(1,2,3): obj.setPassed();\n"));
164 174 QVERIFY(_helper->runScript("if obj.getQColor3(PythonQt.QtGui.QColor(1,2,3))==PythonQt.QtGui.QColor(1,2,3): obj.setPassed();\n"));
165 175 QVERIFY(_helper->runScript("if obj.getQColor4(PythonQt.QtGui.QColor(1,2,3))==PythonQt.QtGui.QColor(1,2,3): obj.setPassed();\n"));
166 176 QVERIFY(_helper->runScript("if obj.getQColor5()==PythonQt.QtGui.QColor(1,2,3): obj.setPassed();\n"));
167 177 }
168 178
169 179 void PythonQtTestSlotCalling::testPODSlotCalls()
170 180 {
171 181 QVERIFY(_helper->runScript("if obj.getBool(False)==False: obj.setPassed();\n"));
172 182 QVERIFY(_helper->runScript("if obj.getBool(True)==True: obj.setPassed();\n"));
173 183 QVERIFY(_helper->runScript("if obj.getInt(-42)==-42: obj.setPassed();\n"));
174 184 QVERIFY(_helper->runScript("if obj.getUInt(42)==42: obj.setPassed();\n"));
175 185 QVERIFY(_helper->runScript("if obj.getShort(-43)==-43: obj.setPassed();\n"));
176 186 QVERIFY(_helper->runScript("if obj.getUShort(43)==43: obj.setPassed();\n"));
177 187 QVERIFY(_helper->runScript("if obj.getChar(-12)==-12: obj.setPassed();\n"));
178 188 QVERIFY(_helper->runScript("if obj.getUChar(12)==12: obj.setPassed();\n"));
179 189 QVERIFY(_helper->runScript("if obj.getLong(-256*256*256)==-256*256*256: obj.setPassed();\n"));
180 190 QVERIFY(_helper->runScript("if obj.getULong(256*256*256)==256*256*256: obj.setPassed();\n"));
181 191 QVERIFY(_helper->runScript("if obj.getLongLong(-42)==-42: obj.setPassed();\n"));
182 192 QVERIFY(_helper->runScript("if obj.getULongLong(42)==42: obj.setPassed();\n"));
183 193 QVERIFY(_helper->runScript("if obj.getQChar(4096)==4096: obj.setPassed();\n"));
184 194 QVERIFY(_helper->runScript("if obj.getDouble(47.12)==47.12: obj.setPassed();\n"));
185 195 QVERIFY(_helper->runScript("if abs(obj.getFloat(47.11)-47.11)<0.01: obj.setPassed();\n"));
186 196 QVERIFY(_helper->runScript("if obj.getQString('testStr')=='testStr': obj.setPassed();\n"));
187 197 QVERIFY(_helper->runScript("if obj.getQString('')=='': obj.setPassed();\n"));
188 198 QVERIFY(_helper->runScript("if obj.getQStringList(('test','test2'))==('test','test2'): obj.setPassed();\n"));
189 199 }
190 200
191 201 void PythonQtTestSlotCalling::testQVariantSlotCalls()
192 202 {
193 203 QVERIFY(_helper->runScript("if obj.getQVariant(-42)==-42: obj.setPassed();\n"));
194 204 QVERIFY(_helper->runScript("if obj.getQVariant('testStr')=='testStr': obj.setPassed();\n"));
195 205 QVERIFY(_helper->runScript("if obj.getQVariant(('test','test2'))==('test','test2'): obj.setPassed();\n"));
196 206 QVERIFY(_helper->runScript("if obj.getQVariant(('test',12, 47.11))==('test',12, 47.11): obj.setPassed();\n"));
197 207 QVERIFY(_helper->runScript("if obj.getQVariant({'test':'bla','test2':47.11})=={'test':'bla','test2':47.11}: obj.setPassed();\n"));
198 208 QEXPECT_FAIL("", "Testing to pass a map and compare with a different map", Continue);
199 209 QVERIFY(_helper->runScript("if obj.getQVariant({'test':'bla2','test2':47.11})=={'test':'bla','test2':47.11}: obj.setPassed();\n"));
200 210 QVERIFY(_helper->runScript("if obj.getQVariant(obj)==obj: obj.setPassed();\n"));
201 211 }
202 212
203 213 void PythonQtTestSlotCalling::testObjectSlotCalls()
204 214 {
205 215 QVERIFY(_helper->runScript("if obj.getQObject(obj)==obj: obj.setPassed();\n"));
206 216 QVERIFY(_helper->runScript("if obj.getTestObject(obj)==obj: obj.setPassed();\n"));
207 217 QVERIFY(_helper->runScript("if obj.getNewObject().className()=='PythonQtTestSlotCallingHelper': obj.setPassed();\n"));
208 218 QEXPECT_FAIL("", "Testing to pass a QObject when another object was expected", Continue);
209 219 QVERIFY(_helper->runScript("if obj.getQWidget(obj)==obj: obj.setPassed();\n"));
210 220 }
211 221
212 222 void PythonQtTestSlotCalling::testCppFactory()
213 223 {
214 224 PythonQtTestCppFactory* f = new PythonQtTestCppFactory;
215 225 PythonQt::self()->addInstanceDecorators(new PQCppObjectDecorator);
216 226 // do not register, since we want to know if that works as well
217 227 //qRegisterMetaType<PQCppObjectNoWrap>("PQCppObjectNoWrap");
218 228 PythonQt::self()->addDecorators(new PQCppObjectNoWrapDecorator);
219 229
220 230 PythonQt::self()->addWrapperFactory(f);
221 231 QVERIFY(_helper->runScript("if obj.createPQCppObject(12).getHeight()==12: obj.setPassed();\n"));
222 232 QVERIFY(_helper->runScript("if obj.createPQCppObject(12).getH()==12: obj.setPassed();\n"));
223 233 QVERIFY(_helper->runScript("pq1 = obj.createPQCppObject(12);\n"
224 234 "pq2 = obj.createPQCppObject(13);\n"
225 235 "pq3 = obj.getPQCppObject(pq1);\n"
226 236 "pq4 = obj.getPQCppObject(pq2);\n"
227 237 "if pq3.getHeight()==12 and pq4.getHeight()==13: obj.setPassed();\n"
228 238 ));
229 239
230 240 QVERIFY(_helper->runScript("if obj.createPQCppObjectNoWrap(12).getH()==12: obj.setPassed();\n"));
231 241
232 242 QVERIFY(_helper->runScript("if obj.getPQCppObjectNoWrapAsValue().getH()==47: obj.setPassed();\n"));
233 243
234 244 qRegisterMetaType<PQUnknownButRegisteredValueObject>("PQUnknownButRegisteredValueObject");
235 245 QVERIFY(_helper->runScript("a = obj.getUnknownButRegisteredValueObjectAsPtr();print a;\nif a!=None: obj.setPassed();\n"));
236 246 QVERIFY(_helper->runScript("a = obj.getUnknownButRegisteredValueObjectAsValue();print a;\nif a!=None: obj.setPassed();\n"));
237 247 QVERIFY(_helper->runScript("a = obj.getUnknownValueObjectAsPtr();print a;\nif a!=None: obj.setPassed();\n"));
238 248 QEXPECT_FAIL("", "Testing by value return without the object being registered as QMetaType or having registered a default constructor decorator", Continue);
239 249 QVERIFY(_helper->runScript("a = obj.getUnknownValueObjectAsValue();print a;\nif a!=None: obj.setPassed();\n"));
240 250
241 251 // expect to get strict call to double overload
242 252 QVERIFY(_helper->runScript("obj.testNoArg()\nfrom PythonQt import PQCppObjectNoWrap\na = PQCppObjectNoWrap(22.2)\nif a.getH()==2: obj.setPassed();\n"));
243 253 // expect to get un-strict call to double overload
244 254 QVERIFY(_helper->runScript("obj.testNoArg()\nfrom PythonQt import PQCppObjectNoWrap\na = PQCppObjectNoWrap(22)\nif a.getH()==2: obj.setPassed();\n"));
245 255 // expect to get strict call to copy constructor overload
246 256 QVERIFY(_helper->runScript("obj.testNoArg()\nfrom PythonQt import PQCppObjectNoWrap\na = PQCppObjectNoWrap(PQCppObjectNoWrap())\nprint a.getH()\nif a.getH()==1: obj.setPassed();\n"));
247 257
248 258 // test decorated enums
249 259 // already registered by signals test
250 260 //PythonQt::self()->registerCPPClass("PQCppObject2",NULL,NULL, PythonQtCreateObject<PQCppObject2Decorator>);
251 261
252 262 // local enum (decorated)
253 263 QVERIFY(_helper->runScript("obj.testNoArg()\nfrom PythonQt import PQCppObject2\na = PQCppObject2()\nprint a.testEnumFlag1\nif a.testEnumFlag1(PQCppObject2.TestEnumValue2)==PQCppObject2.TestEnumValue2: obj.setPassed();\n"));
254 264 // enum with namespace (decorated)
255 265 QVERIFY(_helper->runScript("obj.testNoArg()\nfrom PythonQt import PQCppObject2\na = PQCppObject2()\nif a.testEnumFlag2(PQCppObject2.TestEnumValue2)==PQCppObject2.TestEnumValue2: obj.setPassed();\n"));
256 266 // with int overload to check overloading
257 267 QVERIFY(_helper->runScript("obj.testNoArg()\nfrom PythonQt import PQCppObject2\na = PQCppObject2()\nif a.testEnumFlag3(PQCppObject2.TestEnumValue2)==PQCppObject2.TestEnumValue2: obj.setPassed();\n"));
258 268
259 269 }
260 270
261 271 PQCppObject2Decorator::TestEnumFlag PQCppObject2Decorator::testEnumFlag1(PQCppObject2* obj, PQCppObject2Decorator::TestEnumFlag flag) {
262 272 return flag;
263 273 }
264 274
265 275 PQCppObject2::TestEnumFlag PQCppObject2Decorator::testEnumFlag2(PQCppObject2* obj, PQCppObject2::TestEnumFlag flag) {
266 276 return flag;
267 277 }
268 278
269 279 // with int overload
270 280 PQCppObject2Decorator::TestEnumFlag PQCppObject2Decorator::testEnumFlag3(PQCppObject2* obj, int flag) {
271 281 return (TestEnumFlag)-1;
272 282 }
273 283 PQCppObject2Decorator::TestEnumFlag PQCppObject2Decorator::testEnumFlag3(PQCppObject2* obj, PQCppObject2Decorator::TestEnumFlag flag) {
274 284 return flag;
275 285 }
276 286
277 287 void PythonQtTestSlotCalling::testMultiArgsSlotCall()
278 288 {
279 289 QVERIFY(_helper->runScript("if obj.getMultiArgs(12,47.11,'test')==(12,47.11,'test'): obj.setPassed();\n"));
280 290 }
281 291
282 292 bool PythonQtTestSlotCallingHelper::runScript(const char* script, int expectedOverload)
283 293 {
284 294 _called = false;
285 295 _passed = false;
286 296 _calledOverload = -1;
287 297 PyRun_SimpleString(script);
288 298 return _called && _passed && _calledOverload==expectedOverload;
289 299 }
290 300
291 301
292 302 void PythonQtTestSignalHandler::initTestCase()
293 303 {
294 304 _helper = new PythonQtTestSignalHandlerHelper(this);
295 305 PythonQtObjectPtr main = PythonQt::self()->getMainModule();
296 306 PythonQt::self()->addObject(main, "obj", _helper);
297 307 }
298 308
299 309 void PythonQtTestSignalHandler::testSignalHandler()
300 310 {
301 311 PythonQtObjectPtr main = PythonQt::self()->getMainModule();
302 312 PyRun_SimpleString("def testIntSignal(a):\n if a==12: obj.setPassed();\n");
303 313 QVERIFY(PythonQt::self()->addSignalHandler(_helper, SIGNAL(intSignal(int)), main, "testIntSignal"));
304 314 QVERIFY(_helper->emitIntSignal(12));
305 315
306 316 PyRun_SimpleString("def testFloatSignal(a):\n if a==12: obj.setPassed();\n");
307 317 QVERIFY(PythonQt::self()->addSignalHandler(_helper, SIGNAL(floatSignal(float)), main, "testFloatSignal"));
308 318 QVERIFY(_helper->emitFloatSignal(12));
309 319
310 320 // test decorated enums
311 321 PythonQt::self()->registerCPPClass("PQCppObject2",NULL,NULL, PythonQtCreateObject<PQCppObject2Decorator>);
312 322
313 323 PyRun_SimpleString("def testEnumSignal(a):\n if a==1: obj.setPassed();\n");
314 324 QVERIFY(PythonQt::self()->addSignalHandler(_helper, SIGNAL(enumSignal(PQCppObject2::TestEnumFlag)), main, "testEnumSignal"));
315 325 QVERIFY(_helper->emitEnumSignal(PQCppObject2::TestEnumValue2));
316 326
317 327 PyRun_SimpleString("def testVariantSignal(a):\n if a==obj.expectedVariant(): obj.setPassed();\n");
318 328 QVERIFY(PythonQt::self()->addSignalHandler(_helper, SIGNAL(variantSignal(QVariant)), main, "testVariantSignal"));
319 329 _helper->setExpectedVariant(QString("Test"));
320 330 QVERIFY(_helper->emitVariantSignal(QString("Test")));
321 331 _helper->setExpectedVariant(12);
322 332 QVERIFY(_helper->emitVariantSignal(12));
323 333 _helper->setExpectedVariant(QStringList() << "test1" << "test2");
324 334 QVERIFY(_helper->emitVariantSignal(QStringList() << "test1" << "test2"));
325 335 _helper->setExpectedVariant(qVariantFromValue((QObject*)_helper));
326 336 QVERIFY(_helper->emitVariantSignal(qVariantFromValue((QObject*)_helper)));
327 337
328 338 PyRun_SimpleString("def testComplexSignal(a,b,l,o):\n if a==12 and b==13 and l==('test1','test2') and o == obj: obj.setPassed();\n");
329 339 // intentionally not normalized signal:
330 340 QVERIFY(PythonQt::self()->addSignalHandler(_helper, SIGNAL(complexSignal( int, float , const QStringList , QObject*)), main, "testComplexSignal"));
331 341 QVERIFY(_helper->emitComplexSignal(12,13,QStringList() << "test1" << "test2", _helper));
332 342
333 343 // try removing the handler
334 344 QVERIFY(PythonQt::self()->removeSignalHandler(_helper, SIGNAL(complexSignal( int, float , const QStringList , QObject*)), main, "testComplexSignal"));
335 345 // and emit the signal, which should fail because the handler was removed
336 346 QVERIFY(!_helper->emitComplexSignal(12,13,QStringList() << "test1" << "test2", _helper));
337 347
338 348 QVERIFY(PythonQt::self()->removeSignalHandler(_helper, SIGNAL(intSignal(int)), main, "testIntSignal"));
339 349 QVERIFY(PythonQt::self()->removeSignalHandler(_helper, SIGNAL(floatSignal(float)), main, "testFloatSignal"));
340 350 QVERIFY(PythonQt::self()->removeSignalHandler(_helper, SIGNAL(variantSignal(QVariant)), main, "testVariantSignal"));
341 351 QVERIFY(PythonQt::self()->removeSignalHandler(_helper, SIGNAL(enumSignal(PQCppObject2::TestEnumFlag)), main, "testEnumSignal"));
342 352
343 353 }
344 354
345 355 void PythonQtTestSignalHandler::testRecursiveSignalHandler()
346 356 {
347 357 PythonQtObjectPtr main = PythonQt::self()->getMainModule();
348 358 PyRun_SimpleString("def testSignal1(a):\n obj.emitSignal2(a);\n");
349 359 PyRun_SimpleString("def testSignal2(a):\n obj.emitSignal3(float(a));\n");
350 360 PyRun_SimpleString("def testSignal3(a):\n if a==12: obj.setPassed();\n");
351 361 QVERIFY(PythonQt::self()->addSignalHandler(_helper, SIGNAL(signal1(int)), main, "testSignal1"));
352 362 QVERIFY(PythonQt::self()->addSignalHandler(_helper, SIGNAL(signal2(const QString&)), main, "testSignal2"));
353 363 QVERIFY(PythonQt::self()->addSignalHandler(_helper, SIGNAL(signal3(float)), main, "testSignal3"));
354 364 QVERIFY(_helper->emitSignal1(12));
355 365 }
356 366
357 367
358 368 void PythonQtTestApi::initTestCase()
359 369 {
360 370 _helper = new PythonQtTestApiHelper();
361 371 _main = PythonQt::self()->getMainModule();
362 372 _main.evalScript("import PythonQt");
363 373 _main.addObject("obj", _helper);
364 374 }
365 375
366 376 bool PythonQtTestApiHelper::call(const QString& function, const QVariantList& args, const QVariant& expectedResult) {
367 377 _passed = false;
368 378 QVariant r = PythonQt::self()->call(PythonQt::self()->getMainModule(), function, args);
369 379 return _passed && expectedResult==r;
370 380 }
371 381
372 382 void PythonQtTestApi::testCall()
373 383 {
374 384 PythonQtObjectPtr main = PythonQt::self()->getMainModule();
375 385
376 386 QVERIFY(qVariantValue<QObject*>(PythonQt::self()->getVariable(main, "obj"))==_helper);
377 387
378 388 PyRun_SimpleString("def testCallNoArgs():\n obj.setPassed();\n");
379 389 QVERIFY(_helper->call("testCallNoArgs", QVariantList(), QVariant()));
380 390
381 391 PyRun_SimpleString("def testCall1(a):\n if a=='test': obj.setPassed();\n return 'test2';\n");
382 392 QVERIFY(_helper->call("testCall1", QVariantList() << QVariant("test"), QVariant(QString("test2"))));
383 393
384 394 PyRun_SimpleString("def testCall2(a, b):\n if a=='test' and b==obj: obj.setPassed();\n return obj;\n");
385 395 QVariant r = PythonQt::self()->call(PythonQt::self()->getMainModule(), "testCall2", QVariantList() << QVariant("test") << qVariantFromValue((QObject*)_helper));
386 396 QObject* p = qVariantValue<QObject*>(r);
387 397 QVERIFY(p==_helper);
388 398 }
389 399
390 400 void PythonQtTestApi::testVariables()
391 401 {
392 402 PythonQt::self()->addObject(PythonQt::self()->getMainModule(), "someObject", _helper);
393 403 QVariant v = PythonQt::self()->getVariable(PythonQt::self()->getMainModule(), "someObject");
394 404 QObject* p = qVariantValue<QObject*>(v);
395 405 QVERIFY(p==_helper);
396 406 // test for unset variable
397 407 QVariant v2 = PythonQt::self()->getVariable(PythonQt::self()->getMainModule(), "someObject2");
398 408 QVERIFY(v2==QVariant());
399 409
400 410 PythonQt::self()->addVariable(PythonQt::self()->getMainModule(), "someValue", QStringList() << "test1" << "test2");
401 411 QVariant v3 = PythonQt::self()->getVariable(PythonQt::self()->getMainModule(), "someValue");
402 412 QVERIFY(v3 == QVariant(QStringList() << "test1" << "test2"));
403 413
404 414 QStringList l = PythonQt::self()->introspection(PythonQt::self()->getMainModule(), QString::null, PythonQt::Variable);
405 415 QSet<QString> s;
406 416 // check that at least these three variables are set
407 417 s << "obj" << "someObject" << "someValue";
408 418 foreach (QString value, s) {
409 419 QVERIFY(l.indexOf(value)!=-1);
410 420 }
411 421
412 422 // insert a second time!
413 423 PythonQt::self()->addObject(PythonQt::self()->getMainModule(), "someObject", _helper);
414 424 // and remove
415 425 PythonQt::self()->removeVariable(PythonQt::self()->getMainModule(), "someObject");
416 426 // we expect to find no variable
417 427 QVariant v4 = PythonQt::self()->getVariable(PythonQt::self()->getMainModule(), "someObject");
418 428 QVERIFY(v4==QVariant());
419 429 }
420 430
421 431 void PythonQtTestApi::testImporter()
422 432 {
423 433 PythonQt::self()->setImporter(_helper);
424 434 PythonQt::self()->overwriteSysPath(QStringList() << "c:\\test");
425 435 PyRun_SimpleString("import bla\n");
426 436 }
427 437
428 438 void PythonQtTestApi::testQtNamespace()
429 439 {
430 440 QVERIFY(_main.getVariable("PythonQt.QtCore.Qt.red").toInt()==Qt::red);
431 441 QVERIFY(_main.getVariable("PythonQt.QtCore.Qt.FlatCap").toInt()==Qt::FlatCap);
432 442 QVERIFY(PythonQtObjectPtr(_main.getVariable("PythonQt.QtCore.Qt.escape")));
433 443 // check for an enum type wrapper
434 444 QVERIFY(PythonQtObjectPtr(_main.getVariable("PythonQt.QtCore.Qt.AlignmentFlag")));
435 445 // check for a flags type wrapper
436 446 QVERIFY(PythonQtObjectPtr(_main.getVariable("PythonQt.QtCore.Qt.Alignment")));
437 447 }
438 448
449 void PythonQtTestApi::testConnects()
450 {
451 // QVERIFY(qVariantValue<QColor>(_main.evalScript("PythonQt.Qt.QColor(PythonQt.Qt.Qt.red)" ,Py_eval_input)) == QColor(Qt::red));
452 //TODO: add signal/slot connect both with QObject.connect and connect
453 }
454
439 455 void PythonQtTestApi::testQColorDecorators()
440 456 {
441 457 PythonQtObjectPtr colorClass = _main.getVariable("PythonQt.QtGui.QColor");
442 458 QVERIFY(colorClass);
443 459 // verify that the class is in the correct module
444 460 QVERIFY(colorClass.getVariable("__module__") == "PythonQt.QtGui");
445 461 // test on Qt module as well:
446 462 colorClass = _main.getVariable("PythonQt.Qt.QColor");
447 463 QVERIFY(colorClass);
448 464 // constructors
449 465 QVERIFY(qVariantValue<QColor>(colorClass.call(QVariantList() << 1 << 2 << 3)) == QColor(1,2,3));
450 466 QVERIFY(qVariantValue<QColor>(colorClass.call()) == QColor());
451 467 QEXPECT_FAIL("", "Testing non-existing constructor", Continue);
452 468 QVERIFY(colorClass.call(QVariantList() << 1 << 2) != QVariant());
453 469
454 470 // check that enum overload is taken over int
455 471 QVERIFY(qVariantValue<QColor>(_main.evalScript("PythonQt.Qt.QColor(PythonQt.Qt.Qt.red)" ,Py_eval_input)) == QColor(Qt::red));
456 472 // check that int overload is taken over enum
457 473 QVERIFY(qVariantValue<QColor>(_main.evalScript("PythonQt.Qt.QColor(0x112233)" ,Py_eval_input)) == QColor(0x112233));
458 474
459 475 // check for decorated Cmyk enum value
460 476 QVERIFY(colorClass.getVariable("Cmyk").toInt() == QColor::Cmyk);
461 477 PythonQtObjectPtr staticMethod = colorClass.getVariable("fromRgb");
462 478 QVERIFY(staticMethod);
463 479 // direct call of static method via class
464 480 QVERIFY(qVariantValue<QColor>(colorClass.call("fromRgb", QVariantList() << 1 << 2 << 3)) == QColor(1,2,3));
465 481 // direct call of static method
466 482 QVERIFY(qVariantValue<QColor>(staticMethod.call(QVariantList() << 1 << 2 << 3)) == QColor(1,2,3));
467 483 PythonQtObjectPtr publicMethod = colorClass.getVariable("red");
468 484 QVERIFY(publicMethod);
469 485 // call with passing self in:
470 486 QVERIFY(colorClass.call("red", QVariantList() << QColor(255,0,0)).toInt() == 255);
471 487 }
472 488
473 489 QByteArray PythonQtTestApiHelper::readFileAsBytes(const QString& filename)
474 490 {
475 491 QByteArray b;
476 492 return b;
477 493 }
478 494
479 495 QByteArray PythonQtTestApiHelper::readSourceFile(const QString& filename, bool& ok)
480 496 {
481 497 QByteArray b;
482 498 ok = true;
483 499 return b;
484 500 }
485 501
486 502 bool PythonQtTestApiHelper::exists(const QString& filename)
487 503 {
488 504 return true;
489 505 }
490 506
491 507 QDateTime PythonQtTestApiHelper::lastModifiedDate(const QString& filename) {
492 508 return QDateTime::currentDateTime();
493 509 }
494 510
495 511
496 512 void PythonQtTestApi::testRedirect()
497 513 {
498 514 connect(PythonQt::self(), SIGNAL(pythonStdOut(const QString&)), _helper, SLOT(stdOut(const QString&)));
499 515 connect(PythonQt::self(), SIGNAL(pythonStdErr(const QString&)), _helper, SLOT(stdErr(const QString&)));
500 516 PyRun_SimpleString("print 'test'\n");
501 517 }
502 518
503 519 void PythonQtTestApiHelper::stdOut(const QString& s)
504 520 {
505 521 qDebug() << s;
506 522 }
507 523
508 524 void PythonQtTestApiHelper::stdErr(const QString& s)
509 525 {
510 526 qDebug() << s;
511 527 }
512 528
513 529 QObject* PythonQtTestCppFactory::create(const QByteArray& name, void *ptr)
514 530 {
515 531 if (name == "PQCppObject") {
516 532 return new PQCppObjectWrapper(ptr);
517 533 }
518 534 return NULL;
519 535 }
Show file before | Show file after | Hide comments
@@ -1,500 +1,512
1 1 #ifndef _PYTHONQTTESTS_H
2 2 #define _PYTHONQTTESTS_H
3 3
4 4 /*
5 5 *
6 6 * Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
7 7 *
8 8 * This library is free software; you can redistribute it and/or
9 9 * modify it under the terms of the GNU Lesser General Public
10 10 * License as published by the Free Software Foundation; either
11 11 * version 2.1 of the License, or (at your option) any later version.
12 12 *
13 13 * This library is distributed in the hope that it will be useful,
14 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 16 * Lesser General Public License for more details.
17 17 *
18 18 * Further, this software is distributed without any warranty that it is
19 19 * free of the rightful claim of any third person regarding infringement
20 20 * or the like. Any license provided herein, whether implied or
21 21 * otherwise, applies only to this software file. Patent licenses, if
22 22 * any, provided herein do not apply to combinations of this program with
23 23 * other software, or any other product whatsoever.
24 24 *
25 25 * You should have received a copy of the GNU Lesser General Public
26 26 * License along with this library; if not, write to the Free Software
27 27 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
28 28 *
29 29 * Contact information: MeVis Research GmbH, Universitaetsallee 29,
30 30 * 28359 Bremen, Germany or:
31 31 *
32 32 * http://www.mevis.de
33 33 *
34 34 */
35 35
36 36 //----------------------------------------------------------------------------------
37 37 /*!
38 38 // \file PythonQtTests.h
39 39 // \author Florian Link
40 40 // \author Last changed by $Author: florian $
41 41 // \date 2006-05
42 42 */
43 43 //----------------------------------------------------------------------------------
44 44
45 45 #include "PythonQt.h"
46 46 #include <QtTest/QtTest>
47 47 #include <QVariant>
48 48 #include "PythonQtImportFileInterface.h"
49 49 #include "PythonQtCppWrapperFactory.h"
50 50
51 #include <QPen>
52 #include <QColor>
53 #include <QBrush>
54 #include <QCursor>
55
51 56 class PythonQtTestSlotCallingHelper;
52 57 class PythonQtTestApiHelper;
53 58 class QWidget;
54 59
55 60 //! test the PythonQt api
56 61 class PythonQtTestApi : public QObject
57 62 {
58 63 Q_OBJECT
59 64
60 65 private slots:
61 66 void initTestCase();
62 67 void testCall();
63 68 void testVariables();
64 69 void testRedirect();
65 70 void testImporter();
66 71 void testQColorDecorators();
67 72 void testQtNamespace();
73 void testConnects();
68 74
69 75 private:
70 76 PythonQtTestApiHelper* _helper;
71 77 PythonQtObjectPtr _main;
72 78
73 79 };
74 80
75 81 class ClassA {
76 82 public:
77 83 ClassA() { x = 1; }
78 84 int x;
79 85 };
80 86
81 87 class ClassB {
82 88 public:
83 89 ClassB() { y = 2; }
84 90 int y;
85 91
86 92 virtual int type() { return 2; }
87 93 };
88 94
89 95 class ClassC : public ClassA, public ClassB {
90 96 public:
91 97 ClassC() { z = 3; }
92 98 int z;
93 99
94 100 virtual int type() { return 3; }
95 101 };
96 102
97 103 class ClassD : public QObject, public ClassA, public ClassB {
98 104 Q_OBJECT
99 105 public:
100 106 ClassD() { d = 4; }
101 107 public slots:
102 108 int getD() { return d; }
103 109 private:
104 110 int d;
105 111
106 112 virtual int type() { return 4; }
107 113 };
108 114
109 115 class ClassAWrapper : public QObject {
110 116 Q_OBJECT
111 117 public slots:
112 118 ClassA* new_ClassA() { return new ClassA; }
113 119 int getX(ClassA* o) { return o->x; }
114 120 };
115 121
116 122 class ClassBWrapper : public QObject {
117 123 Q_OBJECT
118 124 public slots:
119 125 ClassB* new_ClassB() { return new ClassB; }
120 126 int getY(ClassB* o) { return o->y; }
121 127 };
122 128
123 129 class ClassCWrapper : public QObject {
124 130 Q_OBJECT
125 131 public slots:
126 132 ClassC* new_ClassC() { return new ClassC; }
127 133 int getZ(ClassC* o) { return o->z; }
128 134 };
129 135
130 136 class ClassDWrapper : public QObject {
131 137 Q_OBJECT
132 138 public slots:
133 139 ClassD* new_ClassD() { return new ClassD; }
134 140 };
135 141
136 142
137 143 //! test the PythonQt api (helper)
138 144 class PythonQtTestApiHelper : public QObject , public PythonQtImportFileInterface
139 145 {
140 146 Q_OBJECT
141 147 public:
142 148 PythonQtTestApiHelper() {
143 149 };
144 150
145 151 bool call(const QString& function, const QVariantList& args, const QVariant& expectedResult);
146 152
147 153 virtual QByteArray readFileAsBytes(const QString& filename);
148 154
149 155 virtual QByteArray readSourceFile(const QString& filename, bool& ok);
150 156
151 157 virtual bool exists(const QString& filename);
152 158
153 159 virtual QDateTime lastModifiedDate(const QString& filename);
154 160
155 161 public slots:
156 162
157 163 //! call to set that the test has passed (from Python!)
158 164 void setPassed() { _passed = true; }
159 165
160 166 void stdOut(const QString&);
161 167 void stdErr(const QString&);
162 168
163 169 private:
164 170 bool _passed;
165 171 };
166 172
167 173
168 174 // test implementation of the wrapper factory
169 175 class PythonQtTestCppFactory : public PythonQtCppWrapperFactory
170 176 {
171 177 public:
172 178 virtual QObject* create(const QByteArray& name, void *ptr);
173 179 };
174 180
175 181 //! an cpp object to be wrapped
176 182 class PQCppObject {
177 183
178 184 public:
179 185 PQCppObject(int h) { _height = h; }
180 186
181 187 int getHeight() { return _height; }
182 188 void setHeight(int h) { _height = h; }
183 189
184 190 private:
185 191 int _height;
186 192 };
187 193
188 194 //! an qobject that wraps the existing cpp object
189 195 class PQCppObjectWrapper : public QObject {
190 196 Q_OBJECT
191 197 public:
192 198 PQCppObjectWrapper(void* ptr) {
193 199 _ptr = (PQCppObject*)ptr;
194 200 }
195 201
196 202 public slots:
197 203 int getHeight() { return _ptr->getHeight(); }
198 204 void setHeight(int h) { _ptr->setHeight(h); }
199 205
200 206 private:
201 207 PQCppObject* _ptr;
202 208 };
203 209
204 210 class PQCppObjectDecorator : public QObject {
205 211 Q_OBJECT
206 212 public slots:
207 213 int getH(PQCppObject* obj) { return obj->getHeight(); }
208 214
209 215 };
210 216
211 217 //! an cpp object to be wrapped by decorators only
212 218 class PQCppObjectNoWrap {
213 219
214 220 public:
215 221 PQCppObjectNoWrap() { _height = 0; }
216 222 PQCppObjectNoWrap(int h) { _height = h; }
217 223
218 224 int getHeight() { return _height; }
219 225 void setHeight(int h) { _height = h; }
220 226
221 227 private:
222 228 int _height;
223 229 };
224 230
225 231 class PQCppObjectNoWrapDecorator : public QObject {
226 232 Q_OBJECT
227 233
228 234 public slots:
229 235 PQCppObjectNoWrap* new_PQCppObjectNoWrap() {
230 236 return new PQCppObjectNoWrap(0);
231 237 }
232 238 PQCppObjectNoWrap* new_PQCppObjectNoWrap(const PQCppObjectNoWrap& other) {
233 239 return new PQCppObjectNoWrap(1);
234 240 }
235 241 PQCppObjectNoWrap* new_PQCppObjectNoWrap(double value) {
236 242 return new PQCppObjectNoWrap(2);
237 243 }
238 244
239 245 int getH(PQCppObjectNoWrap* obj) { return obj->getHeight(); }
240 246
241 247 };
242 248
243 249
244 250 //! an cpp object that is to be wrapped by decorators only
245 251 class PQCppObject2 {
246 252
247 253 public:
248 254 enum TestEnumFlag {
249 255 TestEnumValue1 = 0,
250 256 TestEnumValue2 = 1
251 257 };
252 258
253 259 PQCppObject2() {}
254 260
255 261 };
256 262
257 263 class PQCppObject2Decorator : public QObject {
258 264 Q_OBJECT
259 265
260 266 public:
261 267 Q_ENUMS(TestEnumFlag)
262 268 Q_FLAGS(TestEnum)
263 269
264 270 enum TestEnumFlag {
265 271 TestEnumValue1 = 0,
266 272 TestEnumValue2 = 1
267 273 };
268 274
269 275 Q_DECLARE_FLAGS(TestEnum, TestEnumFlag)
270 276
271 277 public slots:
272 278 PQCppObject2* new_PQCppObject2() {
273 279 return new PQCppObject2();
274 280 }
275 281
276 282 TestEnumFlag testEnumFlag1(PQCppObject2* obj, TestEnumFlag flag);
277 283
278 284 PQCppObject2::TestEnumFlag testEnumFlag2(PQCppObject2* obj, PQCppObject2::TestEnumFlag flag);
279 285
280 286 // with int overload
281 287 TestEnumFlag testEnumFlag3(PQCppObject2* obj, int flag);
282 288 TestEnumFlag testEnumFlag3(PQCppObject2* obj, TestEnumFlag flag);
283 289
284 290 };
285 291
286 292 class PQUnknownValueObject
287 293 {
288 294 public:
289 295 PQUnknownValueObject() {};
290 296 };
291 297
292 298 class PQUnknownButRegisteredValueObject
293 299 {
294 300 public:
295 301 PQUnknownButRegisteredValueObject() {};
296 302 };
297 303
298 304 //! test the calling of slots
299 305 class PythonQtTestSlotCalling : public QObject
300 306 {
301 307 Q_OBJECT
302 308
303 309 private slots:
304 310 void initTestCase();
305 311 void init();
306 312
307 313 void testNoArgSlotCall();
308 314 void testPODSlotCalls();
309 315 void testCPPSlotCalls();
310 316 void testQVariantSlotCalls();
311 317 void testObjectSlotCalls();
312 318 void testMultiArgsSlotCall();
313 319 void testPyObjectSlotCall();
314 320 void testOverloadedCall();
315 321 void testCppFactory();
316 322 void testInheritance();
323 void testAutoConversion();
317 324
318 325 private:
319 326 PythonQtTestSlotCallingHelper* _helper;
320 327
321 328 };
322 329
323 330 //! helper class for slot calling test
324 331 class PythonQtTestSlotCallingHelper : public QObject
325 332 {
326 333 Q_OBJECT
327 334 public:
328 335 PythonQtTestSlotCallingHelper(PythonQtTestSlotCalling* test) {
329 336 _test = test;
330 337 };
331 338
332 339 bool runScript(const char* script, int expectedOverload = -1);
333 340
334 341 public slots:
335 342
336 343 //! call to set that the test has passed (from Python!)
337 344 void setPassed() { _passed = true; }
338 345
339 346 //! no arguments, no return value:
340 347 void testNoArg() { _called = true; }
341 348
342 349 //! overload test!
343 350 void overload(bool a) { _calledOverload = 0; _called = true; }
344 351 void overload(float a) { _calledOverload = 1; _called = true;}
345 352 void overload(int a) { _calledOverload = 2; _called = true;}
346 353 void overload(const QString& str) { _calledOverload = 3; _called = true;}
347 354 void overload(const QStringList& str) { _calledOverload = 4; _called = true;}
348 355 void overload(QObject* str) { _calledOverload = 5; _called = true;}
349 356 void overload(float a, int b) { _calledOverload = 6; _called = true;}
350 357
351 358 //! POD values:
352 359 int getInt(int a) { _called = true; return a; }
353 360 unsigned int getUInt(unsigned int a) { _called = true; return a; }
354 361 bool getBool(bool a) { _called = true; return a; }
355 362 char getChar(char a) { _called = true; return a; }
356 363 unsigned char getUChar(unsigned char a) { _called = true; return a; }
357 364 long getLong(long a) { _called = true; return a; }
358 365 unsigned long getULong(unsigned long a) { _called = true; return a; }
359 366 short getShort(short a) { _called = true; return a; }
360 367 unsigned short getUShort(unsigned short a) { _called = true; return a; }
361 368 QChar getQChar(QChar a) { _called = true; return a; }
362 369 qint64 getLongLong(qint64 a) { _called = true; return a; }
363 370 quint64 getULongLong(quint64 a) { _called = true; return a; }
364 371 double getDouble(double d) { _called = true; return d; }
365 372 float getFloat(float d) { _called = true; return d; }
366 373
367 374 //! important qt types:
368 375 QString getQString(const QString& s) { _called = true; return s; }
369 376 QStringList getQStringList(const QStringList& l) { _called = true; return l; }
370 377 QVariant getQVariant(const QVariant& var) { _called = true; return var; }
371 378
372 379 // QColor as representative for C++ value classes
373 380 QColor getQColor1(const QColor& var) { _called = true; return var; }
374 381 QColor getQColor2(QColor& var) { _called = true; return var; }
375 382 QColor getQColor3(QColor* col) { _called = true; return *col; }
376 383 QColor getQColor4(const QVariant& color) { _called = true; return qVariantValue<QColor>(color); }
377 384 QColor* getQColor5() { _called = true; static QColor c(1,2,3); return &c; }
378 385
379 386 PyObject* getPyObject(PyObject* obj) { _called = true; return obj; }
380 387 PyObject* getPyObjectFromVariant(const QVariant& val) { _called = true; return PythonQtObjectPtr(val); };
381 388 QVariant getPyObjectFromVariant2(const QVariant& val) { _called = true; return val; };
382 389 // this does not yet work but is not required to work:
383 390 //PyObject* getPyObjectFromPtr(const PythonQtObjectPtr& val) { _called = true; return val; };
384 391
385 392 //! testing pointer passing
386 393 PythonQtTestSlotCallingHelper* getTestObject(PythonQtTestSlotCallingHelper* obj) { _called = true; return obj; }
387 394 //! testing inheritance checking
388 395 QObject* getQObject(QObject* obj) { _called = true; return obj; }
389 396 QWidget* getQWidget(QWidget* obj) { _called = true; return obj; }
390 397 //! testing if an object that was not wrapped is wrapped earlier is wrapped correctly
391 398 QObject* getNewObject() { _called = true; return new PythonQtTestSlotCallingHelper(NULL); }
392 399
393 400 QVariantList getMultiArgs(int a, double b, const QString& str) { _called = true; return (QVariantList() << a << b << str); }
394 401
395 402 //! cpp wrapper factory test
396 403 PQCppObject* createPQCppObject(int h) { _called = true; return new PQCppObject(h); }
397 404
398 405 //! cpp wrapper factory test
399 406 PQCppObject* getPQCppObject(PQCppObject* p) { _called = true; return p; }
400 407
401 408 //! cpp wrapper factory test
402 409 PQCppObjectNoWrap* createPQCppObjectNoWrap(int h) { _called = true; return new PQCppObjectNoWrap(h); }
403 410
404 411 //! cpp wrapper factory test
405 412 PQCppObjectNoWrap* getPQCppObjectNoWrap(PQCppObjectNoWrap* p) { _called = true; return p; }
406 413
407 414 //! get a return by value PQCppObjectNoWrap
408 415 PQCppObjectNoWrap getPQCppObjectNoWrapAsValue() { _called = true; return PQCppObjectNoWrap(47); }
409 416
410 417 PQUnknownButRegisteredValueObject getUnknownButRegisteredValueObjectAsValue() { _called = true; return PQUnknownButRegisteredValueObject(); }
411 418 PQUnknownValueObject getUnknownValueObjectAsValue() { _called = true; return PQUnknownValueObject(); }
412 419
413 420 PQUnknownButRegisteredValueObject* getUnknownButRegisteredValueObjectAsPtr() { _called = true; return new PQUnknownButRegisteredValueObject(); }
414 421 PQUnknownValueObject* getUnknownValueObjectAsPtr() { _called = true; return new PQUnknownValueObject(); }
415 422
416 423 ClassA* getClassAPtr(ClassA* o) { _called = true; return o; }
417 424 ClassB* getClassBPtr(ClassB* o) { _called = true; return o; }
418 425 ClassC* getClassCPtr(ClassC* o) { _called = true; return o; }
419 426 ClassD* getClassDPtr(ClassD* o) { _called = true; return o; }
420 427
421 428 ClassA* createClassA() { _called = true; return new ClassA; }
422 429 ClassB* createClassB() { _called = true; return new ClassB; }
423 430 ClassC* createClassC() { _called = true; return new ClassC; }
424 431 ClassD* createClassD() { _called = true; return new ClassD; }
425 432 ClassA* createClassCAsA() { _called = true; return new ClassC; }
426 433 ClassB* createClassCAsB() { _called = true; return new ClassC; }
427 434 ClassA* createClassDAsA() { _called = true; return new ClassD; }
428 435 ClassB* createClassDAsB() { _called = true; return new ClassD; }
429 436
437 QColor setAutoConvertColor(const QColor& color) { _called = true; return color; };
438 QBrush setAutoConvertBrush(const QBrush& brush) { _called = true; return brush; };
439 QPen setAutoConvertPen(const QPen& pen) { _called = true; return pen; };
440 QCursor setAutoConvertCursor(const QCursor& cursor) { _called = true; return cursor; };
441
430 442 private:
431 443 bool _passed;
432 444 bool _called;
433 445 int _calledOverload;
434 446 PythonQtTestSlotCalling* _test;
435 447 };
436 448
437 449 class PythonQtTestSignalHandlerHelper;
438 450
439 451 //! test the connection of signals to python
440 452 class PythonQtTestSignalHandler : public QObject
441 453 {
442 454 Q_OBJECT
443 455
444 456 private slots:
445 457 void initTestCase();
446 458
447 459 void testSignalHandler();
448 460 void testRecursiveSignalHandler();
449 461
450 462 private:
451 463 PythonQtTestSignalHandlerHelper* _helper;
452 464
453 465 };
454 466
455 467 //! helper class for signal testing
456 468 class PythonQtTestSignalHandlerHelper : public QObject
457 469 {
458 470 Q_OBJECT
459 471
460 472 public:
461 473 PythonQtTestSignalHandlerHelper(PythonQtTestSignalHandler* test) {
462 474 _test = test;
463 475 };
464 476
465 477 public slots:
466 478 void setPassed() { _passed = true; }
467 479
468 480 bool emitIntSignal(int a) { _passed = false; emit intSignal(a); return _passed; };
469 481 bool emitFloatSignal(float a) { _passed = false; emit floatSignal(a); return _passed; };
470 482 bool emitEnumSignal(PQCppObject2::TestEnumFlag flag) { _passed = false; emit enumSignal(flag); return _passed; };
471 483
472 484 bool emitVariantSignal(const QVariant& v) { _passed = false; emit variantSignal(v); return _passed; };
473 485 QVariant expectedVariant() { return _v; }
474 486 void setExpectedVariant(const QVariant& v) { _v = v; }
475 487
476 488 bool emitComplexSignal(int a, float b, const QStringList& l, QObject* obj) { _passed = false; emit complexSignal(a,b,l,obj); return _passed; };
477 489
478 490 bool emitSignal1(int a) { _passed = false; emit signal1(a); return _passed; };
479 491 bool emitSignal2(const QString& s) { _passed = false; emit signal2(s); return _passed; };
480 492 bool emitSignal3(float a) { _passed = false; emit signal3(a); return _passed; };
481 493
482 494 signals:
483 495 void intSignal(int);
484 496 void floatSignal(float);
485 497 void variantSignal(const QVariant& v);
486 498 void complexSignal(int a, float b, const QStringList& l, QObject* obj);
487 499 void enumSignal(PQCppObject2::TestEnumFlag flag);
488 500
489 501 void signal1(int);
490 502 void signal2(const QString&);
491 503 void signal3(float);
492 504
493 505 private:
494 506 bool _passed;
495 507 QVariant _v;
496 508
497 509 PythonQtTestSignalHandler* _test;
498 510 };
499 511
500 512 #endif
General Comments 0
You need to be logged in to leave comments. Login now