?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Bug 470455 - test_database_sync_embed_visits.js leaks, r=sdwilsh
[wine-gecko.git] / extensions / java / xpcom / tests / testparams / TestParams.java
blob81b4e9bafbf3bfebce348822e888e4b3cac9a9e2
1 /* ***** BEGIN LICENSE BLOCK *****
2 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
3 *
4 * The contents of this file are subject to the Mozilla Public License Version
5 * 1.1 (the "License"); you may not use this file except in compliance with
6 * the License. You may obtain a copy of the License at
7 * http://www.mozilla.org/MPL/
8 *
9 * Software distributed under the License is distributed on an "AS IS" basis,
10 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
11 * for the specific language governing rights and limitations under the
12 * License.
13 *
14 * The Original Code is Java XPCOM Bindings.
15 *
16 * The Initial Developer of the Original Code is IBM Corporation.
17 * Portions created by the Initial Developer are Copyright (C) 2007
18 * IBM Corporation. All Rights Reserved.
19 *
20 * Contributor(s):
21 * Javier Pedemonte (jhpedemonte@gmail.com)
22 *
23 * Alternatively, the contents of this file may be used under the terms of
24 * either the GNU General Public License Version 2 or later (the "GPL"), or
25 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
26 * in which case the provisions of the GPL or the LGPL are applicable instead
27 * of those above. If you wish to allow use of your version of this file only
28 * under the terms of either the GPL or the LGPL, and not to allow others to
29 * use your version of this file under the terms of the MPL, indicate your
30 * decision by deleting the provisions above and replace them with the notice
31 * and other provisions required by the GPL or the LGPL. If you do not delete
32 * the provisions above, a recipient may use your version of this file under
33 * the terms of any one of the MPL, the GPL or the LGPL.
34 *
35 * ***** END LICENSE BLOCK ***** */
36
37 import java.io.File;
38 import java.io.FileFilter;
39 import java.io.IOException;
40 import java.io.UnsupportedEncodingException;
41 import java.lang.reflect.InvocationTargetException;
42 import java.lang.reflect.Method;
43 import java.util.Arrays;
44
45 import org.mozilla.interfaces.nsIEcho;
46 import org.mozilla.interfaces.nsIJXTestArrayParams;
47 import org.mozilla.interfaces.nsIJXTestParams;
48 import org.mozilla.interfaces.nsIStackFrame;
49 import org.mozilla.interfaces.nsISupports;
50 import org.mozilla.interfaces.nsITestXPCFunctionCallback;
51 import org.mozilla.interfaces.nsITestXPCSomeUselessThing;
52 import org.mozilla.interfaces.nsIXPCTestArray;
53 import org.mozilla.interfaces.nsIXPCTestIn;
54 import org.mozilla.xpcom.Mozilla;
55 import org.mozilla.xpcom.XPCOMException;
56
57
58 /**
59 * Tests the marshalling and unmarshalling of method parameters using the
60 * XPConnect testcases from mozilla/js/src/xpconnect/tests.
61 */
62 public class TestParams {
63
64 private static File grePath;
65
66 private static String testString = "this is a test string";
67 private static String emptyString = "";
68 private static String utf8String =
69 "Non-Ascii 1 byte chars: Ž‰ŠˆŒ�, 2 byte chars: \u1234 \u1235 \u1236";
70 //private static String sharedString = "a shared string";
71
72
73 /**
74 * @param args 0 - full path to XULRunner binary directory
75 */
76 public static void main(String[] args) {
77 try {
78 checkArgs(args);
79 } catch (IllegalArgumentException e) {
80 System.exit(-1);
81 }
82
83 Mozilla mozilla = Mozilla.getInstance();
84 mozilla.initialize(grePath);
85
86 File profile = null;
87 try {
88 profile = createTempProfileDir();
89 LocationProvider locProvider = new LocationProvider(grePath,
90 profile);
91 mozilla.initEmbedding(grePath, grePath, locProvider);
92 } catch (IOException e) {
93 e.printStackTrace();
94 System.exit(-1);
95 }
96
97 try {
98 runEchoTests();
99
100 runInTests();
101
102 runArrayTests();
103 } catch (Exception e) {
104 e.printStackTrace();
105 System.exit(-1);
106 }
107
108 nsIJXTestParams jstest = (nsIJXTestParams) Mozilla.getInstance()
109 .getComponentManager()
110 .createInstanceByContractID("@mozilla.org/javaxpcom/tests/params;1",
111 null, nsIJXTestParams.NS_IJXTESTPARAMS_IID);
112 try {
113 jstest.runTests(new JavaTests());
114 } catch (XPCOMException e) {
115 e.printStackTrace();
116 System.exit(-1);
117 }
118
119
120 // cleanup
121 mozilla.termEmbedding();
122 deleteDir(profile);
123 }
124
125 private static void checkArgs(String[] args) {
126 if (args.length != 1) {
127 printUsage();
128 throw new IllegalArgumentException();
129 }
130
131 grePath = new File(args[0]);
132 if (!grePath.exists() || !grePath.isDirectory()) {
133 System.err.println("ERROR: given path doesn't exist");
134 printUsage();
135 throw new IllegalArgumentException();
136 }
137 }
138
139 private static void printUsage() {
140 // TODO Auto-generated method stub
141 }
142
143 private static File createTempProfileDir() throws IOException {
144 // Get name of temporary profile directory
145 File profile = File.createTempFile("mozilla-test-", null);
146 profile.delete();
147
148 // On some operating systems (particularly Windows), the previous
149 // temporary profile may not have been deleted. Delete them now.
150 File[] files = profile.getParentFile()
151 .listFiles(new FileFilter() {
152 public boolean accept(File file) {
153 if (file.getName().startsWith("mozilla-test-")) {
154 return true;
155 }
156 return false;
157 }
158 });
159 for (int i = 0; i < files.length; i++) {
160 deleteDir(files[i]);
161 }
162
163 // Create temporary profile directory
164 profile.mkdir();
165
166 return profile;
167 }
168
169 private static void deleteDir(File dir) {
170 File[] files = dir.listFiles();
171 for (int i = 0; i < files.length; i++) {
172 if (files[i].isDirectory()) {
173 deleteDir(files[i]);
174 }
175 files[i].delete();
176 }
177 dir.delete();
178 }
179
180 /**
181 * @param aCallee Object on which to run tests
182 * @param aTests An array of tests to run. The format looks like this:
183 * index 0: method name of test to run
184 * 1: Object array of method arguments
185 * 2: expected result
186 * 3: comment to use when logging test result; if
187 * <code>null</code>, uses method name
188 * @throws RuntimeException if any of the tests fails
189 */
190 private static void runTestsArray(Object aCallee, Object[][] aTests) {
191 boolean succeeded = true;
192 for (int i = 0; i < aTests.length; i++) {
193 Method method = getMethod(aCallee.getClass(), (String) aTests[i][0]);
194
195 String comment = (aTests[i][3] != null) ? (String) aTests[i][3] :
196 (String) aTests[i][0];
197
198 Object result = null;
199 boolean passed = false;
200 try {
201 result = method.invoke(aCallee, (Object[]) aTests[i][1]);
202 if (result != null) {
203 passed = (result.equals(aTests[i][2]));
204 } else {
205 passed = (result == aTests[i][2]);
206 }
207 } catch (Exception e) {
208 succeeded = false;
209 System.err.println("*** TEST " + comment + " threw exception:");
210 e.printStackTrace();
211 logResult(comment, false);
212 continue;
213 }
214
215 logResult(comment, passed);
216
217 if (!passed) {
218 succeeded = false;
219 System.err.println("*** TEST " + comment + " FAILED: expected "
220 + aTests[i][2] + ", returned " + result);
221 }
222 }
223
224 if (!succeeded) {
225 throw new RuntimeException("RunTestsArray did not succeed");
226 }
227 }
228
229 /**
230 * @param aCallee Object on which to run tests
231 * @param aTests An array of tests to run. The format looks like this:
232 * index 0: method name of test to run
233 * 1: Object array of method arguments
234 * 2: comparator method that checks result
235 * 3: comment to use when logging test result; if
236 * <code>null</code>, uses method name
237 * @throws RuntimeException if any of the tests fails
238 */
239 private static void runTestsArrayWithComparator(Object aCallee,
240 Object[][] aTests) {
241 boolean succeeded = true;
242 for (int i = 0; i < aTests.length; i++) {
243 Method method = getMethod(aCallee.getClass(), (String) aTests[i][0]);
244
245 String comment = (aTests[i][3] != null) ? (String) aTests[i][3] :
246 (String) aTests[i][0];
247
248 Object result = null;
249 boolean passed = false;
250 Exception exp = null;
251 Object[] args = (Object[]) aTests[i][1];
252 try {
253 result = method.invoke(aCallee, args);
254 } catch (Exception e) {
255 exp = e;
256 if (exp instanceof InvocationTargetException) {
257 exp = (Exception) ((InvocationTargetException) exp).getCause();
258 }
259 }
260
261 // call comparator method to see if test passed
262 try {
263 IResultComparator r = (IResultComparator) aTests[i][2];
264 passed = r.didPass(args, result, exp);
265 } catch (Exception e) {
266 exp = e;
267 passed = false;
268 }
269
270 logResult(comment, passed);
271
272 if (!passed) {
273 succeeded = false;
274 if (exp != null) {
275 System.err.println("*** TEST " + comment + " threw exception:");
276 exp.printStackTrace();
277 }
278 }
279 }
280
281 if (!succeeded) {
282 throw new RuntimeException("RunTestsArray did not succeed");
283 }
284 }
285
286 private static Method getMethod(Class aClass, String aMethodName) {
287 Method[] methods = aClass.getMethods();
288 for (int i = 0; i < methods.length; i++) {
289 if (methods[i].getName().equals(aMethodName)) {
290 return methods[i];
291 }
292 }
293 return null;
294 }
295
296 private static void logResult(String comment, boolean passed) {
297 System.out.println((passed ? "passed" : "FAILED") + ": " + comment);
298 }
299
300 private static void runEchoTests() {
301 nsIEcho nativeEcho = (nsIEcho) Mozilla.getInstance()
302 .getComponentManager()
303 .createInstanceByContractID("@mozilla.org/javaxpcom/tests/xpc;1",
304 null, nsIEcho.NS_IECHO_IID);
305
306 Object[][] tests = new Object[][] {
307 /* test DOMString */
308 { "in2OutOneDOMString", new Object[] { testString }, testString,
309 "in2OutOneDOMString w/ '" + testString + "'" },
310 { "in2OutOneDOMString", new Object[] { emptyString }, emptyString,
311 "in2OutOneDomString w/ empty string" },
312 { "in2OutOneDOMString", new Object[] { null }, null,
313 "in2OutOneDOMString w/ null value" },
314 /* test AString */
315 { "in2OutOneAString", new Object[] { testString }, testString,
316 "in2OutOneAString w/ '" + testString + "'" },
317 { "in2OutOneAString", new Object[] { emptyString }, emptyString,
318 "in2OutOneAString w/ empty string" },
319 { "in2OutOneAString", new Object[] { utf8String }, utf8String,
320 "in2OutOneAString w/ '" + utf8String + "'" },
321 { "in2OutOneAString", new Object[] { null }, null,
322 "in2OutOneAString w/ null value" },
323 /* test AUTF8String */
324 { "in2OutOneUTF8String", new Object[] { testString }, testString,
325 "in2OutOneUTF8String w/ '" + testString + "'" },
326 { "in2OutOneUTF8String", new Object[] { emptyString }, emptyString,
327 "in2OutOneUTF8String w/ empty string" },
328 { "in2OutOneUTF8String", new Object[] { utf8String }, utf8String,
329 "in2OutOneUTF8String w/ '" + utf8String + "'" },
330 { "in2OutOneUTF8String", new Object[] { null }, null,
331 "in2OutOneUTF8String w/ null value" },
332 /* test ACString */
333 { "in2OutOneCString", new Object[] { testString }, testString,
334 "in2OutOneCString w/ '" + testString + "'" },
335 { "in2OutOneCString", new Object[] { emptyString }, emptyString,
336 "in2OutOneCString w/ empty string" },
337 { "in2OutOneCString", new Object[] { null }, null,
338 "in2OutOneCString w/ null value" },
339 /* test normal strings */
340 { "in2OutOneString", new Object[] { testString }, testString,
341 "in2OutOneString w/ '" + testString + "'" },
342 { "in2OutOneString", new Object[] { emptyString }, emptyString,
343 "in2OutOneString w/ empty string" }
344 };
345
346 runTestsArray(nativeEcho, tests);
347
348 do {
349 Object result = null;
350 boolean passed = false;
351 String comment = "in2OutOneString w/ null value";
352 try {
353 result = nativeEcho.in2OutOneString(null);
354 passed = (result == null);
355 } catch (Exception e) {
356 // Calling nativeEcho.in2OutOneString(null) should throw an
357 // exception, with errorcode == NS_ERROR_FAILURE.
358 if (e instanceof XPCOMException &&
359 ((XPCOMException) e).errorcode == Mozilla.NS_ERROR_FAILURE) {
360 passed = true;
361 }
362
363 if (!passed) {
364 System.err.println("*** TEST " + comment +
365 " threw exception:");
366 e.printStackTrace();
367 logResult(comment, false);
368 continue;
369 }
370 }
371
372 logResult(comment, passed);
373
374 if (!passed) {
375 System.err.println("*** TEST " + comment +
376 " FAILED: expected null, returned " + result);
377 }
378 } while (false);
379
380 tests = new Object[][] {
381 { "setAString", new Object[] { testString }, null,
382 "setAString w/ '" + testString + "'" },
383 { "getAString", null, testString,
384 "getAString w/ '" + testString + "'" },
385 { "setAString", new Object[] { emptyString }, null,
386 "setAString w/ empty string" },
387 { "getAString", null, emptyString,
388 "getAString w/ empty string" },
389 { "setAString", new Object[] { null }, null,
390 "setAString w/ null value" },
391 { "getAString", null, null,
392 "getAString w/ null value" },
393 /* Is the 'shared' attribute even used in scriptable functions?
394 { "sharedString", null, sharedString, null } */
395 };
396
397 runTestsArray(nativeEcho, tests);
398 }
399
400 private static void runInTests() {
401 nsIXPCTestIn nativeInTest = (nsIXPCTestIn) Mozilla.getInstance()
402 .getComponentManager()
403 .createInstanceByContractID("@mozilla.org/javaxpcom/tests/xpc;1",
404 null, nsIXPCTestIn.NS_IXPCTESTIN_IID);
405
406 /* XPConnect converts 64-bit values into doubles when calling into
407 * Javascript. If we use Long.MIN_VALUE or Long.MAX_VALUE, the values
408 * are rounded 'up' when converted to double. Then, when converted back
409 * to a 64-bit integer, the conversion overflows, always resulting in
410 * Long.MIN_VALUE. To workaround that, we just call with very large
411 * values, but ones that won't overflow in conversion.
412 */
413 //Object minLong = new Long(Long.MIN_VALUE);
414 //Object maxLong = new Long(Long.MAX_VALUE);
415 Object minLong = new Long(-9223372036854774784L);
416 Object maxLong = new Long(9223372036854774784L);
417 Object zeroLong = new Long(0);
418 Object negLong = new Long(-1);
419 Object minInt = new Integer(Integer.MIN_VALUE);
420 Object maxInt = new Integer(Integer.MAX_VALUE);
421 Object zeroInt = new Integer(0);
422 Object negInt = new Integer(-1);
423 Object maxUInt = new Long(4294967295L);
424 Object minShort = new Short(Short.MIN_VALUE);
425 Object maxShort = new Short(Short.MAX_VALUE);
426 Object zeroShort = new Short((short) 0);
427 Object negShort = new Short((short) -1);
428 Object maxUShort = new Integer(65535);
429 Object charA = new Character('a');
430 Object charZ = new Character('Z');
431 Object charWide = new Character('\u1234');
432 Object maxUByte = new Short((short) 255);
433 Object minFloat = new Float(Float.MIN_VALUE);
434 Object maxFloat = new Float(Float.MAX_VALUE);
435 Object minDouble = new Double(Double.MIN_VALUE);
436 Object maxDouble = new Double(Double.MAX_VALUE);
437
438 Object[][] tests = new Object[][] {
439 { "echoLong", new Object[] { minInt }, minInt,
440 "echoLong w/ " + minInt },
441 { "echoLong", new Object[] { maxInt }, maxInt,
442 "echoLong w/ " + maxInt },
443 { "echoShort", new Object[] { minShort }, minShort,
444 "echoShort w/ " + minShort },
445 { "echoShort", new Object[] { maxShort }, maxShort,
446 "echoShort w/ " + maxShort },
447 { "echoChar", new Object[] { charA }, charA,
448 "echoChar w/ " + charA },
449 { "echoChar", new Object[] { charZ }, charZ,
450 "echoChar w/ " + charZ },
451 { "echoBoolean", new Object[] { Boolean.FALSE }, Boolean.FALSE,
452 "echoBoolean w/ " + Boolean.FALSE},
453 { "echoBoolean", new Object[] { Boolean.TRUE }, Boolean.TRUE,
454 "echoBoolean w/ " + Boolean.TRUE },
455 { "echoOctet", new Object[] { zeroShort }, zeroShort,
456 "echoOctet w/ zero"},
457 { "echoOctet", new Object[] { maxUByte }, maxUByte,
458 "echoOctet w/ " + maxUByte },
459 { "echoLongLong", new Object[] { minLong }, minLong,
460 "echoLongLong w/ " + minLong },
461 { "echoLongLong", new Object[] { maxLong }, maxLong,
462 "echoLongLong w/ " + maxLong },
463 { "echoUnsignedShort", new Object[] { maxUShort }, maxUShort,
464 "echoUnsignedShort w/ " + maxUShort },
465 { "echoUnsignedShort", new Object[] { zeroInt }, zeroInt,
466 "echoUnsignedShort w/ zero" },
467 // is this test case correct/valid?
468 { "echoUnsignedShort", new Object[] { negInt }, maxUShort,
469 "echoUnsignedShort w/ -1" },
470 { "echoUnsignedLong", new Object[] { maxUInt }, maxUInt,
471 "echoUnsignedLong w/ " + maxUInt },
472 { "echoUnsignedLong", new Object[] { zeroLong }, zeroLong,
473 "echoUnsignedLong w/ zero" },
474 { "echoUnsignedLong", new Object[] { negLong }, maxUInt,
475 "echoUnsignedLong w/ -1" },
476 { "echoFloat", new Object[] { minFloat }, minFloat,
477 "echoFloat w/ " + minFloat },
478 { "echoFloat", new Object[] { maxFloat }, maxFloat,
479 "echoFloat w/ " + maxFloat },
480 { "echoDouble", new Object[] { minDouble }, minDouble,
481 "echoDouble w/ " + minDouble },
482 { "echoDouble", new Object[] { maxDouble }, maxDouble,
483 "echoDouble w/ " + maxDouble },
484 { "echoWchar", new Object[] { charA }, charA,
485 "echoWchar w/ " + charA },
486 { "echoWchar", new Object[] { charZ }, charZ,
487 "echoWchar w/ " + charZ },
488 { "echoWchar", new Object[] { charWide }, charWide,
489 "echoWchar w/ " + charWide },
490 { "echoString", new Object[] { testString }, testString,
491 "echoString w/ '" + testString + "'" },
492 { "echoString", new Object[] { emptyString }, emptyString,
493 "echoString w/ empty string" },
494 { "echoString", new Object[] { utf8String }, utf8String,
495 "echoString w/ '" + utf8String + "'" },
496 { "echoString", new Object[] { null }, null,
497 "echoString w/ null value" },
498 };
499
500 runTestsArray(nativeInTest, tests);
501
502 // Max unsigned long long = 18446744073709551615UL
503 Object maxULong = new Double(1.8446744073709550E19);
504 Object zeroDouble = new Double(0.0);
505
506 tests = new Object[][] {
507 { "echoPRBool", new Object[] { Boolean.FALSE }, Boolean.FALSE,
508 "echoPRBool w/ false" },
509 { "echoPRBool", new Object[] { Boolean.TRUE }, Boolean.TRUE,
510 "echoPRBool w/ true" },
511 { "echoPRInt32", new Object[] { minInt }, minInt,
512 "echoPRInt32 w/ " + minInt },
513 { "echoPRInt32", new Object[] { maxInt }, maxInt,
514 "echoPRInt32 w/ " + maxInt },
515 { "echoPRInt16", new Object[] { minShort }, minShort,
516 "echoPRInt16 w/ " + minShort },
517 { "echoPRInt16", new Object[] { maxShort }, maxShort,
518 "echoPRInt16 w/ " + maxShort },
519 { "echoPRInt64", new Object[] { minLong }, minLong,
520 "echoPRInt64 w/ " + minLong },
521 { "echoPRInt64", new Object[] { maxLong }, maxLong,
522 "echoPRInt64 w/ " + maxLong },
523 { "echoPRUint8", new Object[] { maxUByte }, maxUByte,
524 "echoPRUint8 w/ " + maxUByte },
525 { "echoPRUint8", new Object[] { zeroShort }, zeroShort,
526 "echoPRUint8 w/ zero" },
527 { "echoPRUint8", new Object[] { negShort }, maxUByte,
528 "echoPRUint8 w/ -1" },
529 { "echoPRUint16", new Object[] { maxUShort }, maxUShort,
530 "echoPRUint16 w/ " + maxUShort },
531 { "echoPRUint16", new Object[] { zeroInt }, zeroInt,
532 "echoPRUint16 w/ zero" },
533 { "echoPRUint16", new Object[] { negInt }, maxUShort,
534 "echoPRUint16 w/ -1" },
535 { "echoPRUint32", new Object[] { maxUInt }, maxUInt,
536 "echoPRUint32 w/ " + maxUInt },
537 { "echoPRUint32", new Object[] { zeroLong }, zeroLong,
538 "echoPRUint32 w/ zero" },
539 { "echoPRUint32", new Object[] { negLong }, maxUInt,
540 "echoPRUint32 w/ -1" },
541 { "echoPRUint64", new Object[] { maxULong }, maxULong,
542 "echoPRUint64 w/ " + maxULong },
543 { "echoPRUint64", new Object[] { zeroDouble }, zeroDouble,
544 "echoPRUint64 w/ zero" },
545 /* XXX
546 { "echoPRUint64", new Object[] { negInt }, maxULong,
547 "echoPRUint64 w/ -1" }, */
548 };
549
550 runTestsArray(nativeInTest, tests);
551 }
552
553 private static void runArrayTests() {
554 /*** nsIXPCTestArray ***/
555
556 nsIXPCTestArray xpcArrayTests = (nsIXPCTestArray) Mozilla.getInstance()
557 .getComponentManager()
558 .createInstanceByContractID("@mozilla.org/javaxpcom/tests/xpc;1",
559 null, nsIXPCTestArray.NS_IXPCTESTARRAY_IID);
560
561 boolean succeeded = true;
562
563 final int[][] intArray = { { 1, 2, 3, 4, 0, -1, -2, -3, -4 } };
564 int[][] intArrayCopy = (int[][]) intArray.clone();
565 Integer multiple = new Integer(2);
566
567 final String[][] str = { { "this", "is", "to", "be", "reversed" } };
568 String[][] strCopy = (String[][]) str.clone();
569 long[] count = { strCopy[0].length };
570
571 String[][] strCopy2 = (String[][]) str.clone();
572
573 Object[][] tests = new Object[][] {
574 { "multiplyEachItemInIntegerArray",
575 new Object[] { multiple, new Long(intArrayCopy[0].length), intArrayCopy },
576 new IResultComparator() {
577 public boolean didPass(Object[] args, Object result, Exception e) {
578 if (e != null)
579 return false;
580 int m = ((Integer) args[0]).intValue();
581 int[][] resultArray = (int[][]) args[2];
582 for (int i = 0; i < intArray[0].length; i++) {
583 if (intArray[0][i] * m != resultArray[0][i])
584 return false;
585 }
586 return true;
587 }
588 },
589 null
590 },
591 { "doubleStringArray",
592 new Object[] { count, strCopy },
593 new IResultComparator() {
594 public boolean didPass(Object[] args, Object result, Exception e) {
595 if (e != null)
596 return false;
597 int inLength = str[0].length;
598 int outLength = (int) ((long[]) args[0])[0];
599 if (outLength != inLength * 2)
600 return false;
601
602 String[][] resultArray = (String[][]) args[1];
603 for (int i = 0; i < inLength; i++) {
604 String doubled = doubleString(str[0][i]);
605 if (!doubled.equals(resultArray[0][i*2]) ||
606 !doubled.equals(resultArray[0][i*2+1]))
607 return false;
608 }
609 return true;
610 }
611
612 private String doubleString(String string) {
613 StringBuffer buf = new StringBuffer(string.length()*2);
614 for (int i = 0; i < string.length(); i++) {
615 buf.append(string.charAt(i));
616 buf.append(string.charAt(i));
617 }
618 return buf.toString();
619 }
620 },
621 null
622 },
623 { "reverseStringArray",
624 new Object[] { new Long(strCopy2[0].length), strCopy2 },
625 new IResultComparator() {
626 public boolean didPass(Object[] args, Object result, Exception e) {
627 if (e != null)
628 return false;
629 int length = ((Long) args[0]).intValue();
630 String[][] resultArray = (String[][]) args[1];
631 for (int i = 0; i < length; i++) {
632 if (!str[0][i].equals(resultArray[0][length - 1 - i]))
633 return false;
634 }
635 return true;
636 }
637 },
638 null
639 }
640 };
641
642 runTestsArrayWithComparator(xpcArrayTests, tests);
643
644
645 /*** nsIJXTestArrayParams ***/
646
647 nsIJXTestArrayParams arrayTests = (nsIJXTestArrayParams) xpcArrayTests
648 .queryInterface(nsIJXTestArrayParams.NS_IJXTESTARRAYPARAMS_IID);
649
650 System.arraycopy(intArray[0], 0, intArrayCopy[0], 0, intArray[0].length);
651 int[][] resultArray = new int[1][];
652 IResultComparator copyIntArrayResultComparator = new IResultComparator() {
653 public boolean didPass(Object[] args, Object result, Exception e) {
654 if (e != null)
655 return false;
656 int inLength = ((Long) args[1]).intValue();
657 int[][] resultArray = (int[][]) args[2];
658 for (int i = 0; i < inLength; i++) {
659 if (intArray[0][i] != resultArray[0][i])
660 return false;
661 }
662 return true;
663 }
664 };
665 // for tests that are expected to throw ArrayIndexOutOfBoundsException
666 IResultComparator arrayIOBExpComparator = new IResultComparator() {
667 public boolean didPass(Object[] args, Object result, Exception e) {
668 if (e != null) {
669 if (e instanceof ArrayIndexOutOfBoundsException)
670 return true;
671 }
672 return false;
673 }
674 };
675
676 String[] returnString = new String[1];
677 IResultComparator stringComparator = new IResultComparator() {
678 public boolean didPass(Object[] args, Object result, Exception e) {
679 if (e != null)
680 return false;
681 String inString = (String) args[0];
682 int inLength = ((Long) args[1]).intValue();
683 String[] outString = (String[]) args[2];
684 if (outString[0].length() != inLength)
685 return false;
686 if (!inString.substring(0, inLength).equals(outString[0]))
687 return false;
688 return true;
689 }
690 };
691
692 IResultComparator returnStringComparator = new IResultComparator() {
693 public boolean didPass(Object[] args, Object result, Exception e) {
694 if (e != null)
695 return false;
696 String inString = (String) args[0];
697 int inLength = ((Long) args[1]).intValue();
698 String outString = (String) result;
699 if (outString.length() != inLength)
700 return false;
701 if (!inString.substring(0, inLength).equals(outString))
702 return false;
703 return true;
704 }
705 };
706
707 byte[] testBytes = null;
708 byte[][] returnBytes = new byte[1][];
709 try {
710 testBytes = utf8String.getBytes("UTF-8");
711 } catch (UnsupportedEncodingException e1) {
712 e1.printStackTrace();
713 }
714
715 tests = new Object[][] {
716 { "multiplyEachItemInIntegerArray2",
717 new Object[] { multiple, intArrayCopy, new Long(intArrayCopy[0].length) },
718 new IResultComparator() {
719 public boolean didPass(Object[] args, Object result, Exception e) {
720 if (e != null)
721 return false;
722 int m = ((Integer) args[0]).intValue();
723 int[][] resultArray = (int[][]) args[1];
724 for (int i = 0; i < intArray[0].length; i++) {
725 if (intArray[0][i] * m != resultArray[0][i])
726 return false;
727 }
728 return true;
729 }
730 },
731 null
732 },
733 { "copyIntArray",
734 new Object[] { intArray[0], new Long(intArray[0].length), resultArray },
735 copyIntArrayResultComparator,
736 null
737 },
738 { "copyIntArray",
739 new Object[] { intArray[0], new Long(intArray[0].length - 2), resultArray },
740 copyIntArrayResultComparator,
741 "copyIntArray w/ smaller count"
742 },
743 { "copyIntArray",
744 new Object[] { intArray[0], new Long(intArray[0].length + 2), resultArray },
745 arrayIOBExpComparator,
746 "copyIntArray w/ larger count"
747 },
748 { "returnIntArray",
749 new Object[] { intArray[0], new Long(intArray[0].length) },
750 new IResultComparator() {
751 public boolean didPass(Object[] args, Object result, Exception e) {
752 if (e != null)
753 return false;
754 int[] inputArray = (int[]) args[0];
755 int[] resultArray = (int[]) result;
756 return Arrays.equals(resultArray, inputArray);
757 }
758 },
759 null
760 },
761 { "returnIntArray",
762 new Object[] { intArray[0], new Long(intArray[0].length - 2) },
763 new IResultComparator() {
764 public boolean didPass(Object[] args, Object result, Exception e) {
765 if (e != null)
766 return false;
767 int[] inputArray = (int[]) args[0];
768 int inLength = ((Long) args[1]).intValue();
769 int[] resultArray = (int[]) result;
770 if (resultArray.length != inLength)
771 return false;
772
773 for (int i = 0; i < inLength; i++) {
774 if (resultArray[i] != inputArray[i])
775 return false;
776 }
777 return true;
778 }
779 },
780 "returnIntArray w/ smaller count"
781 },
782 { "returnIntArray",
783 new Object[] { intArray[0], new Long(intArray[0].length + 2) },
784 arrayIOBExpComparator,
785 "returnIntArray w/ larger count"
786 },
787 { "copyByteArray",
788 new Object[] { testBytes, new Long(testBytes.length), returnBytes },
789 new IResultComparator() {
790 public boolean didPass(Object[] args, Object result,
791 Exception e) {
792 if (e != null)
793 return false;
794 byte[] inArray = (byte[]) args[0];
795 byte[][] outArray = (byte[][]) args[2];
796 return Arrays.equals(inArray, outArray[0]);
797 }
798 },
799 null
800 },
801 { "returnByteArray",
802 new Object[] { testBytes, new Long(testBytes.length) },
803 new IResultComparator() {
804 public boolean didPass(Object[] args, Object result,
805 Exception e) {
806 if (e != null)
807 return false;
808 byte[] inArray = (byte[]) args[0];
809 byte[] outArray = (byte[]) result;
810 return Arrays.equals(inArray, outArray);
811 }
812 },
813 null
814 },
815 { "copySizedString",
816 new Object[] { testString, new Long(testString.length()), returnString },
817 stringComparator,
818 null
819 },
820 { "returnSizedString",
821 new Object[] { testString, new Long(testString.length()) },
822 returnStringComparator,
823 null
824 },
825 { "copySizedWString",
826 new Object[] { utf8String, new Long(utf8String.length()), returnString },
827 stringComparator,
828 null
829 },
830 { "returnSizedWString",
831 new Object[] { utf8String, new Long(utf8String.length()) },
832 returnStringComparator,
833 null
834 },
835 };
836
837 runTestsArrayWithComparator(arrayTests, tests);
838
839 if (!succeeded) {
840 throw new RuntimeException("Array tests did not succeed");
841 }
842 }
843
844 }
845
846 class JavaTests implements nsIEcho, nsIXPCTestIn {
847
848 private nsIEcho receiver;
849 private String savedString;
850 private Object[] results = new Object[8];
851
852 /* nsISupports */
853
854 public nsISupports queryInterface(String aIID) {
855 return Mozilla.queryInterface(this, aIID);
856 }
857
858 /* nsIEcho */
859
860 public void callFunction(nsITestXPCFunctionCallback callback, String s) {
861 throw new XPCOMException(Mozilla.NS_ERROR_NOT_IMPLEMENTED);
862 }
863
864 public void callFunctionWithThis(nsITestXPCFunctionCallback callback,
865 nsISupports self, String s) {
866 throw new XPCOMException(Mozilla.NS_ERROR_NOT_IMPLEMENTED);
867 }
868
869 public void callReceiverSometimeLater() {
870 throw new XPCOMException(Mozilla.NS_ERROR_NOT_IMPLEMENTED);
871 }
872
873 public void debugDumpJSStack() {
874 throw new XPCOMException(Mozilla.NS_ERROR_NOT_IMPLEMENTED);
875 }
876
877 public String echoIn2OutOneAString(String input) {
878 if (receiver != null) {
879 return receiver.echoIn2OutOneAString(input);
880 }
881 return in2OutOneAString(input);
882 }
883
884 public String echoIn2OutOneCString(String input) {
885 if (receiver != null) {
886 return receiver.echoIn2OutOneCString(input);
887 }
888 return in2OutOneCString(input);
889 }
890
891 public String echoIn2OutOneDOMString(String input) {
892 if (receiver != null) {
893 return receiver.echoIn2OutOneDOMString(input);
894 }
895 return in2OutOneDOMString(input);
896 }
897
898 public String echoIn2OutOneUTF8String(String input) {
899 if (receiver != null) {
900 return receiver.echoIn2OutOneUTF8String(input);
901 }
902 return in2OutOneUTF8String(input);
903 }
904
905 public void failInJSTest(int fail) {
906 throw new XPCOMException(Mozilla.NS_ERROR_NOT_IMPLEMENTED);
907 }
908
909 public String getAString() {
910 return savedString;
911 }
912
913 public int getSomeValue() {
914 throw new XPCOMException(Mozilla.NS_ERROR_NOT_IMPLEMENTED);
915 }
916
917 public nsIStackFrame getStack() {
918 throw new XPCOMException(Mozilla.NS_ERROR_NOT_IMPLEMENTED);
919 }
920
921 public short getThrowInGetter() {
922 throw new XPCOMException(Mozilla.NS_ERROR_NOT_IMPLEMENTED);
923 }
924
925 public int in2OutAddTwoInts(int input1, int input2, int[] output1,
926 int[] output2) {
927 throw new XPCOMException(Mozilla.NS_ERROR_NOT_IMPLEMENTED);
928 }
929
930 public String in2OutOneAString(String input) {
931 if (input != null)
932 return new String(input);
933 return null;
934 }
935
936 public String in2OutOneCString(String input) {
937 if (input != null)
938 return new String(input);
939 return null;
940 }
941
942 public String in2OutOneDOMString(String input) {
943 if (input != null)
944 return new String(input);
945 return null;
946 }
947
948 public int in2OutOneInt(int input) {
949 throw new XPCOMException(Mozilla.NS_ERROR_NOT_IMPLEMENTED);
950 }
951
952 public String in2OutOneString(String input) {
953 if (input != null)
954 return new String(input);
955 return null;
956 }
957
958 public String in2OutOneUTF8String(String input) {
959 if (input != null)
960 return new String(input);
961 return null;
962 }
963
964 public void methodWithForwardDeclaredParam(nsITestXPCSomeUselessThing sut) {
965 throw new XPCOMException(Mozilla.NS_ERROR_NOT_IMPLEMENTED);
966 }
967
968 public void printArgTypes() {
969 throw new XPCOMException(Mozilla.NS_ERROR_NOT_IMPLEMENTED);
970 }
971
972 public nsISupports pseudoQueryInterface(String uuid) {
973 throw new XPCOMException(Mozilla.NS_ERROR_NOT_IMPLEMENTED);
974 }
975
976 public void returnCode(int code) {
977 throw new XPCOMException(Mozilla.NS_ERROR_NOT_IMPLEMENTED);
978 }
979
980 public void returnCode_NS_ERROR_NULL_POINTER() {
981 throw new XPCOMException(Mozilla.NS_ERROR_NOT_IMPLEMENTED);
982 }
983
984 public void returnCode_NS_ERROR_OUT_OF_MEMORY() {
985 throw new XPCOMException(Mozilla.NS_ERROR_NOT_IMPLEMENTED);
986 }
987
988 public void returnCode_NS_ERROR_UNEXPECTED() {
989 throw new XPCOMException(Mozilla.NS_ERROR_NOT_IMPLEMENTED);
990 }
991
992 public void returnCode_NS_OK() {
993 throw new XPCOMException(Mozilla.NS_ERROR_NOT_IMPLEMENTED);
994 }
995
996 public nsISupports returnInterface(nsISupports obj) {
997 throw new XPCOMException(Mozilla.NS_ERROR_NOT_IMPLEMENTED);
998 }
999
1000 public void sendInOutManyTypes(short[] p1, short[] p2, int[] p3, long[] p4,
1001 short[] p5, int[] p6, long[] p7, double[] p8, float[] p9,
1002 double[] p10, boolean[] p11, char[] p12, char[] p13, String[] p14,
1003 String[] p15, String[] p16) {
1004 throw new XPCOMException(Mozilla.NS_ERROR_NOT_IMPLEMENTED);
1005 }
1006
1007 public void sendManyTypes(short p1, short p2, int p3, long p4, short p5,
1008 int p6, long p7, double p8, float p9, double p10, boolean p11,
1009 char p12, char p13, String p14, String p15, String p16) {
1010 throw new XPCOMException(Mozilla.NS_ERROR_NOT_IMPLEMENTED);
1011 }
1012
1013 public void sendOneString(String str) {
1014 if (receiver != null) {
1015 receiver.sendOneString(str);
1016 }
1017 results[0] = str;
1018 }
1019
1020 public void setAString(String aAString) {
1021 savedString = aAString;
1022 }
1023
1024 public void setReceiver(nsIEcho aReceiver) {
1025 System.out.println("Setting receiver to nsIEcho impl = " + aReceiver);
1026 receiver = aReceiver;
1027 }
1028
1029 public void setReceiverReturnOldReceiver(nsIEcho[] aReceiver) {
1030 throw new XPCOMException(Mozilla.NS_ERROR_NOT_IMPLEMENTED);
1031 }
1032
1033 public void setSomeValue(int aSomeValue) {
1034 throw new XPCOMException(Mozilla.NS_ERROR_NOT_IMPLEMENTED);
1035 }
1036
1037 public String sharedString() {
1038 throw new XPCOMException(Mozilla.NS_ERROR_NOT_IMPLEMENTED);
1039 }
1040
1041 public void simpleCallNoEcho() {
1042 throw new XPCOMException(Mozilla.NS_ERROR_NOT_IMPLEMENTED);
1043 }
1044
1045 public void throwArg() {
1046 throw new XPCOMException(Mozilla.NS_ERROR_NOT_IMPLEMENTED);
1047 }
1048
1049 /* nsIXPCTestIn */
1050
1051 public boolean echoBoolean(boolean b) {
1052 return b;
1053 }
1054
1055 public char echoChar(char c) {
1056 return c;
1057 }
1058
1059 public double echoDouble(double d) {
1060 return d;
1061 }
1062
1063 public float echoFloat(float f) {
1064 return f;
1065 }
1066
1067 public int echoLong(int l) {
1068 return l;
1069 }
1070
1071 public long echoLongLong(long ll) {
1072 return ll;
1073 }
1074
1075 public short echoOctet(short o) {
1076 return o;
1077 }
1078
1079 public boolean echoPRBool(boolean b) {
1080 return b;
1081 }
1082
1083 public short echoPRInt16(short l) {
1084 return l;
1085 }
1086
1087 public int echoPRInt32(int l) {
1088 return l;
1089 }
1090
1091 public long echoPRInt64(long i) {
1092 return i;
1093 }
1094
1095 public int echoPRUint16(int i) {
1096 return i;
1097 }
1098
1099 public long echoPRUint32(long i) {
1100 return i;
1101 }
1102
1103 public long echoPRUint32_2(long i) {
1104 return i;
1105 }
1106
1107 public double echoPRUint64(double i) {
1108 return i;
1109 }
1110
1111 public short echoPRUint8(short i) {
1112 return i;
1113 }
1114
1115 public short echoShort(short a) {
1116 return a;
1117 }
1118
1119 public String echoString(String ws) {
1120 return ws;
1121
1122 }
1123 public long echoUnsignedLong(long ul) {
1124 return ul;
1125 }
1126
1127 public int echoUnsignedShort(int us) {
1128 return us;
1129 }
1130
1131 public void echoVoid() {
1132 }
1133
1134 public char echoWchar(char wc) {
1135 return wc;
1136 }
1137
1138 public void copyIntArray(int[] srcArray, long count, int[][] dstArray) {
1139 System.arraycopy(srcArray, 0, dstArray[0], 0, (int) count);
1140 }
1141
1142 public void copySizedString(String srcString, long count, String[] dstString) {
1143 dstString[0] = srcString.substring(0, (int) count);
1144 }
1145
1146 public void multiplyEachItemInIntegerArray2(int val, int[][] valueArray,
1147 long count) {
1148 for(int i = 0; i < count; i++) {
1149 valueArray[0][i] *= val;
1150 }
1151 }
1152
1153 public int[] returnIntArray(int[] srcArray, long count) {
1154 int[] array = new int[(int) count];
1155 System.arraycopy(srcArray, 0, array, 0, (int) count);
1156 return array;
1157 }
1158
1159 public String returnSizedString(String srcString, long count) {
1160 return srcString.substring(0, (int) count);
1161 }
1162
1163 }
1164
1165 interface IResultComparator {
1166
1167 boolean didPass(Object[] args, Object result, Exception e);
1168
1169 }
Wine Gecko package