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

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

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