← Back to branch summary

~ubuntu-branches/ubuntu/precise/kompozer/precise

« back to all changes in this revision

Viewing changes to mozilla/xpcom/reflect/xptcall/tests/TestXPTCInvoke.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Anthony Yarusso
  • Date: 2007-08-27 01:11:03 UTC
  • Revision ID: james.westby@ubuntu.com-20070827011103-2jgf4s6532gqu2ka
Tags: upstream-0.7.10
Import upstream version 0.7.10

Show diffs side-by-side

added added

removed removed

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