The Tor Browser / file comparison

comparison: xpcom/reflect/xptcall/tests/TestXPTCInvoke.cpp

xpcom/reflect/xptcall/tests/TestXPTCInvoke.cpp

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:af9db974730e
1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /* This Source Code Form is subject to the terms of the Mozilla Public
3 * License, v. 2.0. If a copy of the MPL was not distributed with this
4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
5
6 /* Invoke tests xptcall. */
7
8 #include <stdio.h>
9 #include "xptcall.h"
10 #include "prinrval.h"
11 #include "nsMemory.h"
12
13 // Allows us to mark unused functions as known-unused
14 #ifdef __GNUC__
15 #define UNUSED __attribute__ ((unused))
16 #else
17 #define UNUSED
18 #endif
19
20 // forward declration
21 static void DoMultipleInheritenceTest();
22 static void DoMultipleInheritenceTest2();
23 static void UNUSED DoSpeedTest();
24
25 // {AAC1FB90-E099-11d2-984E-006008962422}
26 #define INVOKETESTTARGET_IID \
27 { 0xaac1fb90, 0xe099, 0x11d2, \
28 { 0x98, 0x4e, 0x0, 0x60, 0x8, 0x96, 0x24, 0x22 } }
29
30
31 class InvokeTestTargetInterface : public nsISupports
32 {
33 public:
34 NS_DECLARE_STATIC_IID_ACCESSOR(INVOKETESTTARGET_IID)
35 NS_IMETHOD AddTwoInts(int32_t p1, int32_t p2, int32_t* retval) = 0;
36 NS_IMETHOD MultTwoInts(int32_t p1, int32_t p2, int32_t* retval) = 0;
37 NS_IMETHOD AddTwoLLs(int64_t p1, int64_t p2, int64_t* retval) = 0;
38 NS_IMETHOD MultTwoLLs(int64_t p1, int64_t p2, int64_t* retval) = 0;
39
40 NS_IMETHOD AddManyInts(int32_t p1, int32_t p2, int32_t p3, int32_t p4,
41 int32_t p5, int32_t p6, int32_t p7, int32_t p8,
42 int32_t p9, int32_t p10, int32_t* retval) = 0;
43
44 NS_IMETHOD AddTwoFloats(float p1, float p2, float* retval) = 0;
45
46 NS_IMETHOD AddManyDoubles(double p1, double p2, double p3, double p4,
47 double p5, double p6, double p7, double p8,
48 double p9, double p10, double* retval) = 0;
49
50 NS_IMETHOD AddManyFloats(float p1, float p2, float p3, float p4,
51 float p5, float p6, float p7, float p8,
52 float p9, float p10, float* retval) = 0;
53
54 NS_IMETHOD AddManyManyFloats(float p1, float p2, float p3, float p4,
55 float p5, float p6, float p7, float p8,
56 float p9, float p10, float p11, float p12,
57 float p13, float p14, float p15, float p16,
58 float p17, float p18, float p19, float p20,
59 float *retval) = 0;
60
61 NS_IMETHOD AddMixedInts(int64_t p1, int32_t p2, int64_t p3, int32_t p4,
62 int32_t p5, int64_t p6, int32_t p7, int32_t p8,
63 int64_t p9, int32_t p10, int64_t* retval) = 0;
64
65 NS_IMETHOD AddMixedInts2(int32_t p1, int64_t p2, int32_t p3, int64_t p4,
66 int64_t p5, int32_t p6, int64_t p7, int64_t p8,
67 int32_t p9, int64_t p10, int64_t* retval) = 0;
68
69 NS_IMETHOD AddMixedFloats(float p1, float p2, double p3, double p4,
70 float p5, float p6, double p7, double p8,
71 float p9, double p10, float p11,
72 double *retval) = 0;
73
74 NS_IMETHOD PassTwoStrings(const char* s1, const char* s2, char** retval) = 0;
75
76 NS_IMETHOD AddMixedInts3(int64_t p1, int64_t p2, int32_t p3, int64_t p4,
77 int32_t p5, int32_t p6, int64_t p7, int64_t p8,
78 int32_t p9, int64_t p10, int64_t* retval) = 0;
79 NS_IMETHOD ShouldFail(int32_t p) = 0;
80 };
81
82 NS_DEFINE_STATIC_IID_ACCESSOR(InvokeTestTargetInterface, INVOKETESTTARGET_IID)
83
84 class InvokeTestTarget : public InvokeTestTargetInterface
85 {
86 public:
87 NS_DECL_ISUPPORTS
88 NS_IMETHOD AddTwoInts(int32_t p1, int32_t p2, int32_t* retval);
89 NS_IMETHOD MultTwoInts(int32_t p1, int32_t p2, int32_t* retval);
90 NS_IMETHOD AddTwoLLs(int64_t p1, int64_t p2, int64_t* retval);
91 NS_IMETHOD MultTwoLLs(int64_t p1, int64_t p2, int64_t* retval);
92
93 NS_IMETHOD AddManyInts(int32_t p1, int32_t p2, int32_t p3, int32_t p4,
94 int32_t p5, int32_t p6, int32_t p7, int32_t p8,
95 int32_t p9, int32_t p10, int32_t* retval);
96
97 NS_IMETHOD AddTwoFloats(float p1, float p2, float* retval);
98
99 NS_IMETHOD AddManyDoubles(double p1, double p2, double p3, double p4,
100 double p5, double p6, double p7, double p8,
101 double p9, double p10, double* retval);
102
103 NS_IMETHOD AddManyFloats(float p1, float p2, float p3, float p4,
104 float p5, float p6, float p7, float p8,
105 float p9, float p10, float* retval);
106
107 NS_IMETHOD AddMixedInts(int64_t p1, int32_t p2, int64_t p3, int32_t p4,
108 int32_t p5, int64_t p6, int32_t p7, int32_t p8,
109 int64_t p9, int32_t p10, int64_t* retval);
110
111 NS_IMETHOD AddMixedInts2(int32_t p1, int64_t p2, int32_t p3, int64_t p4,
112 int64_t p5, int32_t p6, int64_t p7, int64_t p8,
113 int32_t p9, int64_t p10, int64_t* retval);
114
115 NS_IMETHOD AddMixedFloats(float p1, float p2, double p3, double p4,
116 float p5, float p6, double p7, double p8,
117 float p9, double p10, float p11,
118 double *retval);
119
120 NS_IMETHOD AddManyManyFloats(float p1, float p2, float p3, float p4,
121 float p5, float p6, float p7, float p8,
122 float p9, float p10, float p11, float p12,
123 float p13, float p14, float p15, float p16,
124 float p17, float p18, float p19, float p20,
125 float *retval);
126
127 NS_IMETHOD PassTwoStrings(const char* s1, const char* s2, char** retval);
128
129 InvokeTestTarget();
130
131 NS_IMETHOD AddMixedInts3(int64_t p1, int64_t p2, int32_t p3, int64_t p4,
132 int32_t p5, int32_t p6, int64_t p7, int64_t p8,
133 int32_t p9, int64_t p10, int64_t* retval);
134 NS_IMETHOD ShouldFail(int32_t p);
135 };
136
137 NS_IMPL_ISUPPORTS(InvokeTestTarget, InvokeTestTargetInterface)
138
139 InvokeTestTarget::InvokeTestTarget()
140 {
141 NS_ADDREF_THIS();
142 }
143
144 NS_IMETHODIMP
145 InvokeTestTarget::ShouldFail(int32_t p) {
146 return NS_ERROR_NULL_POINTER;
147 }
148 NS_IMETHODIMP
149 InvokeTestTarget::AddTwoInts(int32_t p1, int32_t p2, int32_t* retval)
150 {
151 *retval = p1 + p2;
152 return NS_OK;
153 }
154
155 NS_IMETHODIMP
156 InvokeTestTarget::MultTwoInts(int32_t p1, int32_t p2, int32_t* retval)
157 {
158 *retval = p1 * p2;
159 return NS_OK;
160 }
161
162 NS_IMETHODIMP
163 InvokeTestTarget::AddTwoLLs(int64_t p1, int64_t p2, int64_t* retval)
164 {
165 *retval = p1 + p2;
166 return NS_OK;
167 }
168
169 NS_IMETHODIMP
170 InvokeTestTarget::MultTwoLLs(int64_t p1, int64_t p2, int64_t* retval)
171 {
172 *retval = p1 * p2;
173 return NS_OK;
174 }
175
176 NS_IMETHODIMP
177 InvokeTestTarget::AddManyInts(int32_t p1, int32_t p2, int32_t p3, int32_t p4,
178 int32_t p5, int32_t p6, int32_t p7, int32_t p8,
179 int32_t p9, int32_t p10, int32_t* retval)
180 {
181 #ifdef DEBUG_TESTINVOKE
182 printf("%d, %d, %d, %d, %d, %d, %d, %d, %d, %d\n",
183 p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
184 #endif
185 *retval = p1 + p2 + p3 + p4 + p5 + p6 + p7 + p8 + p9 + p10;
186 return NS_OK;
187 }
188
189 NS_IMETHODIMP
190 InvokeTestTarget::AddTwoFloats(float p1, float p2, float *retval)
191 {
192 #ifdef DEBUG_TESTINVOKE
193 printf("%f, %f\n", p1, p2);
194 #endif
195 *retval = p1 + p2;
196 return NS_OK;
197 }
198
199 NS_IMETHODIMP
200 InvokeTestTarget::AddManyDoubles(double p1, double p2, double p3, double p4,
201 double p5, double p6, double p7, double p8,
202 double p9, double p10, double* retval)
203 {
204 #ifdef DEBUG_TESTINVOKE
205 printf("%lf, %lf, %lf, %lf, %lf, %lf, %lf, %lf, %lf, %lf\n",
206 p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
207 #endif
208 *retval = p1 + p2 + p3 + p4 + p5 + p6 + p7 + p8 + p9 + p10;
209 return NS_OK;
210 }
211
212 NS_IMETHODIMP
213 InvokeTestTarget::AddManyFloats(float p1, float p2, float p3, float p4,
214 float p5, float p6, float p7, float p8,
215 float p9, float p10, float* retval)
216 {
217 #ifdef DEBUG_TESTINVOKE
218 printf("%f, %f, %f, %f, %f, %f, %f, %f, %f, %f\n",
219 p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
220 #endif
221 *retval = p1 + p2 + p3 + p4 + p5 + p6 + p7 + p8 + p9 + p10;
222 return NS_OK;
223 }
224
225 NS_IMETHODIMP
226 InvokeTestTarget::AddMixedFloats(float p1, float p2, double p3, double p4,
227 float p5, float p6, double p7, double p8,
228 float p9, double p10, float p11,
229 double *retval)
230 {
231 #ifdef DEBUG_TESTINVOKE
232 printf("%f, %f, %lf, %lf, %f, %f, %lf, %lf, %f, %lf, %f\n",
233 p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11);
234 #endif
235 *retval = p1 + p2 + p3 + p4 + p5 + p6 + p7 + p8 + p9 + p10 + p11;
236 return NS_OK;
237 }
238
239 NS_IMETHODIMP
240 InvokeTestTarget::AddManyManyFloats(float p1, float p2, float p3, float p4,
241 float p5, float p6, float p7, float p8,
242 float p9, float p10, float p11, float p12,
243 float p13, float p14, float p15, float p16,
244 float p17, float p18, float p19, float p20,
245 float *retval)
246 {
247 #ifdef DEBUG_TESTINVOKE
248 printf("%f, %f, %f, %f, %f, %f, %f, %f, %f, %f, "
249 "%f, %f, %f, %f, %f, %f, %f, %f, %f, %f\n",
250 p1, p2, p3, p4, p5, p6, p7, p8, p9, p10,
251 p11, p12, p13, p14, p15, p16, p17, p18, p19, p20);
252 #endif
253 *retval = p1 + p2 + p3 + p4 + p5 + p6 + p7 + p8 + p9 + p10 +
254 p11 + p12 + p13 + p14 + p15 + p16 + p17 + p18 + p19 + p20;
255 return NS_OK;
256 }
257
258 NS_IMETHODIMP
259 InvokeTestTarget::AddMixedInts(int64_t p1, int32_t p2, int64_t p3, int32_t p4,
260 int32_t p5, int64_t p6, int32_t p7, int32_t p8,
261 int64_t p9, int32_t p10, int64_t* retval)
262 {
263 *retval = p1 + p2 + p3 + p4 + p5 + p6 + p7 + p8 + p9 + p10;
264 return NS_OK;
265 }
266
267 NS_IMETHODIMP
268 InvokeTestTarget::AddMixedInts2(int32_t p1, int64_t p2, int32_t p3, int64_t p4,
269 int64_t p5, int32_t p6, int64_t p7, int64_t p8,
270 int32_t p9, int64_t p10, int64_t* retval)
271 {
272 *retval = p1 + p2 + p3 + p4 + p5 + p6 + p7 + p8 + p9 + p10;
273 return NS_OK;
274 }
275
276 NS_IMETHODIMP
277 InvokeTestTarget::AddMixedInts3(int64_t p1, int64_t p2, int32_t p3, int64_t p4,
278 int32_t p5, int32_t p6, int64_t p7, int64_t p8,
279 int32_t p9, int64_t p10, int64_t* retval)
280 {
281 printf("P1 : %lld\n", p1);
282 printf("P2 : %lld\n", p2);
283 printf("P3 : %d\n", p3);
284 printf("P4 : %lld\n", p4);
285 printf("P5 : %d\n", p5);
286 printf("P6 : %d\n", p6);
287 printf("P7 : %lld\n", p7);
288 printf("P8 : %lld\n", p8);
289 printf("P9 : %d\n", p9);
290 printf("P10: %lld\n", p10);
291 printf("ret: %p\n", static_cast<void*>(retval));
292 *retval = p1 + p2 + p3 + p4 + p5 + p6 + p7 + p8 + p9 + p10;
293 return NS_OK;
294 }
295
296 NS_IMETHODIMP
297 InvokeTestTarget::PassTwoStrings(const char* s1, const char* s2, char** retval)
298 {
299 const char milk[] = "milk";
300 char *ret = (char*)nsMemory::Alloc(sizeof(milk));
301 if (!ret)
302 return NS_ERROR_OUT_OF_MEMORY;
303 strncpy(ret, milk, sizeof(milk));
304 printf("\t%s %s", s1, s2);
305 *retval = ret;
306 return NS_OK;
307 }
308
309 int main()
310 {
311 InvokeTestTarget *test = new InvokeTestTarget();
312
313 /* here we make the global 'check for alloc failure' checker happy */
314 if(!test)
315 return 1;
316
317 int32_t out, tmp32 = 0;
318 int64_t out64;
319 nsresult failed_rv;
320 printf("calling direct:\n");
321 if(NS_SUCCEEDED(test->AddTwoInts(1,1,&out)))
322 printf("\t1 + 1 = %d\n", out);
323 else
324 printf("\tFAILED");
325 int64_t one = 1, two = 2;
326 if(NS_SUCCEEDED(test->AddTwoLLs(one,one,&out64)))
327 {
328 tmp32 = (int)out64;
329 printf("\t1L + 1L = %d\n", tmp32);
330 }
331 else
332 printf("\tFAILED");
333 if(NS_SUCCEEDED(test->MultTwoInts(2,2,&out)))
334 printf("\t2 * 2 = %d\n", out);
335 else
336 printf("\tFAILED");
337 if(NS_SUCCEEDED(test->MultTwoLLs(two,two,&out64)))
338 {
339 tmp32 = (int)out64;
340 printf("\t2L * 2L = %d\n", tmp32);
341 }
342 else
343 printf("\tFAILED");
344
345 double outD;
346 float outF;
347 int32_t outI;
348 char *outS;
349
350 if(NS_SUCCEEDED(test->AddManyInts(1,2,3,4,5,6,7,8,9,10,&outI)))
351 printf("\t1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 = %d\n", outI);
352 else
353 printf("\tFAILED");
354
355 if(NS_SUCCEEDED(test->AddTwoFloats(1,2,&outF)))
356 printf("\t1 + 2 = %ff\n", (double)outF);
357 else
358 printf("\tFAILED");
359
360 if(NS_SUCCEEDED(test->AddManyDoubles(1,2,3,4,5,6,7,8,9,10,&outD)))
361 printf("\t1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 = %f\n", outD);
362 else
363 printf("\tFAILED");
364
365 if(NS_SUCCEEDED(test->AddManyFloats(1,2,3,4,5,6,7,8,9,10,&outF)))
366 printf("\t1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 = %ff\n", (double)outF);
367 else
368 printf("\tFAILED");
369
370 if(NS_SUCCEEDED(test->AddManyManyFloats(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,&outF)))
371 printf("\t1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 +1 15 + 16 + 17 + 18 + 19 + 20 = %ff\n", (double)outF);
372 else
373 printf("\tFAILED");
374
375 if(NS_SUCCEEDED(test->AddMixedInts(1,2,3,4,5,6,7,8,9,10,&out64)))
376 {
377 tmp32 = (int)out64;
378 printf("\t1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 = %d\n", tmp32);
379 }
380 else
381 printf("\tFAILED");
382
383 if(NS_SUCCEEDED(test->AddMixedInts2(1,2,3,4,5,6,7,8,9,10,&out64)))
384 {
385 tmp32 = (int)out64;
386 printf("\t1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 = %d\n", tmp32);
387 }
388 else
389 printf("\tFAILED");
390
391 if(NS_SUCCEEDED(test->AddMixedInts3(3,5,7,11,13,17,19,23,29,31,&out64)))
392 {
393 tmp32 = (int)out64;
394 printf("\t3 + 5 + 7 + 11 + 13 + 17 + 19 + 23 + 29 + 31 = %d\n", tmp32);
395 }
396 else
397 printf("\tFAILED");
398
399 if(NS_SUCCEEDED(test->AddMixedFloats(1,2,3,4,5,6,7,8,9,10,11,&outD)))
400 printf("\t1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 = %f\n", (double)outD);
401 else
402 printf("\tFAILED");
403
404 if (NS_SUCCEEDED(test->PassTwoStrings("moo","cow",&outS))) {
405 printf(" = %s\n", outS);
406 nsMemory::Free(outS);
407 } else
408 printf("\tFAILED");
409
410 failed_rv = test->ShouldFail(5);
411 printf("should fail %s, returned %x\n", failed_rv == NS_ERROR_NULL_POINTER ? "failed" :"passed", failed_rv);
412
413 printf("calling via invoke:\n");
414
415 nsXPTCVariant var[21];
416
417 var[0].val.i32 = 1;
418 var[0].type = nsXPTType::T_I32;
419 var[0].flags = 0;
420
421 var[1].val.i32 = 1;
422 var[1].type = nsXPTType::T_I32;
423 var[1].flags = 0;
424
425 var[2].val.i32 = 0;
426 var[2].type = nsXPTType::T_I32;
427 var[2].flags = nsXPTCVariant::PTR_IS_DATA;
428 var[2].ptr = &var[2].val.i32;
429
430 if(NS_SUCCEEDED(NS_InvokeByIndex(test, 3, 3, var)))
431 printf("\t1 + 1 = %d\n", var[2].val.i32);
432 else
433 printf("\tFAILED");
434
435 var[0].val.i64 = 1;
436 var[0].type = nsXPTType::T_I64;
437 var[0].flags = 0;
438
439 var[1].val.i64 = 1;
440 var[1].type = nsXPTType::T_I64;
441 var[1].flags = 0;
442
443 var[2].val.i64 = 0;
444 var[2].type = nsXPTType::T_I64;
445 var[2].flags = nsXPTCVariant::PTR_IS_DATA;
446 var[2].ptr = &var[2].val.i64;
447
448 if(NS_SUCCEEDED(NS_InvokeByIndex(test, 5, 3, var)))
449 printf("\t1L + 1L = %d\n", (int)var[2].val.i64);
450 else
451 printf("\tFAILED");
452
453 var[0].val.i32 = 2;
454 var[0].type = nsXPTType::T_I32;
455 var[0].flags = 0;
456
457 var[1].val.i32 = 2;
458 var[1].type = nsXPTType::T_I32;
459 var[1].flags = 0;
460
461 var[2].val.i32 = 0;
462 var[2].type = nsXPTType::T_I32;
463 var[2].flags = nsXPTCVariant::PTR_IS_DATA;
464 var[2].ptr = &var[2].val.i32;
465
466 if(NS_SUCCEEDED(NS_InvokeByIndex(test, 4, 3, var)))
467 printf("\t2 * 2 = %d\n", var[2].val.i32);
468 else
469 printf("\tFAILED");
470
471 var[0].val.i64 = 2;
472 var[0].type = nsXPTType::T_I64;
473 var[0].flags = 0;
474
475 var[1].val.i64 = 2;
476 var[1].type = nsXPTType::T_I64;
477 var[1].flags = 0;
478
479 var[2].val.i64 = 0;
480 var[2].type = nsXPTType::T_I64;
481 var[2].flags = nsXPTCVariant::PTR_IS_DATA;
482 var[2].ptr = &var[2].val.i64;
483
484 if(NS_SUCCEEDED(NS_InvokeByIndex(test, 6, 3, var)))
485 printf("\t2L * 2L = %d\n", (int)var[2].val.i64);
486 else
487 printf("\tFAILED");
488
489 var[0].val.i32 = 1;
490 var[0].type = nsXPTType::T_I32;
491 var[0].flags = 0;
492
493 var[1].val.i32 = 2;
494 var[1].type = nsXPTType::T_I32;
495 var[1].flags = 0;
496
497 var[2].val.i32 = 3;
498 var[2].type = nsXPTType::T_I32;
499 var[2].flags = 0;
500
501 var[3].val.i32 = 4;
502 var[3].type = nsXPTType::T_I32;
503 var[3].flags = 0;
504
505 var[4].val.i32 = 5;
506 var[4].type = nsXPTType::T_I32;
507 var[4].flags = 0;
508
509 var[5].val.i32 = 6;
510 var[5].type = nsXPTType::T_I32;
511 var[5].flags = 0;
512
513 var[6].val.i32 = 7;
514 var[6].type = nsXPTType::T_I32;
515 var[6].flags = 0;
516
517 var[7].val.i32 = 8;
518 var[7].type = nsXPTType::T_I32;
519 var[7].flags = 0;
520
521 var[8].val.i32 = 9;
522 var[8].type = nsXPTType::T_I32;
523 var[8].flags = 0;
524
525 var[9].val.i32 = 10;
526 var[9].type = nsXPTType::T_I32;
527 var[9].flags = 0;
528
529 var[10].val.i32 = 0;
530 var[10].type = nsXPTType::T_I32;
531 var[10].flags = nsXPTCVariant::PTR_IS_DATA;
532 var[10].ptr = &var[10].val.i32;
533
534 if(NS_SUCCEEDED(NS_InvokeByIndex(test, 7, 11, var)))
535 printf("\t1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 = %d\n",
536 var[10].val.i32);
537
538 var[0].val.f = 1.0f;
539 var[0].type = nsXPTType::T_FLOAT;
540 var[0].flags = 0;
541
542 var[1].val.f = 2.0f;
543 var[1].type = nsXPTType::T_FLOAT;
544 var[1].flags = 0;
545
546 var[2].val.f = 0.0f;
547 var[2].type = nsXPTType::T_FLOAT;
548 var[2].flags = nsXPTCVariant::PTR_IS_DATA;
549 var[2].ptr = &var[2].val.f;
550
551 if(NS_SUCCEEDED(NS_InvokeByIndex(test, 8, 3, var)))
552 printf("\t1 + 2 = %ff\n",
553 (double) var[2].val.f);
554
555
556 var[0].val.d = 1.0;
557 var[0].type = nsXPTType::T_DOUBLE;
558 var[0].flags = 0;
559
560 var[1].val.d = 2.0;
561 var[1].type = nsXPTType::T_DOUBLE;
562 var[1].flags = 0;
563
564 var[2].val.d = 3.0;
565 var[2].type = nsXPTType::T_DOUBLE;
566 var[2].flags = 0;
567
568 var[3].val.d = 4.0;
569 var[3].type = nsXPTType::T_DOUBLE;
570 var[3].flags = 0;
571
572 var[4].val.d = 5.0;
573 var[4].type = nsXPTType::T_DOUBLE;
574 var[4].flags = 0;
575
576 var[5].val.d = 6.0;
577 var[5].type = nsXPTType::T_DOUBLE;
578 var[5].flags = 0;
579
580 var[6].val.d = 7.0;
581 var[6].type = nsXPTType::T_DOUBLE;
582 var[6].flags = 0;
583
584 var[7].val.d = 8.0;
585 var[7].type = nsXPTType::T_DOUBLE;
586 var[7].flags = 0;
587
588 var[8].val.d = 9.0;
589 var[8].type = nsXPTType::T_DOUBLE;
590 var[8].flags = 0;
591
592 var[9].val.d = 10.0;
593 var[9].type = nsXPTType::T_DOUBLE;
594 var[9].flags = 0;
595
596 var[10].val.d = 0.0;
597 var[10].type = nsXPTType::T_DOUBLE;
598 var[10].flags = nsXPTCVariant::PTR_IS_DATA;
599 var[10].ptr = &var[10].val.d;
600
601 if(NS_SUCCEEDED(NS_InvokeByIndex(test, 9, 11, var)))
602 printf("\t1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 = %f\n",
603 var[10].val.d);
604 else
605 printf("\tFAILED");
606
607 var[0].val.f = 1.0f;
608 var[0].type = nsXPTType::T_FLOAT;
609 var[0].flags = 0;
610
611 var[1].val.f = 2.0f;
612 var[1].type = nsXPTType::T_FLOAT;
613 var[1].flags = 0;
614
615 var[2].val.f = 3.0f;
616 var[2].type = nsXPTType::T_FLOAT;
617 var[2].flags = 0;
618
619 var[3].val.f = 4.0f;
620 var[3].type = nsXPTType::T_FLOAT;
621 var[3].flags = 0;
622
623 var[4].val.f = 5.0f;
624 var[4].type = nsXPTType::T_FLOAT;
625 var[4].flags = 0;
626
627 var[5].val.f = 6.0f;
628 var[5].type = nsXPTType::T_FLOAT;
629 var[5].flags = 0;
630
631 var[6].val.f = 7.0f;
632 var[6].type = nsXPTType::T_FLOAT;
633 var[6].flags = 0;
634
635 var[7].val.f = 8.0f;
636 var[7].type = nsXPTType::T_FLOAT;
637 var[7].flags = 0;
638
639 var[8].val.f = 9.0f;
640 var[8].type = nsXPTType::T_FLOAT;
641 var[8].flags = 0;
642
643 var[9].val.f = 10.0f;
644 var[9].type = nsXPTType::T_FLOAT;
645 var[9].flags = 0;
646
647 var[10].val.f = 0.0f;
648 var[10].type = nsXPTType::T_FLOAT;
649 var[10].flags = nsXPTCVariant::PTR_IS_DATA;
650 var[10].ptr = &var[10].val.f;
651
652 if(NS_SUCCEEDED(NS_InvokeByIndex(test, 10, 11, var)))
653 printf("\t1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 = %ff\n",
654 (double) var[10].val.f);
655 else
656 printf("\tFAILED");
657
658 var[0].val.f = 1.0f;
659 var[0].type = nsXPTType::T_FLOAT;
660 var[0].flags = 0;
661
662 var[1].val.f = 2.0f;
663 var[1].type = nsXPTType::T_FLOAT;
664 var[1].flags = 0;
665
666 var[2].val.f = 3.0f;
667 var[2].type = nsXPTType::T_FLOAT;
668 var[2].flags = 0;
669
670 var[3].val.f = 4.0f;
671 var[3].type = nsXPTType::T_FLOAT;
672 var[3].flags = 0;
673
674 var[4].val.f = 5.0f;
675 var[4].type = nsXPTType::T_FLOAT;
676 var[4].flags = 0;
677
678 var[5].val.f = 6.0f;
679 var[5].type = nsXPTType::T_FLOAT;
680 var[5].flags = 0;
681
682 var[6].val.f = 7.0f;
683 var[6].type = nsXPTType::T_FLOAT;
684 var[6].flags = 0;
685
686 var[7].val.f = 8.0f;
687 var[7].type = nsXPTType::T_FLOAT;
688 var[7].flags = 0;
689
690 var[8].val.f = 9.0f;
691 var[8].type = nsXPTType::T_FLOAT;
692 var[8].flags = 0;
693
694 var[9].val.f = 10.0f;
695 var[9].type = nsXPTType::T_FLOAT;
696 var[9].flags = 0;
697
698 var[10].val.f = 11.0f;
699 var[10].type = nsXPTType::T_FLOAT;
700 var[10].flags = 0;
701
702 var[11].val.f = 12.0f;
703 var[11].type = nsXPTType::T_FLOAT;
704 var[11].flags = 0;
705
706 var[12].val.f = 13.0f;
707 var[12].type = nsXPTType::T_FLOAT;
708 var[12].flags = 0;
709
710 var[13].val.f = 14.0f;
711 var[13].type = nsXPTType::T_FLOAT;
712 var[13].flags = 0;
713
714 var[14].val.f = 15.0f;
715 var[14].type = nsXPTType::T_FLOAT;
716 var[14].flags = 0;
717
718 var[15].val.f = 16.0f;
719 var[15].type = nsXPTType::T_FLOAT;
720 var[15].flags = 0;
721
722 var[16].val.f = 17.0f;
723 var[16].type = nsXPTType::T_FLOAT;
724 var[16].flags = 0;
725
726 var[17].val.f = 18.0f;
727 var[17].type = nsXPTType::T_FLOAT;
728 var[17].flags = 0;
729
730 var[18].val.f = 19.0f;
731 var[18].type = nsXPTType::T_FLOAT;
732 var[18].flags = 0;
733
734 var[19].val.f = 20.0f;
735 var[19].type = nsXPTType::T_FLOAT;
736 var[19].flags = 0;
737
738 var[20].val.f = 0.0f;
739 var[20].type = nsXPTType::T_FLOAT;
740 var[20].flags = nsXPTCVariant::PTR_IS_DATA;
741 var[20].ptr = &var[20].val.f;
742
743 if(NS_SUCCEEDED(NS_InvokeByIndex(test, 11, 21, var)))
744 printf("\t1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20 = %ff\n",
745 (double) var[20].val.f);
746
747 var[0].val.i64 = 1;
748 var[0].type = nsXPTType::T_I64;
749 var[0].flags = 0;
750
751 var[1].val.i32 = 2;
752 var[1].type = nsXPTType::T_I32;
753 var[1].flags = 0;
754
755 var[2].val.i64 = 3;
756 var[2].type = nsXPTType::T_I64;
757 var[2].flags = 0;
758
759 var[3].val.i32 = 4;
760 var[3].type = nsXPTType::T_I32;
761 var[3].flags = 0;
762
763 var[4].val.i32 = 5;
764 var[4].type = nsXPTType::T_I32;
765 var[4].flags = 0;
766
767 var[5].val.i64 = 6;
768 var[5].type = nsXPTType::T_I64;
769 var[5].flags = 0;
770
771 var[6].val.i32 = 7;
772 var[6].type = nsXPTType::T_I32;
773 var[6].flags = 0;
774
775 var[7].val.i32 = 8;
776 var[7].type = nsXPTType::T_I32;
777 var[7].flags = 0;
778
779 var[8].val.i64 = 9;
780 var[8].type = nsXPTType::T_I64;
781 var[8].flags = 0;
782
783 var[9].val.i32 = 10;
784 var[9].type = nsXPTType::T_I32;
785 var[9].flags = 0;
786
787 var[10].val.i64 = 0;
788 var[10].type = nsXPTType::T_I64;
789 var[10].flags = nsXPTCVariant::PTR_IS_DATA;
790 var[10].ptr = &var[10].val.i64;
791
792 if(NS_SUCCEEDED(NS_InvokeByIndex(test, 12, 11, var)))
793 printf("\t1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 = %d\n",
794 (int)var[10].val.i64);
795 else
796 printf("\tFAILED");
797
798 var[0].val.i32 = 1;
799 var[0].type = nsXPTType::T_I32;
800 var[0].flags = 0;
801
802 var[1].val.i64 = 2;
803 var[1].type = nsXPTType::T_I64;
804 var[1].flags = 0;
805
806 var[2].val.i32 = 3;
807 var[2].type = nsXPTType::T_I32;
808 var[2].flags = 0;
809
810 var[3].val.i64 = 4;
811 var[3].type = nsXPTType::T_I64;
812 var[3].flags = 0;
813
814 var[4].val.i64 = 5;
815 var[4].type = nsXPTType::T_I64;
816 var[4].flags = 0;
817
818 var[5].val.i32 = 6;
819 var[5].type = nsXPTType::T_I32;
820 var[5].flags = 0;
821
822 var[6].val.i64 = 7;
823 var[6].type = nsXPTType::T_I64;
824 var[6].flags = 0;
825
826 var[7].val.i64 = 8;
827 var[7].type = nsXPTType::T_I64;
828 var[7].flags = 0;
829
830 var[8].val.i32 = 9;
831 var[8].type = nsXPTType::T_I32;
832 var[8].flags = 0;
833
834 var[9].val.i64 = 10;
835 var[9].type = nsXPTType::T_I64;
836 var[9].flags = 0;
837
838 var[10].val.i64 = 0;
839 var[10].type = nsXPTType::T_I64;
840 var[10].flags = nsXPTCVariant::PTR_IS_DATA;
841 var[10].ptr = &var[10].val.i64;
842
843 if(NS_SUCCEEDED(NS_InvokeByIndex(test, 13, 11, var)))
844 printf("\t1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 = %d\n",
845 (int)var[10].val.i64);
846 else
847 printf("\tFAILED");
848
849 var[0].val.f = 1.0f;
850 var[0].type = nsXPTType::T_FLOAT;
851 var[0].flags = 0;
852
853 var[1].val.f = 2.0f;
854 var[1].type = nsXPTType::T_FLOAT;
855 var[1].flags = 0;
856
857 var[2].val.d = 3.0;
858 var[2].type = nsXPTType::T_DOUBLE;
859 var[2].flags = 0;
860
861 var[3].val.d = 4.0;
862 var[3].type = nsXPTType::T_DOUBLE;
863 var[3].flags = 0;
864
865 var[4].val.f = 5.0f;
866 var[4].type = nsXPTType::T_FLOAT;
867 var[4].flags = 0;
868
869 var[5].val.f = 6.0f;
870 var[5].type = nsXPTType::T_FLOAT;
871 var[5].flags = 0;
872
873 var[6].val.d = 7.0;
874 var[6].type = nsXPTType::T_DOUBLE;
875 var[6].flags = 0;
876
877 var[7].val.d = 8.0;
878 var[7].type = nsXPTType::T_DOUBLE;
879 var[7].flags = 0;
880
881 var[8].val.f = 9.0f;
882 var[8].type = nsXPTType::T_FLOAT;
883 var[8].flags = 0;
884
885 var[9].val.d = 10.0;
886 var[9].type = nsXPTType::T_DOUBLE;
887 var[9].flags = 0;
888
889 var[10].val.f = 11.0f;
890 var[10].type = nsXPTType::T_FLOAT;
891 var[10].flags = 0;
892
893 var[11].val.d = 0.0;
894 var[11].type = nsXPTType::T_DOUBLE;
895 var[11].flags = nsXPTCVariant::PTR_IS_DATA;
896 var[11].ptr = &var[11].val.d;
897
898 if(NS_SUCCEEDED(NS_InvokeByIndex(test, 14, 12, var)))
899 printf("\t1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 = %f\n",
900 var[11].val.d);
901 else
902 printf("\tFAILED");
903
904 var[0].val.p = (void*)"moo";
905 var[0].type = nsXPTType::T_CHAR_STR;
906 var[0].flags = 0;
907
908 var[1].val.p = (void*)"cow";
909 var[1].type = nsXPTType::T_CHAR_STR;
910 var[1].flags = 0;
911
912 var[2].val.p = 0;
913 var[2].type = nsXPTType::T_CHAR_STR;
914 var[2].flags = nsXPTCVariant::PTR_IS_DATA;
915 var[2].ptr = &var[2].val.p;
916
917 if(NS_SUCCEEDED(NS_InvokeByIndex(test, 15, 3, var)))
918 printf(" = %s\n", static_cast<char*>(var[2].val.p));
919 else
920 printf("\tFAILED");
921
922 var[0].val.i32 = 5;
923 var[0].type = nsXPTType::T_I32;
924 var[0].flags = 0;
925
926 failed_rv = NS_InvokeByIndex(test, 17, 1, var);
927 printf("should fail %s, returned %x\n", failed_rv == NS_ERROR_NULL_POINTER ? "failed" :"passed", failed_rv);
928
929 var[0].val.i64 = 3;
930 var[0].type = nsXPTType::T_I64;
931 var[0].flags = 0;
932
933 var[1].val.i64 = 5;
934 var[1].type = nsXPTType::T_I64;
935 var[1].flags = 0;
936
937 var[2].val.i32 = 7;
938 var[2].type = nsXPTType::T_I32;
939 var[2].flags = 0;
940
941 var[3].val.i64 = 11;
942 var[3].type = nsXPTType::T_I64;
943 var[3].flags = 0;
944
945 var[4].val.i32 = 13;
946 var[4].type = nsXPTType::T_I32;
947 var[4].flags = 0;
948
949 var[5].val.i32 = 17;
950 var[5].type = nsXPTType::T_I32;
951 var[5].flags = 0;
952
953 var[6].val.i64 = 19;
954 var[6].type = nsXPTType::T_I64;
955 var[6].flags = 0;
956
957 var[7].val.i64 = 23;
958 var[7].type = nsXPTType::T_I64;
959 var[7].flags = 0;
960
961 var[8].val.i32 = 29;
962 var[8].type = nsXPTType::T_I32;
963 var[8].flags = 0;
964
965 var[9].val.i64 = 31;
966 var[9].type = nsXPTType::T_I64;
967 var[9].flags = 0;
968
969 var[10].val.i64 = 0;
970 var[10].type = nsXPTType::T_I64;
971 var[10].flags = nsXPTCVariant::PTR_IS_DATA;
972 var[10].ptr = &var[10].val.i64;
973
974 if(NS_SUCCEEDED(NS_InvokeByIndex(test, 16, 11, var)))
975 printf("\t3 + 5 + 7 + 11 + 13 + 17 + 19 + 23 + 29+ 31 = %d\n",
976 (int)var[10].val.i64);
977 else
978 printf("\tFAILED");
979
980 DoMultipleInheritenceTest();
981 DoMultipleInheritenceTest2();
982 // Disabled by default - takes too much time on slow machines
983 //DoSpeedTest();
984
985 return 0;
986 }
987
988 /***************************************************************************/
989 /***************************************************************************/
990 /***************************************************************************/
991
992 // {491C65A0-3317-11d3-9885-006008962422}
993 #define FOO_IID \
994 { 0x491c65a0, 0x3317, 0x11d3, \
995 { 0x98, 0x85, 0x0, 0x60, 0x8, 0x96, 0x24, 0x22 } }
996
997 // {491C65A1-3317-11d3-9885-006008962422}
998 #define BAR_IID \
999 { 0x491c65a1, 0x3317, 0x11d3, \
1000 { 0x98, 0x85, 0x0, 0x60, 0x8, 0x96, 0x24, 0x22 } }
1001
1002 /***************************/
1003
1004 class nsIFoo : public nsISupports
1005 {
1006 public:
1007 NS_DECLARE_STATIC_IID_ACCESSOR(FOO_IID)
1008 NS_IMETHOD FooMethod1(int32_t i) = 0;
1009 NS_IMETHOD FooMethod2(int32_t i) = 0;
1010 };
1011
1012 NS_DEFINE_STATIC_IID_ACCESSOR(nsIFoo, FOO_IID)
1013
1014 class nsIBar : public nsISupports
1015 {
1016 public:
1017 NS_DECLARE_STATIC_IID_ACCESSOR(BAR_IID)
1018 NS_IMETHOD BarMethod1(int32_t i) = 0;
1019 NS_IMETHOD BarMethod2(int32_t i) = 0;
1020 };
1021
1022 NS_DEFINE_STATIC_IID_ACCESSOR(nsIBar, BAR_IID)
1023
1024 /***************************/
1025
1026 class FooImpl : public nsIFoo
1027 {
1028 public:
1029 NS_IMETHOD FooMethod1(int32_t i);
1030 NS_IMETHOD FooMethod2(int32_t i);
1031
1032 FooImpl();
1033
1034 protected:
1035 ~FooImpl() {}
1036
1037 public:
1038 virtual const char* ImplName() = 0;
1039
1040 int SomeData1;
1041 int SomeData2;
1042 const char* Name;
1043 };
1044
1045 class BarImpl : public nsIBar
1046 {
1047 public:
1048 NS_IMETHOD BarMethod1(int32_t i);
1049 NS_IMETHOD BarMethod2(int32_t i);
1050
1051 BarImpl();
1052
1053 protected:
1054 ~BarImpl() {}
1055
1056 public:
1057 virtual const char * ImplName() = 0;
1058
1059 int SomeData1;
1060 int SomeData2;
1061 const char* Name;
1062 };
1063
1064 /***************************/
1065
1066 FooImpl::FooImpl() : Name("FooImpl")
1067 {
1068 }
1069
1070 NS_IMETHODIMP FooImpl::FooMethod1(int32_t i)
1071 {
1072 printf("\tFooImpl::FooMethod1 called with i == %d, %s part of a %s\n",
1073 i, Name, ImplName());
1074 return NS_OK;
1075 }
1076
1077 NS_IMETHODIMP FooImpl::FooMethod2(int32_t i)
1078 {
1079 printf("\tFooImpl::FooMethod2 called with i == %d, %s part of a %s\n",
1080 i, Name, ImplName());
1081 return NS_OK;
1082 }
1083
1084 /***************************/
1085
1086 BarImpl::BarImpl() : Name("BarImpl")
1087 {
1088 }
1089
1090 NS_IMETHODIMP BarImpl::BarMethod1(int32_t i)
1091 {
1092 printf("\tBarImpl::BarMethod1 called with i == %d, %s part of a %s\n",
1093 i, Name, ImplName());
1094 return NS_OK;
1095 }
1096
1097 NS_IMETHODIMP BarImpl::BarMethod2(int32_t i)
1098 {
1099 printf("\tBarImpl::BarMethod2 called with i == %d, %s part of a %s\n",
1100 i, Name, ImplName());
1101 return NS_OK;
1102 }
1103
1104 /***************************/
1105
1106 class FooBarImpl : public FooImpl, public BarImpl
1107 {
1108 public:
1109 NS_DECL_ISUPPORTS
1110
1111 const char* ImplName();
1112
1113 FooBarImpl();
1114
1115 private:
1116 ~FooBarImpl() {}
1117
1118 public:
1119 const char* MyName;
1120 };
1121
1122 FooBarImpl::FooBarImpl() : MyName("FooBarImpl")
1123 {
1124 NS_ADDREF_THIS();
1125 }
1126
1127 const char* FooBarImpl::ImplName()
1128 {
1129 return MyName;
1130 }
1131
1132 NS_IMETHODIMP
1133 FooBarImpl::QueryInterface(REFNSIID aIID, void** aInstancePtr)
1134 {
1135 if (nullptr == aInstancePtr) {
1136 return NS_ERROR_NULL_POINTER;
1137 }
1138
1139 *aInstancePtr = nullptr;
1140
1141
1142 if (aIID.Equals(NS_GET_IID(nsIFoo))) {
1143 *aInstancePtr = (void*) static_cast<nsIFoo*>(this);
1144 NS_ADDREF_THIS();
1145 return NS_OK;
1146 }
1147 if (aIID.Equals(NS_GET_IID(nsIBar))) {
1148 *aInstancePtr = (void*) static_cast<nsIBar*>(this);
1149 NS_ADDREF_THIS();
1150 return NS_OK;
1151 }
1152
1153 if (aIID.Equals(NS_GET_IID(nsISupports))) {
1154 *aInstancePtr = (void*) static_cast<nsISupports*>
1155 (static_cast<nsIFoo*>(this));
1156 NS_ADDREF_THIS();
1157 return NS_OK;
1158 }
1159 return NS_NOINTERFACE;
1160 }
1161
1162 NS_IMPL_ADDREF(FooBarImpl)
1163 NS_IMPL_RELEASE(FooBarImpl)
1164
1165
1166 static void DoMultipleInheritenceTest()
1167 {
1168 FooBarImpl* impl = new FooBarImpl();
1169 if(!impl)
1170 return;
1171
1172 nsIFoo* foo;
1173 nsIBar* bar;
1174
1175 nsXPTCVariant var[1];
1176
1177 printf("\n");
1178 if(NS_SUCCEEDED(impl->QueryInterface(NS_GET_IID(nsIFoo), (void**)&foo)) &&
1179 NS_SUCCEEDED(impl->QueryInterface(NS_GET_IID(nsIBar), (void**)&bar)))
1180 {
1181 printf("impl == %p\n", static_cast<void*>(impl));
1182 printf("foo == %p\n", static_cast<void*>(foo));
1183 printf("bar == %p\n", static_cast<void*>(bar));
1184
1185 printf("Calling Foo...\n");
1186 printf("direct calls:\n");
1187 foo->FooMethod1(1);
1188 foo->FooMethod2(2);
1189
1190 printf("invoke calls:\n");
1191 var[0].val.i32 = 1;
1192 var[0].type = nsXPTType::T_I32;
1193 var[0].flags = 0;
1194 NS_InvokeByIndex(foo, 3, 1, var);
1195
1196 var[0].val.i32 = 2;
1197 var[0].type = nsXPTType::T_I32;
1198 var[0].flags = 0;
1199 NS_InvokeByIndex(foo, 4, 1, var);
1200
1201 printf("\n");
1202
1203 printf("Calling Bar...\n");
1204 printf("direct calls:\n");
1205 bar->BarMethod1(1);
1206 bar->BarMethod2(2);
1207
1208 printf("invoke calls:\n");
1209 var[0].val.i32 = 1;
1210 var[0].type = nsXPTType::T_I32;
1211 var[0].flags = 0;
1212 NS_InvokeByIndex(bar, 3, 1, var);
1213
1214 var[0].val.i32 = 2;
1215 var[0].type = nsXPTType::T_I32;
1216 var[0].flags = 0;
1217 NS_InvokeByIndex(bar, 4, 1, var);
1218
1219 printf("\n");
1220
1221 NS_RELEASE(foo);
1222 NS_RELEASE(bar);
1223 }
1224 NS_RELEASE(impl);
1225 }
1226 /***************************************************************************/
1227 /***************************************************************************/
1228 /***************************************************************************/
1229 /* This is a variation on the theme submitted by duncan@be.com (Duncan Wilcox).
1230 * He was seeing the other test work and this test not work. They should both
1231 * Work on any given platform
1232 */
1233
1234 class nsIFoo2 : public nsISupports
1235 {
1236 public:
1237 NS_IMETHOD FooMethod1(int32_t i) = 0;
1238 NS_IMETHOD FooMethod2(int32_t i) = 0;
1239 };
1240
1241 class nsIBar2 : public nsISupports
1242 {
1243 public:
1244 NS_IMETHOD BarMethod1(int32_t i) = 0;
1245 NS_IMETHOD BarMethod2(int32_t i) = 0;
1246 };
1247
1248 class FooBarImpl2 : public nsIFoo2, public nsIBar2
1249 {
1250 public:
1251 // Foo interface
1252 NS_IMETHOD FooMethod1(int32_t i);
1253 NS_IMETHOD FooMethod2(int32_t i);
1254
1255 // Bar interface
1256 NS_IMETHOD BarMethod1(int32_t i);
1257 NS_IMETHOD BarMethod2(int32_t i);
1258
1259 NS_DECL_ISUPPORTS
1260
1261 FooBarImpl2();
1262
1263 private:
1264 ~FooBarImpl2() {}
1265
1266 public:
1267 int32_t value;
1268 };
1269
1270 FooBarImpl2::FooBarImpl2() : value(0x12345678)
1271 {
1272 NS_ADDREF_THIS();
1273 }
1274
1275 NS_IMETHODIMP FooBarImpl2::FooMethod1(int32_t i)
1276 {
1277 printf("\tFooBarImpl2::FooMethod1 called with i == %d, local value = %x\n",
1278 i, value);
1279 return NS_OK;
1280 }
1281
1282 NS_IMETHODIMP FooBarImpl2::FooMethod2(int32_t i)
1283 {
1284 printf("\tFooBarImpl2::FooMethod2 called with i == %d, local value = %x\n",
1285 i, value);
1286 return NS_OK;
1287 }
1288
1289 NS_IMETHODIMP FooBarImpl2::BarMethod1(int32_t i)
1290 {
1291 printf("\tFooBarImpl2::BarMethod1 called with i == %d, local value = %x\n",
1292 i, value);
1293 return NS_OK;
1294 }
1295
1296 NS_IMETHODIMP FooBarImpl2::BarMethod2(int32_t i)
1297 {
1298 printf("\tFooBarImpl2::BarMethod2 called with i == %d, local value = %x\n",
1299 i, value);
1300 return NS_OK;
1301 }
1302
1303 NS_IMETHODIMP
1304 FooBarImpl2::QueryInterface(REFNSIID aIID, void** aInstancePtr)
1305 {
1306 if (nullptr == aInstancePtr) {
1307 return NS_ERROR_NULL_POINTER;
1308 }
1309
1310 *aInstancePtr = nullptr;
1311
1312
1313 if (aIID.Equals(NS_GET_IID(nsIFoo))) {
1314 *aInstancePtr = (void*) static_cast<nsIFoo2*>(this);
1315 NS_ADDREF_THIS();
1316 return NS_OK;
1317 }
1318 if (aIID.Equals(NS_GET_IID(nsIBar))) {
1319 *aInstancePtr = (void*) static_cast<nsIBar2*>(this);
1320 NS_ADDREF_THIS();
1321 return NS_OK;
1322 }
1323
1324 if (aIID.Equals(NS_GET_IID(nsISupports))) {
1325 *aInstancePtr = (void*) static_cast<nsISupports*>
1326 (static_cast<nsIFoo2*>(this));
1327 NS_ADDREF_THIS();
1328 return NS_OK;
1329 }
1330 return NS_NOINTERFACE;
1331 }
1332
1333 NS_IMPL_ADDREF(FooBarImpl2)
1334 NS_IMPL_RELEASE(FooBarImpl2)
1335
1336 static void DoMultipleInheritenceTest2()
1337 {
1338 FooBarImpl2* impl = new FooBarImpl2();
1339 if(!impl)
1340 return;
1341
1342 nsIFoo2* foo;
1343 nsIBar2* bar;
1344
1345 nsXPTCVariant var[1];
1346
1347 printf("\n");
1348 if(NS_SUCCEEDED(impl->QueryInterface(NS_GET_IID(nsIFoo), (void**)&foo)) &&
1349 NS_SUCCEEDED(impl->QueryInterface(NS_GET_IID(nsIBar), (void**)&bar)))
1350 {
1351 printf("impl == %p\n", static_cast<void*>(impl));
1352 printf("foo == %p\n", static_cast<void*>(foo));
1353 printf("bar == %p\n", static_cast<void*>(bar));
1354
1355 printf("Calling Foo...\n");
1356 printf("direct calls:\n");
1357 foo->FooMethod1(1);
1358 foo->FooMethod2(2);
1359
1360 printf("invoke calls:\n");
1361 var[0].val.i32 = 1;
1362 var[0].type = nsXPTType::T_I32;
1363 var[0].flags = 0;
1364 NS_InvokeByIndex(foo, 3, 1, var);
1365
1366 var[0].val.i32 = 2;
1367 var[0].type = nsXPTType::T_I32;
1368 var[0].flags = 0;
1369 NS_InvokeByIndex(foo, 4, 1, var);
1370
1371 printf("\n");
1372
1373 printf("Calling Bar...\n");
1374 printf("direct calls:\n");
1375 bar->BarMethod1(1);
1376 bar->BarMethod2(2);
1377
1378 printf("invoke calls:\n");
1379 var[0].val.i32 = 1;
1380 var[0].type = nsXPTType::T_I32;
1381 var[0].flags = 0;
1382 NS_InvokeByIndex(bar, 3, 1, var);
1383
1384 var[0].val.i32 = 2;
1385 var[0].type = nsXPTType::T_I32;
1386 var[0].flags = 0;
1387 NS_InvokeByIndex(bar, 4, 1, var);
1388
1389 printf("\n");
1390
1391 NS_RELEASE(foo);
1392 NS_RELEASE(bar);
1393 }
1394 NS_RELEASE(impl);
1395 }
1396
1397 static void DoSpeedTest()
1398 {
1399 InvokeTestTarget *test = new InvokeTestTarget();
1400
1401 nsXPTCVariant var[3];
1402
1403 var[0].val.i32 = 1;
1404 var[0].type = nsXPTType::T_I32;
1405 var[0].flags = 0;
1406
1407 var[1].val.i32 = 1;
1408 var[1].type = nsXPTType::T_I32;
1409 var[1].flags = 0;
1410
1411 var[2].val.i32 = 0;
1412 var[2].type = nsXPTType::T_I32;
1413 var[2].flags = nsXPTCVariant::PTR_IS_DATA;
1414 var[2].ptr = &var[2].val.i32;
1415
1416 int32_t in1 = 1;
1417 int32_t in2 = 1;
1418 int32_t out;
1419
1420 // Crank this number down if your platform is slow :)
1421 static const int count = 100000000;
1422 int i;
1423 PRIntervalTime start;
1424 PRIntervalTime interval_direct;
1425 PRIntervalTime interval_invoke;
1426
1427 printf("Speed test...\n\n");
1428 printf("Doing %d direct call iterations...\n", count);
1429 start = PR_IntervalNow();
1430 for(i = count; i; i--)
1431 (void)test->AddTwoInts(in1, in2, &out);
1432 interval_direct = PR_IntervalNow() - start;
1433
1434 printf("Doing %d invoked call iterations...\n", count);
1435 start = PR_IntervalNow();
1436 for(i = count; i; i--)
1437 (void)NS_InvokeByIndex(test, 3, 3, var);
1438 interval_invoke = PR_IntervalNow() - start;
1439
1440 printf(" direct took %0.2f seconds\n",
1441 (double)interval_direct/(double)PR_TicksPerSecond());
1442 printf(" invoke took %0.2f seconds\n",
1443 (double)interval_invoke/(double)PR_TicksPerSecond());
1444 printf(" So, invoke overhead was ~ %0.2f seconds (~ %0.0f%%)\n",
1445 (double)(interval_invoke-interval_direct)/(double)PR_TicksPerSecond(),
1446 (double)(interval_invoke-interval_direct)/(double)interval_invoke*100);
1447 }

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial