1 /*
2 * Copyright (C) 2009 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 /*
18 * These are all tests of JNI, but where the JNI calls themselves are
19 * represented as macro invocations. There are both C and C++ files which
20 * include this file. A #if at the top of this file (immediately below)
21 * detects which language is being used and defines macros accordingly.
22 *
23 * This file also defines a static method called runAllTests(), which
24 * does what it says.
25 */
26
27 #ifndef INCLUDED_FROM_WRAPPER
28 #error "This file should only be compiled by including it from a wrapper file."
29 #endif
30
31 #include "helper.h"
32 #include <stdbool.h>
33 #include <stdlib.h>
34 #include <string.h>
35
36
37 /** reference to test class {@code InstanceFromNative} */
38 static jclass InstanceFromNative;
39
40 /** reference to test class {@code StaticFromNative} */
41 static jclass StaticFromNative;
42
43 /** reference to field {@code InstanceFromNative.theOne} */
44 static jfieldID InstanceFromNative_theOne;
45
46 /** reference to string {@code "biscuits"} */
47 static jstring biscuits;
48
49 /**
50 * how to call a method: (virtual, direct, static) x (standard, array of
51 * args, va_list) */
52 typedef enum {
53 VIRTUAL_PLAIN, VIRTUAL_ARRAY, VIRTUAL_VA,
54 DIRECT_PLAIN, DIRECT_ARRAY, DIRECT_VA,
55 STATIC_PLAIN, STATIC_ARRAY, STATIC_VA,
56 } callType;
57
58 /*
59 * CALL() calls the JNI function with the given name, using a JNIEnv
60 * pointer named "env", and passing along any other arguments given.
61 */
62 #ifdef __cplusplus
63 #define CALL(name, args...) env->name(args)
64 #else
65 /*
66 * Note: The space before the comma below is significant with respect to
67 * the processing of the ## operator.
68 */
69 #define CALL(name, args...) (*env)->name(env , ## args)
70 #endif
71
72
73 /**
74 * Simple assert-like macro which returns NULL if the two values are
75 * equal, or an error message if they aren't.
76 */
77 #define FAIL_IF_UNEQUAL(printfType, expected, actual) \
78 ((expected) == (actual)) ? NULL : \
79 failure("expected " printfType " but got " printfType, \
80 expected, actual);
81
82
83 /**
84 * Initializes the static variables. Returns NULL on success or an
85 * error string on failure.
86 */
initializeVariables(JNIEnv * env)87 static char *initializeVariables(JNIEnv *env) {
88 jclass clazz;
89 jfieldID field;
90
91 clazz = CALL(FindClass, "android/jni/cts/StaticFromNative");
92 if (clazz == NULL) {
93 return failure("could not find StaticFromNative");
94 }
95
96 StaticFromNative = (jclass) CALL(NewGlobalRef, clazz);
97
98 clazz = CALL(FindClass, "android/jni/cts/InstanceFromNative");
99 if (clazz == NULL) {
100 return failure("could not find InstanceFromNative");
101 }
102
103 InstanceFromNative = (jclass) CALL(NewGlobalRef, clazz);
104
105 field = CALL(GetStaticFieldID, InstanceFromNative, "theOne",
106 "Landroid/jni/cts/InstanceFromNative;");
107 if (field == NULL) {
108 return failure("could not find InstanceFromNative.theOne");
109 }
110
111 InstanceFromNative_theOne = field;
112
113 biscuits = CALL(NewStringUTF, "biscuits");
114 if (biscuits == NULL) {
115 return failure("could not construct string");
116 }
117
118 biscuits = (jstring) CALL(NewGlobalRef, biscuits);
119
120 return NULL;
121 }
122
123 /**
124 * Gets the standard instance of InstanceFromNative.
125 */
getStandardInstance(JNIEnv * env)126 static jobject getStandardInstance(JNIEnv *env) {
127 return CALL(GetStaticObjectField, InstanceFromNative,
128 InstanceFromNative_theOne);
129 }
130
131 /**
132 * Looks up a static method on StaticFromNative.
133 */
findStaticMethod(JNIEnv * env,char ** errorMsg,const char * name,const char * sig)134 static jmethodID findStaticMethod(JNIEnv *env, char **errorMsg,
135 const char *name, const char *sig) {
136 jmethodID result = CALL(GetStaticMethodID, StaticFromNative,
137 name, sig);
138
139 if (result == NULL) {
140 *errorMsg = failure("could not find static test method %s:%s",
141 name, sig);
142 }
143
144 return result;
145 }
146
147 /**
148 * Looks up an instance method on InstanceFromNative.
149 */
findInstanceMethod(JNIEnv * env,char ** errorMsg,const char * name,const char * sig)150 static jmethodID findInstanceMethod(JNIEnv *env, char **errorMsg,
151 const char *name, const char *sig) {
152 jmethodID result = CALL(GetMethodID, InstanceFromNative, name, sig);
153
154 if (result == NULL) {
155 *errorMsg = failure("could not find instance test method %s:%s",
156 name, sig);
157 }
158
159 return result;
160 }
161
162 /**
163 * Looks up either an instance method on InstanceFromNative or a
164 * static method on StaticFromNative, depending on the given
165 * call type.
166 */
findAppropriateMethod(JNIEnv * env,char ** errorMsg,callType ct,const char * name,const char * sig)167 static jmethodID findAppropriateMethod(JNIEnv *env, char **errorMsg,
168 callType ct, const char *name, const char *sig) {
169 if ((ct == STATIC_PLAIN) || (ct == STATIC_ARRAY) ||
170 (ct == STATIC_VA)) {
171 return findStaticMethod(env, errorMsg, name, sig);
172 } else {
173 return findInstanceMethod(env, errorMsg, name, sig);
174 }
175 }
176
177
178 /*
179 * The tests.
180 */
181
182 // TODO: Missing functions:
183 // AllocObject
184
help_CallBooleanMethod(JNIEnv * env,callType ct,...)185 static char *help_CallBooleanMethod(JNIEnv *env, callType ct, ...) {
186 va_list args;
187 va_start(args, ct);
188
189 char *msg;
190 jobject o = getStandardInstance(env);
191 jmethodID method = findAppropriateMethod(env, &msg, ct,
192 "returnBoolean", "()Z");
193
194 if (method == NULL) {
195 va_end(args);
196 return msg;
197 }
198
199 jboolean result;
200
201 switch (ct) {
202 case VIRTUAL_PLAIN: {
203 result = CALL(CallBooleanMethod, o, method);
204 break;
205 }
206 case VIRTUAL_ARRAY: {
207 result = CALL(CallBooleanMethodA, o, method, NULL);
208 break;
209 }
210 case VIRTUAL_VA: {
211 result = CALL(CallBooleanMethodV, o, method, args);
212 break;
213 }
214 case DIRECT_PLAIN: {
215 result = CALL(CallNonvirtualBooleanMethod, o, InstanceFromNative,
216 method);
217 break;
218 }
219 case DIRECT_ARRAY: {
220 result = CALL(CallNonvirtualBooleanMethodA, o, InstanceFromNative,
221 method, NULL);
222 break;
223 }
224 case DIRECT_VA: {
225 result = CALL(CallNonvirtualBooleanMethodV, o, InstanceFromNative,
226 method, args);
227 break;
228 }
229 case STATIC_PLAIN: {
230 result = CALL(CallStaticBooleanMethod, StaticFromNative, method);
231 break;
232 }
233 case STATIC_ARRAY: {
234 result = CALL(CallStaticBooleanMethodA, StaticFromNative, method,
235 NULL);
236 break;
237 }
238 case STATIC_VA: {
239 result = CALL(CallStaticBooleanMethodV, StaticFromNative, method,
240 args);
241 break;
242 }
243 default: {
244 va_end(args);
245 return failure("shouldn't happen");
246 }
247 }
248
249 va_end(args);
250
251 return FAIL_IF_UNEQUAL("%d", true, result);
252 }
253
TEST_DECLARATION(CallBooleanMethod)254 TEST_DECLARATION(CallBooleanMethod) {
255 return help_CallBooleanMethod(env, VIRTUAL_PLAIN);
256 }
257
TEST_DECLARATION(CallBooleanMethodA)258 TEST_DECLARATION(CallBooleanMethodA) {
259 return help_CallBooleanMethod(env, VIRTUAL_ARRAY);
260 }
261
TEST_DECLARATION(CallBooleanMethodV)262 TEST_DECLARATION(CallBooleanMethodV) {
263 return help_CallBooleanMethod(env, VIRTUAL_VA);
264 }
265
TEST_DECLARATION(CallNonvirtualBooleanMethod)266 TEST_DECLARATION(CallNonvirtualBooleanMethod) {
267 return help_CallBooleanMethod(env, DIRECT_PLAIN);
268 }
269
TEST_DECLARATION(CallNonvirtualBooleanMethodA)270 TEST_DECLARATION(CallNonvirtualBooleanMethodA) {
271 return help_CallBooleanMethod(env, DIRECT_ARRAY);
272 }
273
TEST_DECLARATION(CallNonvirtualBooleanMethodV)274 TEST_DECLARATION(CallNonvirtualBooleanMethodV) {
275 return help_CallBooleanMethod(env, DIRECT_VA);
276 }
277
TEST_DECLARATION(CallStaticBooleanMethod)278 TEST_DECLARATION(CallStaticBooleanMethod) {
279 return help_CallBooleanMethod(env, STATIC_PLAIN);
280 }
281
TEST_DECLARATION(CallStaticBooleanMethodA)282 TEST_DECLARATION(CallStaticBooleanMethodA) {
283 return help_CallBooleanMethod(env, STATIC_ARRAY);
284 }
285
TEST_DECLARATION(CallStaticBooleanMethodV)286 TEST_DECLARATION(CallStaticBooleanMethodV) {
287 return help_CallBooleanMethod(env, STATIC_VA);
288 }
289
help_CallByteMethod(JNIEnv * env,callType ct,...)290 static char *help_CallByteMethod(JNIEnv *env, callType ct, ...) {
291 va_list args;
292 va_start(args, ct);
293
294 char *msg;
295 jobject o = getStandardInstance(env);
296 jmethodID method = findAppropriateMethod(env, &msg, ct,
297 "returnByte", "()B");
298
299 if (method == NULL) {
300 va_end(args);
301 return msg;
302 }
303
304 jbyte result;
305
306 switch (ct) {
307 case VIRTUAL_PLAIN: {
308 result = CALL(CallByteMethod, o, method);
309 break;
310 }
311 case VIRTUAL_ARRAY: {
312 result = CALL(CallByteMethodA, o, method, NULL);
313 break;
314 }
315 case VIRTUAL_VA: {
316 result = CALL(CallByteMethodV, o, method, args);
317 break;
318 }
319 case DIRECT_PLAIN: {
320 result = CALL(CallNonvirtualByteMethod, o, InstanceFromNative,
321 method);
322 break;
323 }
324 case DIRECT_ARRAY: {
325 result = CALL(CallNonvirtualByteMethodA, o, InstanceFromNative,
326 method, NULL);
327 break;
328 }
329 case DIRECT_VA: {
330 result = CALL(CallNonvirtualByteMethodV, o, InstanceFromNative,
331 method, args);
332 break;
333 }
334 case STATIC_PLAIN: {
335 result = CALL(CallStaticByteMethod, StaticFromNative, method);
336 break;
337 }
338 case STATIC_ARRAY: {
339 result = CALL(CallStaticByteMethodA, StaticFromNative, method,
340 NULL);
341 break;
342 }
343 case STATIC_VA: {
344 result = CALL(CallStaticByteMethodV, StaticFromNative, method,
345 args);
346 break;
347 }
348 default: {
349 va_end(args);
350 return failure("shouldn't happen");
351 }
352 }
353
354 va_end(args);
355
356 return FAIL_IF_UNEQUAL("%d", 14, result);
357 }
358
TEST_DECLARATION(CallByteMethod)359 TEST_DECLARATION(CallByteMethod) {
360 return help_CallByteMethod(env, VIRTUAL_PLAIN);
361 }
362
TEST_DECLARATION(CallByteMethodA)363 TEST_DECLARATION(CallByteMethodA) {
364 return help_CallByteMethod(env, VIRTUAL_ARRAY);
365 }
366
TEST_DECLARATION(CallByteMethodV)367 TEST_DECLARATION(CallByteMethodV) {
368 return help_CallByteMethod(env, VIRTUAL_VA);
369 }
370
TEST_DECLARATION(CallNonvirtualByteMethod)371 TEST_DECLARATION(CallNonvirtualByteMethod) {
372 return help_CallByteMethod(env, DIRECT_PLAIN);
373 }
374
TEST_DECLARATION(CallNonvirtualByteMethodA)375 TEST_DECLARATION(CallNonvirtualByteMethodA) {
376 return help_CallByteMethod(env, DIRECT_ARRAY);
377 }
378
TEST_DECLARATION(CallNonvirtualByteMethodV)379 TEST_DECLARATION(CallNonvirtualByteMethodV) {
380 return help_CallByteMethod(env, DIRECT_VA);
381 }
382
TEST_DECLARATION(CallStaticByteMethod)383 TEST_DECLARATION(CallStaticByteMethod) {
384 return help_CallByteMethod(env, STATIC_PLAIN);
385 }
386
TEST_DECLARATION(CallStaticByteMethodA)387 TEST_DECLARATION(CallStaticByteMethodA) {
388 return help_CallByteMethod(env, STATIC_ARRAY);
389 }
390
TEST_DECLARATION(CallStaticByteMethodV)391 TEST_DECLARATION(CallStaticByteMethodV) {
392 return help_CallByteMethod(env, STATIC_VA);
393 }
394
help_CallShortMethod(JNIEnv * env,callType ct,...)395 static char *help_CallShortMethod(JNIEnv *env, callType ct, ...) {
396 va_list args;
397 va_start(args, ct);
398
399 char *msg;
400 jobject o = getStandardInstance(env);
401 jmethodID method = findAppropriateMethod(env, &msg, ct,
402 "returnShort", "()S");
403
404 if (method == NULL) {
405 va_end(args);
406 return msg;
407 }
408
409 jshort result;
410
411 switch (ct) {
412 case VIRTUAL_PLAIN: {
413 result = CALL(CallShortMethod, o, method);
414 break;
415 }
416 case VIRTUAL_ARRAY: {
417 result = CALL(CallShortMethodA, o, method, NULL);
418 break;
419 }
420 case VIRTUAL_VA: {
421 result = CALL(CallShortMethodV, o, method, args);
422 break;
423 }
424 case DIRECT_PLAIN: {
425 result = CALL(CallNonvirtualShortMethod, o, InstanceFromNative,
426 method);
427 break;
428 }
429 case DIRECT_ARRAY: {
430 result = CALL(CallNonvirtualShortMethodA, o, InstanceFromNative,
431 method, NULL);
432 break;
433 }
434 case DIRECT_VA: {
435 result = CALL(CallNonvirtualShortMethodV, o, InstanceFromNative,
436 method, args);
437 break;
438 }
439 case STATIC_PLAIN: {
440 result = CALL(CallStaticShortMethod, StaticFromNative, method);
441 break;
442 }
443 case STATIC_ARRAY: {
444 result = CALL(CallStaticShortMethodA, StaticFromNative, method,
445 NULL);
446 break;
447 }
448 case STATIC_VA: {
449 result = CALL(CallStaticShortMethodV, StaticFromNative, method,
450 args);
451 break;
452 }
453 default: {
454 va_end(args);
455 return failure("shouldn't happen");
456 }
457 }
458
459 va_end(args);
460
461 return FAIL_IF_UNEQUAL("%d", -608, result);
462 }
463
TEST_DECLARATION(CallShortMethod)464 TEST_DECLARATION(CallShortMethod) {
465 return help_CallShortMethod(env, VIRTUAL_PLAIN);
466 }
467
TEST_DECLARATION(CallShortMethodA)468 TEST_DECLARATION(CallShortMethodA) {
469 return help_CallShortMethod(env, VIRTUAL_ARRAY);
470 }
471
TEST_DECLARATION(CallShortMethodV)472 TEST_DECLARATION(CallShortMethodV) {
473 return help_CallShortMethod(env, VIRTUAL_VA);
474 }
475
TEST_DECLARATION(CallNonvirtualShortMethod)476 TEST_DECLARATION(CallNonvirtualShortMethod) {
477 return help_CallShortMethod(env, DIRECT_PLAIN);
478 }
479
TEST_DECLARATION(CallNonvirtualShortMethodA)480 TEST_DECLARATION(CallNonvirtualShortMethodA) {
481 return help_CallShortMethod(env, DIRECT_ARRAY);
482 }
483
TEST_DECLARATION(CallNonvirtualShortMethodV)484 TEST_DECLARATION(CallNonvirtualShortMethodV) {
485 return help_CallShortMethod(env, DIRECT_VA);
486 }
487
TEST_DECLARATION(CallStaticShortMethod)488 TEST_DECLARATION(CallStaticShortMethod) {
489 return help_CallShortMethod(env, STATIC_PLAIN);
490 }
491
TEST_DECLARATION(CallStaticShortMethodA)492 TEST_DECLARATION(CallStaticShortMethodA) {
493 return help_CallShortMethod(env, STATIC_ARRAY);
494 }
495
TEST_DECLARATION(CallStaticShortMethodV)496 TEST_DECLARATION(CallStaticShortMethodV) {
497 return help_CallShortMethod(env, STATIC_VA);
498 }
499
help_CallCharMethod(JNIEnv * env,callType ct,...)500 static char *help_CallCharMethod(JNIEnv *env, callType ct, ...) {
501 va_list args;
502 va_start(args, ct);
503
504 char *msg;
505 jobject o = getStandardInstance(env);
506 jmethodID method = findAppropriateMethod(env, &msg, ct,
507 "returnChar", "()C");
508
509 if (method == NULL) {
510 va_end(args);
511 return msg;
512 }
513
514 jchar result;
515
516 switch (ct) {
517 case VIRTUAL_PLAIN: {
518 result = CALL(CallCharMethod, o, method);
519 break;
520 }
521 case VIRTUAL_ARRAY: {
522 result = CALL(CallCharMethodA, o, method, NULL);
523 break;
524 }
525 case VIRTUAL_VA: {
526 result = CALL(CallCharMethodV, o, method, args);
527 break;
528 }
529 case DIRECT_PLAIN: {
530 result = CALL(CallNonvirtualCharMethod, o, InstanceFromNative,
531 method);
532 break;
533 }
534 case DIRECT_ARRAY: {
535 result = CALL(CallNonvirtualCharMethodA, o, InstanceFromNative,
536 method, NULL);
537 break;
538 }
539 case DIRECT_VA: {
540 result = CALL(CallNonvirtualCharMethodV, o, InstanceFromNative,
541 method, args);
542 break;
543 }
544 case STATIC_PLAIN: {
545 result = CALL(CallStaticCharMethod, StaticFromNative, method);
546 break;
547 }
548 case STATIC_ARRAY: {
549 result = CALL(CallStaticCharMethodA, StaticFromNative, method,
550 NULL);
551 break;
552 }
553 case STATIC_VA: {
554 result = CALL(CallStaticCharMethodV, StaticFromNative, method,
555 args);
556 break;
557 }
558 default: {
559 va_end(args);
560 return failure("shouldn't happen");
561 }
562 }
563
564 va_end(args);
565
566 return FAIL_IF_UNEQUAL("%d", 9000, result);
567 }
568
TEST_DECLARATION(CallCharMethod)569 TEST_DECLARATION(CallCharMethod) {
570 return help_CallCharMethod(env, VIRTUAL_PLAIN);
571 }
572
TEST_DECLARATION(CallCharMethodA)573 TEST_DECLARATION(CallCharMethodA) {
574 return help_CallCharMethod(env, VIRTUAL_ARRAY);
575 }
576
TEST_DECLARATION(CallCharMethodV)577 TEST_DECLARATION(CallCharMethodV) {
578 return help_CallCharMethod(env, VIRTUAL_VA);
579 }
580
TEST_DECLARATION(CallNonvirtualCharMethod)581 TEST_DECLARATION(CallNonvirtualCharMethod) {
582 return help_CallCharMethod(env, DIRECT_PLAIN);
583 }
584
TEST_DECLARATION(CallNonvirtualCharMethodA)585 TEST_DECLARATION(CallNonvirtualCharMethodA) {
586 return help_CallCharMethod(env, DIRECT_ARRAY);
587 }
588
TEST_DECLARATION(CallNonvirtualCharMethodV)589 TEST_DECLARATION(CallNonvirtualCharMethodV) {
590 return help_CallCharMethod(env, DIRECT_VA);
591 }
592
TEST_DECLARATION(CallStaticCharMethod)593 TEST_DECLARATION(CallStaticCharMethod) {
594 return help_CallCharMethod(env, STATIC_PLAIN);
595 }
596
TEST_DECLARATION(CallStaticCharMethodA)597 TEST_DECLARATION(CallStaticCharMethodA) {
598 return help_CallCharMethod(env, STATIC_ARRAY);
599 }
600
TEST_DECLARATION(CallStaticCharMethodV)601 TEST_DECLARATION(CallStaticCharMethodV) {
602 return help_CallCharMethod(env, STATIC_VA);
603 }
604
help_CallIntMethod(JNIEnv * env,callType ct,...)605 static char *help_CallIntMethod(JNIEnv *env, callType ct, ...) {
606 va_list args;
607 va_start(args, ct);
608
609 char *msg;
610 jobject o = getStandardInstance(env);
611 jmethodID method = findAppropriateMethod(env, &msg, ct,
612 "returnInt", "()I");
613
614 if (method == NULL) {
615 va_end(args);
616 return msg;
617 }
618
619 jint result;
620
621 switch (ct) {
622 case VIRTUAL_PLAIN: {
623 result = CALL(CallIntMethod, o, method);
624 break;
625 }
626 case VIRTUAL_ARRAY: {
627 result = CALL(CallIntMethodA, o, method, NULL);
628 break;
629 }
630 case VIRTUAL_VA: {
631 result = CALL(CallIntMethodV, o, method, args);
632 break;
633 }
634 case DIRECT_PLAIN: {
635 result = CALL(CallNonvirtualIntMethod, o, InstanceFromNative,
636 method);
637 break;
638 }
639 case DIRECT_ARRAY: {
640 result = CALL(CallNonvirtualIntMethodA, o, InstanceFromNative,
641 method, NULL);
642 break;
643 }
644 case DIRECT_VA: {
645 result = CALL(CallNonvirtualIntMethodV, o, InstanceFromNative,
646 method, args);
647 break;
648 }
649 case STATIC_PLAIN: {
650 result = CALL(CallStaticIntMethod, StaticFromNative, method);
651 break;
652 }
653 case STATIC_ARRAY: {
654 result = CALL(CallStaticIntMethodA, StaticFromNative, method,
655 NULL);
656 break;
657 }
658 case STATIC_VA: {
659 result = CALL(CallStaticIntMethodV, StaticFromNative, method,
660 args);
661 break;
662 }
663 default: {
664 va_end(args);
665 return failure("shouldn't happen");
666 }
667 }
668
669 va_end(args);
670
671 return FAIL_IF_UNEQUAL("%d", 4004004, result);
672 }
673
TEST_DECLARATION(CallIntMethod)674 TEST_DECLARATION(CallIntMethod) {
675 return help_CallIntMethod(env, VIRTUAL_PLAIN);
676 }
677
TEST_DECLARATION(CallIntMethodA)678 TEST_DECLARATION(CallIntMethodA) {
679 return help_CallIntMethod(env, VIRTUAL_ARRAY);
680 }
681
TEST_DECLARATION(CallIntMethodV)682 TEST_DECLARATION(CallIntMethodV) {
683 return help_CallIntMethod(env, VIRTUAL_VA);
684 }
685
TEST_DECLARATION(CallNonvirtualIntMethod)686 TEST_DECLARATION(CallNonvirtualIntMethod) {
687 return help_CallIntMethod(env, DIRECT_PLAIN);
688 }
689
TEST_DECLARATION(CallNonvirtualIntMethodA)690 TEST_DECLARATION(CallNonvirtualIntMethodA) {
691 return help_CallIntMethod(env, DIRECT_ARRAY);
692 }
693
TEST_DECLARATION(CallNonvirtualIntMethodV)694 TEST_DECLARATION(CallNonvirtualIntMethodV) {
695 return help_CallIntMethod(env, DIRECT_VA);
696 }
697
TEST_DECLARATION(CallStaticIntMethod)698 TEST_DECLARATION(CallStaticIntMethod) {
699 return help_CallIntMethod(env, STATIC_PLAIN);
700 }
701
TEST_DECLARATION(CallStaticIntMethodA)702 TEST_DECLARATION(CallStaticIntMethodA) {
703 return help_CallIntMethod(env, STATIC_ARRAY);
704 }
705
TEST_DECLARATION(CallStaticIntMethodV)706 TEST_DECLARATION(CallStaticIntMethodV) {
707 return help_CallIntMethod(env, STATIC_VA);
708 }
709
help_CallLongMethod(JNIEnv * env,callType ct,...)710 static char *help_CallLongMethod(JNIEnv *env, callType ct, ...) {
711 va_list args;
712 va_start(args, ct);
713
714 char *msg;
715 jobject o = getStandardInstance(env);
716 jmethodID method = findAppropriateMethod(env, &msg, ct,
717 "returnLong", "()J");
718
719 if (method == NULL) {
720 va_end(args);
721 return msg;
722 }
723
724 jlong result;
725
726 switch (ct) {
727 case VIRTUAL_PLAIN: {
728 result = CALL(CallLongMethod, o, method);
729 break;
730 }
731 case VIRTUAL_ARRAY: {
732 result = CALL(CallLongMethodA, o, method, NULL);
733 break;
734 }
735 case VIRTUAL_VA: {
736 result = CALL(CallLongMethodV, o, method, args);
737 break;
738 }
739 case DIRECT_PLAIN: {
740 result = CALL(CallNonvirtualLongMethod, o, InstanceFromNative,
741 method);
742 break;
743 }
744 case DIRECT_ARRAY: {
745 result = CALL(CallNonvirtualLongMethodA, o, InstanceFromNative,
746 method, NULL);
747 break;
748 }
749 case DIRECT_VA: {
750 result = CALL(CallNonvirtualLongMethodV, o, InstanceFromNative,
751 method, args);
752 break;
753 }
754 case STATIC_PLAIN: {
755 result = CALL(CallStaticLongMethod, StaticFromNative, method);
756 break;
757 }
758 case STATIC_ARRAY: {
759 result = CALL(CallStaticLongMethodA, StaticFromNative, method,
760 NULL);
761 break;
762 }
763 case STATIC_VA: {
764 result = CALL(CallStaticLongMethodV, StaticFromNative, method,
765 args);
766 break;
767 }
768 default: {
769 va_end(args);
770 return failure("shouldn't happen");
771 }
772 }
773
774 va_end(args);
775
776 return FAIL_IF_UNEQUAL("%lld", -80080080087LL, result);
777 }
778
TEST_DECLARATION(CallLongMethod)779 TEST_DECLARATION(CallLongMethod) {
780 return help_CallLongMethod(env, VIRTUAL_PLAIN);
781 }
782
TEST_DECLARATION(CallLongMethodA)783 TEST_DECLARATION(CallLongMethodA) {
784 return help_CallLongMethod(env, VIRTUAL_ARRAY);
785 }
786
TEST_DECLARATION(CallLongMethodV)787 TEST_DECLARATION(CallLongMethodV) {
788 return help_CallLongMethod(env, VIRTUAL_VA);
789 }
790
TEST_DECLARATION(CallNonvirtualLongMethod)791 TEST_DECLARATION(CallNonvirtualLongMethod) {
792 return help_CallLongMethod(env, DIRECT_PLAIN);
793 }
794
TEST_DECLARATION(CallNonvirtualLongMethodA)795 TEST_DECLARATION(CallNonvirtualLongMethodA) {
796 return help_CallLongMethod(env, DIRECT_ARRAY);
797 }
798
TEST_DECLARATION(CallNonvirtualLongMethodV)799 TEST_DECLARATION(CallNonvirtualLongMethodV) {
800 return help_CallLongMethod(env, DIRECT_VA);
801 }
802
TEST_DECLARATION(CallStaticLongMethod)803 TEST_DECLARATION(CallStaticLongMethod) {
804 return help_CallLongMethod(env, STATIC_PLAIN);
805 }
806
TEST_DECLARATION(CallStaticLongMethodA)807 TEST_DECLARATION(CallStaticLongMethodA) {
808 return help_CallLongMethod(env, STATIC_ARRAY);
809 }
810
TEST_DECLARATION(CallStaticLongMethodV)811 TEST_DECLARATION(CallStaticLongMethodV) {
812 return help_CallLongMethod(env, STATIC_VA);
813 }
814
help_CallFloatMethod(JNIEnv * env,callType ct,...)815 static char *help_CallFloatMethod(JNIEnv *env, callType ct, ...) {
816 va_list args;
817 va_start(args, ct);
818
819 char *msg;
820 jobject o = getStandardInstance(env);
821 jmethodID method = findAppropriateMethod(env, &msg, ct,
822 "returnFloat", "()F");
823
824 if (method == NULL) {
825 va_end(args);
826 return msg;
827 }
828
829 jfloat result;
830
831 switch (ct) {
832 case VIRTUAL_PLAIN: {
833 result = CALL(CallFloatMethod, o, method);
834 break;
835 }
836 case VIRTUAL_ARRAY: {
837 result = CALL(CallFloatMethodA, o, method, NULL);
838 break;
839 }
840 case VIRTUAL_VA: {
841 result = CALL(CallFloatMethodV, o, method, args);
842 break;
843 }
844 case DIRECT_PLAIN: {
845 result = CALL(CallNonvirtualFloatMethod, o, InstanceFromNative,
846 method);
847 break;
848 }
849 case DIRECT_ARRAY: {
850 result = CALL(CallNonvirtualFloatMethodA, o, InstanceFromNative,
851 method, NULL);
852 break;
853 }
854 case DIRECT_VA: {
855 result = CALL(CallNonvirtualFloatMethodV, o, InstanceFromNative,
856 method, args);
857 break;
858 }
859 case STATIC_PLAIN: {
860 result = CALL(CallStaticFloatMethod, StaticFromNative, method);
861 break;
862 }
863 case STATIC_ARRAY: {
864 result = CALL(CallStaticFloatMethodA, StaticFromNative, method,
865 NULL);
866 break;
867 }
868 case STATIC_VA: {
869 result = CALL(CallStaticFloatMethodV, StaticFromNative, method,
870 args);
871 break;
872 }
873 default: {
874 va_end(args);
875 return failure("shouldn't happen");
876 }
877 }
878
879 va_end(args);
880
881 return FAIL_IF_UNEQUAL("%g", 2.5e22f, result);
882 }
883
TEST_DECLARATION(CallFloatMethod)884 TEST_DECLARATION(CallFloatMethod) {
885 return help_CallFloatMethod(env, VIRTUAL_PLAIN);
886 }
887
TEST_DECLARATION(CallFloatMethodA)888 TEST_DECLARATION(CallFloatMethodA) {
889 return help_CallFloatMethod(env, VIRTUAL_ARRAY);
890 }
891
TEST_DECLARATION(CallFloatMethodV)892 TEST_DECLARATION(CallFloatMethodV) {
893 return help_CallFloatMethod(env, VIRTUAL_VA);
894 }
895
TEST_DECLARATION(CallNonvirtualFloatMethod)896 TEST_DECLARATION(CallNonvirtualFloatMethod) {
897 return help_CallFloatMethod(env, DIRECT_PLAIN);
898 }
899
TEST_DECLARATION(CallNonvirtualFloatMethodA)900 TEST_DECLARATION(CallNonvirtualFloatMethodA) {
901 return help_CallFloatMethod(env, DIRECT_ARRAY);
902 }
903
TEST_DECLARATION(CallNonvirtualFloatMethodV)904 TEST_DECLARATION(CallNonvirtualFloatMethodV) {
905 return help_CallFloatMethod(env, DIRECT_VA);
906 }
907
TEST_DECLARATION(CallStaticFloatMethod)908 TEST_DECLARATION(CallStaticFloatMethod) {
909 return help_CallFloatMethod(env, STATIC_PLAIN);
910 }
911
TEST_DECLARATION(CallStaticFloatMethodA)912 TEST_DECLARATION(CallStaticFloatMethodA) {
913 return help_CallFloatMethod(env, STATIC_ARRAY);
914 }
915
TEST_DECLARATION(CallStaticFloatMethodV)916 TEST_DECLARATION(CallStaticFloatMethodV) {
917 return help_CallFloatMethod(env, STATIC_VA);
918 }
919
help_CallDoubleMethod(JNIEnv * env,callType ct,...)920 static char *help_CallDoubleMethod(JNIEnv *env, callType ct, ...) {
921 va_list args;
922 va_start(args, ct);
923
924 char *msg;
925 jobject o = getStandardInstance(env);
926 jmethodID method = findAppropriateMethod(env, &msg, ct,
927 "returnDouble", "()D");
928
929 if (method == NULL) {
930 va_end(args);
931 return msg;
932 }
933
934 jdouble result;
935
936 switch (ct) {
937 case VIRTUAL_PLAIN: {
938 result = CALL(CallDoubleMethod, o, method);
939 break;
940 }
941 case VIRTUAL_ARRAY: {
942 result = CALL(CallDoubleMethodA, o, method, NULL);
943 break;
944 }
945 case VIRTUAL_VA: {
946 result = CALL(CallDoubleMethodV, o, method, args);
947 break;
948 }
949 case DIRECT_PLAIN: {
950 result = CALL(CallNonvirtualDoubleMethod, o, InstanceFromNative,
951 method);
952 break;
953 }
954 case DIRECT_ARRAY: {
955 result = CALL(CallNonvirtualDoubleMethodA, o, InstanceFromNative,
956 method, NULL);
957 break;
958 }
959 case DIRECT_VA: {
960 result = CALL(CallNonvirtualDoubleMethodV, o, InstanceFromNative,
961 method, args);
962 break;
963 }
964 case STATIC_PLAIN: {
965 result = CALL(CallStaticDoubleMethod, StaticFromNative, method);
966 break;
967 }
968 case STATIC_ARRAY: {
969 result = CALL(CallStaticDoubleMethodA, StaticFromNative, method,
970 NULL);
971 break;
972 }
973 case STATIC_VA: {
974 result = CALL(CallStaticDoubleMethodV, StaticFromNative, method,
975 args);
976 break;
977 }
978 default: {
979 va_end(args);
980 return failure("shouldn't happen");
981 }
982 }
983
984 va_end(args);
985
986 return FAIL_IF_UNEQUAL("%g", 7.503e100, result);
987 }
988
TEST_DECLARATION(CallDoubleMethod)989 TEST_DECLARATION(CallDoubleMethod) {
990 return help_CallDoubleMethod(env, VIRTUAL_PLAIN);
991 }
992
TEST_DECLARATION(CallDoubleMethodA)993 TEST_DECLARATION(CallDoubleMethodA) {
994 return help_CallDoubleMethod(env, VIRTUAL_ARRAY);
995 }
996
TEST_DECLARATION(CallDoubleMethodV)997 TEST_DECLARATION(CallDoubleMethodV) {
998 return help_CallDoubleMethod(env, VIRTUAL_VA);
999 }
1000
TEST_DECLARATION(CallNonvirtualDoubleMethod)1001 TEST_DECLARATION(CallNonvirtualDoubleMethod) {
1002 return help_CallDoubleMethod(env, DIRECT_PLAIN);
1003 }
1004
TEST_DECLARATION(CallNonvirtualDoubleMethodA)1005 TEST_DECLARATION(CallNonvirtualDoubleMethodA) {
1006 return help_CallDoubleMethod(env, DIRECT_ARRAY);
1007 }
1008
TEST_DECLARATION(CallNonvirtualDoubleMethodV)1009 TEST_DECLARATION(CallNonvirtualDoubleMethodV) {
1010 return help_CallDoubleMethod(env, DIRECT_VA);
1011 }
1012
TEST_DECLARATION(CallStaticDoubleMethod)1013 TEST_DECLARATION(CallStaticDoubleMethod) {
1014 return help_CallDoubleMethod(env, STATIC_PLAIN);
1015 }
1016
TEST_DECLARATION(CallStaticDoubleMethodA)1017 TEST_DECLARATION(CallStaticDoubleMethodA) {
1018 return help_CallDoubleMethod(env, STATIC_ARRAY);
1019 }
1020
TEST_DECLARATION(CallStaticDoubleMethodV)1021 TEST_DECLARATION(CallStaticDoubleMethodV) {
1022 return help_CallDoubleMethod(env, STATIC_VA);
1023 }
1024
help_CallVoidMethod(JNIEnv * env,callType ct,...)1025 static char *help_CallVoidMethod(JNIEnv *env, callType ct, ...) {
1026 va_list args;
1027 va_start(args, ct);
1028
1029 char *msg;
1030 jobject o = getStandardInstance(env);
1031 jmethodID method = findAppropriateMethod(env, &msg, ct,
1032 "nop", "()V");
1033
1034 if (method == NULL) {
1035 va_end(args);
1036 return msg;
1037 }
1038
1039 // For these, we simply consider "success" to be "didn't crash."
1040
1041 switch (ct) {
1042 case VIRTUAL_PLAIN: {
1043 CALL(CallVoidMethod, o, method);
1044 break;
1045 }
1046 case VIRTUAL_ARRAY: {
1047 CALL(CallVoidMethodA, o, method, NULL);
1048 break;
1049 }
1050 case VIRTUAL_VA: {
1051 CALL(CallVoidMethodV, o, method, args);
1052 break;
1053 }
1054 case DIRECT_PLAIN: {
1055 CALL(CallNonvirtualVoidMethod, o, InstanceFromNative,
1056 method);
1057 break;
1058 }
1059 case DIRECT_ARRAY: {
1060 CALL(CallNonvirtualVoidMethodA, o, InstanceFromNative,
1061 method, NULL);
1062 break;
1063 }
1064 case DIRECT_VA: {
1065 CALL(CallNonvirtualVoidMethodV, o, InstanceFromNative,
1066 method, args);
1067 break;
1068 }
1069 case STATIC_PLAIN: {
1070 CALL(CallStaticVoidMethod, StaticFromNative, method);
1071 break;
1072 }
1073 case STATIC_ARRAY: {
1074 CALL(CallStaticVoidMethodA, StaticFromNative, method,
1075 NULL);
1076 break;
1077 }
1078 case STATIC_VA: {
1079 CALL(CallStaticVoidMethodV, StaticFromNative, method,
1080 args);
1081 break;
1082 }
1083 default: {
1084 va_end(args);
1085 return failure("shouldn't happen");
1086 }
1087 }
1088
1089 va_end(args);
1090
1091 return NULL;
1092 }
1093
TEST_DECLARATION(CallVoidMethod)1094 TEST_DECLARATION(CallVoidMethod) {
1095 return help_CallVoidMethod(env, VIRTUAL_PLAIN);
1096 }
1097
TEST_DECLARATION(CallVoidMethodA)1098 TEST_DECLARATION(CallVoidMethodA) {
1099 return help_CallVoidMethod(env, VIRTUAL_ARRAY);
1100 }
1101
TEST_DECLARATION(CallVoidMethodV)1102 TEST_DECLARATION(CallVoidMethodV) {
1103 return help_CallVoidMethod(env, VIRTUAL_VA);
1104 }
1105
TEST_DECLARATION(CallNonvirtualVoidMethod)1106 TEST_DECLARATION(CallNonvirtualVoidMethod) {
1107 return help_CallVoidMethod(env, DIRECT_PLAIN);
1108 }
1109
TEST_DECLARATION(CallNonvirtualVoidMethodA)1110 TEST_DECLARATION(CallNonvirtualVoidMethodA) {
1111 return help_CallVoidMethod(env, DIRECT_ARRAY);
1112 }
1113
TEST_DECLARATION(CallNonvirtualVoidMethodV)1114 TEST_DECLARATION(CallNonvirtualVoidMethodV) {
1115 return help_CallVoidMethod(env, DIRECT_VA);
1116 }
1117
TEST_DECLARATION(CallStaticVoidMethod)1118 TEST_DECLARATION(CallStaticVoidMethod) {
1119 return help_CallVoidMethod(env, STATIC_PLAIN);
1120 }
1121
TEST_DECLARATION(CallStaticVoidMethodA)1122 TEST_DECLARATION(CallStaticVoidMethodA) {
1123 return help_CallVoidMethod(env, STATIC_ARRAY);
1124 }
1125
TEST_DECLARATION(CallStaticVoidMethodV)1126 TEST_DECLARATION(CallStaticVoidMethodV) {
1127 return help_CallVoidMethod(env, STATIC_VA);
1128 }
1129
help_CallObjectMethod(JNIEnv * env,callType ct,...)1130 static char *help_CallObjectMethod(JNIEnv *env, callType ct, ...) {
1131 va_list args;
1132 va_start(args, ct);
1133
1134 char *msg;
1135 jobject o = getStandardInstance(env);
1136 jmethodID method = findAppropriateMethod(env, &msg, ct,
1137 "returnString", "()Ljava/lang/String;");
1138
1139 if (method == NULL) {
1140 va_end(args);
1141 return msg;
1142 }
1143
1144 jstring result;
1145
1146 switch (ct) {
1147 case VIRTUAL_PLAIN: {
1148 result = (jstring) CALL(CallObjectMethod, o, method);
1149 break;
1150 }
1151 case VIRTUAL_ARRAY: {
1152 result = (jstring) CALL(CallObjectMethodA, o, method, NULL);
1153 break;
1154 }
1155 case VIRTUAL_VA: {
1156 result = (jstring) CALL(CallObjectMethodV, o, method, args);
1157 break;
1158 }
1159 case DIRECT_PLAIN: {
1160 result = (jstring)
1161 CALL(CallNonvirtualObjectMethod, o, InstanceFromNative,
1162 method);
1163 break;
1164 }
1165 case DIRECT_ARRAY: {
1166 result = (jstring)
1167 CALL(CallNonvirtualObjectMethodA, o, InstanceFromNative,
1168 method, NULL);
1169 break;
1170 }
1171 case DIRECT_VA: {
1172 result = (jstring)
1173 CALL(CallNonvirtualObjectMethodV, o, InstanceFromNative,
1174 method, args);
1175 break;
1176 }
1177 case STATIC_PLAIN: {
1178 result = (jstring)
1179 CALL(CallStaticObjectMethod, StaticFromNative, method);
1180 break;
1181 }
1182 case STATIC_ARRAY: {
1183 result = (jstring)
1184 CALL(CallStaticObjectMethodA, StaticFromNative, method, NULL);
1185 break;
1186 }
1187 case STATIC_VA: {
1188 result = (jstring)
1189 CALL(CallStaticObjectMethodV, StaticFromNative, method, args);
1190 break;
1191 }
1192 default: {
1193 va_end(args);
1194 return failure("shouldn't happen");
1195 }
1196 }
1197
1198 va_end(args);
1199
1200 if (result == NULL) {
1201 return failure("got null from call");
1202 }
1203
1204 const char *utf = CALL(GetStringUTFChars, result, NULL);
1205
1206 if (strcmp(utf, "muffins") == 0) {
1207 msg = NULL;
1208 } else {
1209 msg = failure("unexpected string: %s", utf);
1210 }
1211
1212 CALL(ReleaseStringUTFChars, result, utf);
1213
1214 return msg;
1215 }
1216
TEST_DECLARATION(CallObjectMethod)1217 TEST_DECLARATION(CallObjectMethod) {
1218 return help_CallObjectMethod(env, VIRTUAL_PLAIN);
1219 }
1220
TEST_DECLARATION(CallObjectMethodA)1221 TEST_DECLARATION(CallObjectMethodA) {
1222 return help_CallObjectMethod(env, VIRTUAL_ARRAY);
1223 }
1224
TEST_DECLARATION(CallObjectMethodV)1225 TEST_DECLARATION(CallObjectMethodV) {
1226 return help_CallObjectMethod(env, VIRTUAL_VA);
1227 }
1228
TEST_DECLARATION(CallNonvirtualObjectMethod)1229 TEST_DECLARATION(CallNonvirtualObjectMethod) {
1230 return help_CallObjectMethod(env, DIRECT_PLAIN);
1231 }
1232
TEST_DECLARATION(CallNonvirtualObjectMethodA)1233 TEST_DECLARATION(CallNonvirtualObjectMethodA) {
1234 return help_CallObjectMethod(env, DIRECT_ARRAY);
1235 }
1236
TEST_DECLARATION(CallNonvirtualObjectMethodV)1237 TEST_DECLARATION(CallNonvirtualObjectMethodV) {
1238 return help_CallObjectMethod(env, DIRECT_VA);
1239 }
1240
TEST_DECLARATION(CallStaticObjectMethod)1241 TEST_DECLARATION(CallStaticObjectMethod) {
1242 return help_CallObjectMethod(env, STATIC_PLAIN);
1243 }
1244
TEST_DECLARATION(CallStaticObjectMethodA)1245 TEST_DECLARATION(CallStaticObjectMethodA) {
1246 return help_CallObjectMethod(env, STATIC_ARRAY);
1247 }
1248
TEST_DECLARATION(CallStaticObjectMethodV)1249 TEST_DECLARATION(CallStaticObjectMethodV) {
1250 return help_CallObjectMethod(env, STATIC_VA);
1251 }
1252
help_TakeOneOfEach(JNIEnv * env,callType ct,...)1253 static char *help_TakeOneOfEach(JNIEnv *env, callType ct, ...) {
1254 va_list args;
1255 va_start(args, ct);
1256
1257 char *msg;
1258 jobject o = getStandardInstance(env);
1259 jmethodID method = findAppropriateMethod(env, &msg, ct,
1260 "takeOneOfEach", "(DFJICSBZLjava/lang/String;)Z");
1261
1262 if (method == NULL) {
1263 va_end(args);
1264 return msg;
1265 }
1266
1267 jvalue jargs[] = {
1268 {d: 0.0}, {f: 1.0f}, {j: 2LL}, {i: 3}, {c: 4}, {s: 5}, {b: 6},
1269 {z: true}, {l: biscuits}
1270 };
1271
1272 jboolean result;
1273
1274 switch (ct) {
1275 case VIRTUAL_PLAIN: {
1276 result = CALL(CallBooleanMethod, o, method,
1277 0.0, 1.0f, 2LL, 3, (jchar) 4, (jshort) 5, (jbyte) 6,
1278 (jboolean) true, biscuits);
1279 break;
1280 }
1281 case VIRTUAL_ARRAY: {
1282 result = CALL(CallBooleanMethodA, o, method, jargs);
1283 break;
1284 }
1285 case VIRTUAL_VA: {
1286 result = CALL(CallBooleanMethodV, o, method, args);
1287 break;
1288 }
1289 case DIRECT_PLAIN: {
1290 result = CALL(CallNonvirtualBooleanMethod, o, InstanceFromNative,
1291 method,
1292 0.0, 1.0f, 2LL, 3, (jchar) 4, (jshort) 5, (jbyte) 6,
1293 (jboolean) true, biscuits);
1294 break;
1295 }
1296 case DIRECT_ARRAY: {
1297 result = CALL(CallNonvirtualBooleanMethodA, o, InstanceFromNative,
1298 method, jargs);
1299 break;
1300 }
1301 case DIRECT_VA: {
1302 result = CALL(CallNonvirtualBooleanMethodV, o, InstanceFromNative,
1303 method, args);
1304 break;
1305 }
1306 case STATIC_PLAIN: {
1307 result = CALL(CallStaticBooleanMethod, StaticFromNative, method,
1308 0.0, 1.0f, 2LL, 3, (jchar) 4, (jshort) 5, (jbyte) 6,
1309 (jboolean) true, biscuits);
1310 break;
1311 }
1312 case STATIC_ARRAY: {
1313 result = CALL(CallStaticBooleanMethodA, StaticFromNative, method,
1314 jargs);
1315 break;
1316 }
1317 case STATIC_VA: {
1318 result = CALL(CallStaticBooleanMethodV, StaticFromNative, method,
1319 args);
1320 break;
1321 }
1322 default: {
1323 va_end(args);
1324 return failure("shouldn't happen");
1325 }
1326 }
1327
1328 va_end(args);
1329
1330 return FAIL_IF_UNEQUAL("%d", true, result);
1331 }
1332
TEST_DECLARATION(TakeOneOfEach)1333 TEST_DECLARATION(TakeOneOfEach) {
1334 return help_TakeOneOfEach(env, VIRTUAL_PLAIN);
1335 }
1336
TEST_DECLARATION(TakeOneOfEachA)1337 TEST_DECLARATION(TakeOneOfEachA) {
1338 return help_TakeOneOfEach(env, VIRTUAL_ARRAY);
1339 }
1340
TEST_DECLARATION(TakeOneOfEachV)1341 TEST_DECLARATION(TakeOneOfEachV) {
1342 return help_TakeOneOfEach(env, VIRTUAL_VA,
1343 0.0, 1.0f, 2LL, 3, (jchar) 4, (jshort) 5, (jbyte) 6,
1344 (jboolean) true, biscuits);
1345 }
1346
TEST_DECLARATION(NonvirtualTakeOneOfEach)1347 TEST_DECLARATION(NonvirtualTakeOneOfEach) {
1348 return help_TakeOneOfEach(env, DIRECT_PLAIN);
1349 }
1350
TEST_DECLARATION(NonvirtualTakeOneOfEachA)1351 TEST_DECLARATION(NonvirtualTakeOneOfEachA) {
1352 return help_TakeOneOfEach(env, DIRECT_ARRAY);
1353 }
1354
TEST_DECLARATION(NonvirtualTakeOneOfEachV)1355 TEST_DECLARATION(NonvirtualTakeOneOfEachV) {
1356 return help_TakeOneOfEach(env, DIRECT_VA,
1357 0.0, 1.0f, 2LL, 3, (jchar) 4, (jshort) 5, (jbyte) 6,
1358 (jboolean) true, biscuits);
1359 }
1360
TEST_DECLARATION(StaticTakeOneOfEach)1361 TEST_DECLARATION(StaticTakeOneOfEach) {
1362 return help_TakeOneOfEach(env, STATIC_PLAIN);
1363 }
1364
TEST_DECLARATION(StaticTakeOneOfEachA)1365 TEST_DECLARATION(StaticTakeOneOfEachA) {
1366 return help_TakeOneOfEach(env, STATIC_ARRAY);
1367 }
1368
TEST_DECLARATION(StaticTakeOneOfEachV)1369 TEST_DECLARATION(StaticTakeOneOfEachV) {
1370 return help_TakeOneOfEach(env, STATIC_VA,
1371 0.0, 1.0f, 2LL, 3, (jchar) 4, (jshort) 5, (jbyte) 6,
1372 (jboolean) true, biscuits);
1373 }
1374
help_TakeCoolHandLuke(JNIEnv * env,callType ct,...)1375 static char *help_TakeCoolHandLuke(JNIEnv *env, callType ct, ...) {
1376 va_list args;
1377 va_start(args, ct);
1378
1379 char *msg;
1380 jobject o = getStandardInstance(env);
1381 jmethodID method = findAppropriateMethod(env, &msg, ct,
1382 "takeCoolHandLuke",
1383 "(IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII)Z");
1384
1385 if (method == NULL) {
1386 va_end(args);
1387 return msg;
1388 }
1389
1390 jvalue jargs[] = {
1391 {i: 1}, {i: 2}, {i: 3}, {i: 4},
1392 {i: 5}, {i: 6}, {i: 7}, {i: 8}, {i: 9},
1393 {i: 10}, {i: 11}, {i: 12}, {i: 13}, {i: 14},
1394 {i: 15}, {i: 16}, {i: 17}, {i: 18}, {i: 19},
1395 {i: 20}, {i: 21}, {i: 22}, {i: 23}, {i: 24},
1396 {i: 25}, {i: 26}, {i: 27}, {i: 28}, {i: 29},
1397 {i: 30}, {i: 31}, {i: 32}, {i: 33}, {i: 34},
1398 {i: 35}, {i: 36}, {i: 37}, {i: 38}, {i: 39},
1399 {i: 40}, {i: 41}, {i: 42}, {i: 43}, {i: 44},
1400 {i: 45}, {i: 46}, {i: 47}, {i: 48}, {i: 49},
1401 {i: 50}
1402 };
1403
1404 jboolean result;
1405
1406 switch (ct) {
1407 case VIRTUAL_PLAIN: {
1408 result = CALL(CallBooleanMethod, o, method,
1409 1, 2, 3, 4, 5, 6, 7, 8, 9,
1410 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
1411 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
1412 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
1413 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
1414 50);
1415 break;
1416 }
1417 case VIRTUAL_ARRAY: {
1418 result = CALL(CallBooleanMethodA, o, method, jargs);
1419 break;
1420 }
1421 case VIRTUAL_VA: {
1422 result = CALL(CallBooleanMethodV, o, method, args);
1423 break;
1424 }
1425 case DIRECT_PLAIN: {
1426 result = CALL(CallNonvirtualBooleanMethod, o, InstanceFromNative,
1427 method,
1428 1, 2, 3, 4, 5, 6, 7, 8, 9,
1429 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
1430 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
1431 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
1432 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
1433 50);
1434 break;
1435 }
1436 case DIRECT_ARRAY: {
1437 result = CALL(CallNonvirtualBooleanMethodA, o, InstanceFromNative,
1438 method, jargs);
1439 break;
1440 }
1441 case DIRECT_VA: {
1442 result = CALL(CallNonvirtualBooleanMethodV, o, InstanceFromNative,
1443 method, args);
1444 break;
1445 }
1446 case STATIC_PLAIN: {
1447 result = CALL(CallStaticBooleanMethod, StaticFromNative, method,
1448 1, 2, 3, 4, 5, 6, 7, 8, 9,
1449 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
1450 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
1451 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
1452 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
1453 50);
1454 break;
1455 }
1456 case STATIC_ARRAY: {
1457 result = CALL(CallStaticBooleanMethodA, StaticFromNative, method,
1458 jargs);
1459 break;
1460 }
1461 case STATIC_VA: {
1462 result = CALL(CallStaticBooleanMethodV, StaticFromNative, method,
1463 args);
1464 break;
1465 }
1466 default: {
1467 va_end(args);
1468 return failure("shouldn't happen");
1469 }
1470 }
1471
1472 va_end(args);
1473
1474 return FAIL_IF_UNEQUAL("%d", true, result);
1475 }
1476
TEST_DECLARATION(TakeCoolHandLuke)1477 TEST_DECLARATION(TakeCoolHandLuke) {
1478 return help_TakeCoolHandLuke(env, VIRTUAL_PLAIN);
1479 }
1480
TEST_DECLARATION(TakeCoolHandLukeA)1481 TEST_DECLARATION(TakeCoolHandLukeA) {
1482 return help_TakeCoolHandLuke(env, VIRTUAL_ARRAY);
1483 }
1484
TEST_DECLARATION(TakeCoolHandLukeV)1485 TEST_DECLARATION(TakeCoolHandLukeV) {
1486 return help_TakeCoolHandLuke(env, VIRTUAL_VA,
1487 1, 2, 3, 4, 5, 6, 7, 8, 9,
1488 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
1489 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
1490 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
1491 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
1492 50);
1493 }
1494
TEST_DECLARATION(NonvirtualTakeCoolHandLuke)1495 TEST_DECLARATION(NonvirtualTakeCoolHandLuke) {
1496 return help_TakeCoolHandLuke(env, DIRECT_PLAIN);
1497 }
1498
TEST_DECLARATION(NonvirtualTakeCoolHandLukeA)1499 TEST_DECLARATION(NonvirtualTakeCoolHandLukeA) {
1500 return help_TakeCoolHandLuke(env, DIRECT_ARRAY);
1501 }
1502
TEST_DECLARATION(NonvirtualTakeCoolHandLukeV)1503 TEST_DECLARATION(NonvirtualTakeCoolHandLukeV) {
1504 return help_TakeCoolHandLuke(env, DIRECT_VA,
1505 1, 2, 3, 4, 5, 6, 7, 8, 9,
1506 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
1507 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
1508 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
1509 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
1510 50);
1511 }
1512
TEST_DECLARATION(StaticTakeCoolHandLuke)1513 TEST_DECLARATION(StaticTakeCoolHandLuke) {
1514 return help_TakeCoolHandLuke(env, STATIC_PLAIN);
1515 }
1516
TEST_DECLARATION(StaticTakeCoolHandLukeA)1517 TEST_DECLARATION(StaticTakeCoolHandLukeA) {
1518 return help_TakeCoolHandLuke(env, STATIC_ARRAY);
1519 }
1520
TEST_DECLARATION(StaticTakeCoolHandLukeV)1521 TEST_DECLARATION(StaticTakeCoolHandLukeV) {
1522 return help_TakeCoolHandLuke(env, STATIC_VA,
1523 1, 2, 3, 4, 5, 6, 7, 8, 9,
1524 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
1525 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
1526 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
1527 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
1528 50);
1529 }
1530
TEST_DECLARATION(DefineClass)1531 TEST_DECLARATION(DefineClass) {
1532 // Android implementations should always return NULL.
1533 jclass clazz = CALL(DefineClass, "foo", NULL, NULL, 0);
1534
1535 if (clazz != NULL) {
1536 return failure("Expected NULL but got %p", clazz);
1537 }
1538
1539 return NULL;
1540 }
1541
1542 // TODO: Missing functions:
1543 // DeleteLocalRef
1544 // DeleteWeakGlobalRef
1545 // EnsureLocalCapacity
1546 // ExceptionCheck
1547 // ExceptionClear
1548 // ExceptionDescribe
1549 // ExceptionOccurred
1550 // FatalError (Note: impossible to test in this framework)
1551 // FindClass
1552 // FromReflectedField
1553 // FromReflectedMethod
1554 // GetArrayLength
1555 // GetBooleanArrayElements
1556 // GetBooleanArrayRegion
1557 // GetBooleanField
1558 // GetByteArrayElements
1559 // GetByteArrayRegion
1560 // GetByteField
1561 // GetCharArrayElements
1562 // GetCharArrayRegion
1563 // GetCharField
1564 // GetDirectBufferAddress
1565 // GetDirectBufferCapacity
1566 // GetDoubleArrayElements
1567 // GetDoubleArrayRegion
1568 // GetDoubleField
1569 // GetFieldID
1570 // GetFloatArrayElements
1571 // GetFloatArrayRegion
1572 // GetFloatField
1573 // GetIntArrayElements
1574 // GetIntArrayRegion
1575 // GetIntField
1576 // GetJavaVM
1577 // GetLongArrayElements
1578 // GetLongArrayRegion
1579 // GetLongField
1580 // GetMethodID
1581 // GetObjectArrayElement
1582 // GetObjectClass
1583 // GetObjectField
1584 // GetObjectRefType (since 1.6)
1585 // GetPrimitiveArrayCritical
1586 // GetShortArrayElements
1587 // GetShortArrayRegion
1588 // GetShortField
1589 // GetStaticBooleanField
1590 // GetStaticByteField
1591 // GetStaticCharField
1592 // GetStaticDoubleField
1593 // GetStaticFieldID
1594 // GetStaticFloatField
1595 // GetStaticIntField
1596 // GetStaticLongField
1597 // GetStaticMethodID
1598 // GetStaticObjectField
1599 // GetStaticShortField
1600 // GetStringChars
1601 // GetStringCritical
1602 // GetStringLength
1603 // GetStringRegion
1604 // GetStringUTFChars
1605 // GetStringUTFLength
1606 // GetStringUTFRegion
1607 // GetSuperclass
1608
TEST_DECLARATION(GetVersion)1609 TEST_DECLARATION(GetVersion) {
1610 // Android implementations should all be at version 1.6.
1611 jint version = CALL(GetVersion);
1612
1613 if (version != JNI_VERSION_1_6) {
1614 return failure("Expected JNI_VERSION_1_6 but got 0x%x", version);
1615 }
1616
1617 return NULL;
1618 }
1619
1620 // TODO: Missing functions:
1621 // IsAssignableFrom
1622 // IsInstanceOf
1623 // IsSameObject
1624 // MonitorEnter
1625 // MonitorExit
1626 // NewBooleanArray
1627 // NewByteArray
1628 // NewCharArray
1629 // NewDirectByteBuffer
1630 // NewDoubleArray
1631 // NewFloatArray
1632 // NewGlobalRef
1633 // NewIntArray
1634 // NewLocalRef
1635 // NewLongArray
1636 // NewObject
1637 // NewObjectA
1638 // NewObjectArray
1639 // NewObjectV
1640 // NewShortArray
1641 // NewString
1642 // NewStringUTF
1643 // NewWeakGlobalRef
1644 // PopLocalFrame
1645 // PushLocalFrame
1646 // RegisterNatives
1647 // ReleaseBooleanArrayElements
1648 // ReleaseByteArrayElements
1649 // ReleaseCharArrayElements
1650 // ReleaseDoubleArrayElements
1651 // ReleaseFloatArrayElements
1652 // ReleaseIntArrayElements
1653 // ReleaseLongArrayElements
1654 // ReleasePrimitiveArrayCritical
1655 // ReleaseShortArrayElements
1656 // ReleaseStringChars
1657 // ReleaseStringCritical
1658 // ReleaseStringUTFChars
1659 // SetBooleanArrayRegion
1660 // SetBooleanField
1661 // SetByteArrayRegion
1662 // SetByteField
1663 // SetCharArrayRegion
1664 // SetCharField
1665 // SetDoubleArrayRegion
1666 // SetDoubleField
1667 // SetFloatArrayRegion
1668 // SetFloatField
1669 // SetIntArrayRegion
1670 // SetIntField
1671 // SetLongArrayRegion
1672 // SetLongField
1673 // SetObjectArrayElement
1674 // SetObjectField
1675 // SetShortArrayRegion
1676 // SetShortField
1677 // SetStaticBooleanField
1678 // SetStaticByteField
1679 // SetStaticCharField
1680 // SetStaticDoubleField
1681 // SetStaticFloatField
1682 // SetStaticIntField
1683 // SetStaticLongField
1684 // SetStaticObjectField
1685 // SetStaticShortField
1686 // Throw
1687 // ThrowNew
1688 // ToReflectedField
1689 // ToReflectedMethod
1690 // UnregisterNatives
1691
1692
1693
1694 /**
1695 * Runs all the tests, returning NULL if they all succeeded, or
1696 * a string listing information about all the failures.
1697 */
runAllTests(JNIEnv * env)1698 static jstring runAllTests(JNIEnv *env) {
1699 char *result = initializeVariables(env);
1700
1701 if (CALL(ExceptionOccurred)) {
1702 CALL(ExceptionDescribe);
1703 CALL(ExceptionClear);
1704 }
1705
1706 if (result == NULL) {
1707 result = runJniTests(env,
1708 RUN_TEST(CallBooleanMethod),
1709 RUN_TEST(CallBooleanMethodA),
1710 RUN_TEST(CallBooleanMethodV),
1711 RUN_TEST(CallNonvirtualBooleanMethod),
1712 RUN_TEST(CallNonvirtualBooleanMethodA),
1713 RUN_TEST(CallNonvirtualBooleanMethodV),
1714 RUN_TEST(CallStaticBooleanMethod),
1715 RUN_TEST(CallStaticBooleanMethodA),
1716 RUN_TEST(CallStaticBooleanMethodV),
1717
1718 RUN_TEST(CallByteMethod),
1719 RUN_TEST(CallByteMethodA),
1720 RUN_TEST(CallByteMethodV),
1721 RUN_TEST(CallNonvirtualByteMethod),
1722 RUN_TEST(CallNonvirtualByteMethodA),
1723 RUN_TEST(CallNonvirtualByteMethodV),
1724 RUN_TEST(CallStaticByteMethod),
1725 RUN_TEST(CallStaticByteMethodA),
1726 RUN_TEST(CallStaticByteMethodV),
1727
1728 RUN_TEST(CallShortMethod),
1729 RUN_TEST(CallShortMethodA),
1730 RUN_TEST(CallShortMethodV),
1731 RUN_TEST(CallNonvirtualShortMethod),
1732 RUN_TEST(CallNonvirtualShortMethodA),
1733 RUN_TEST(CallNonvirtualShortMethodV),
1734 RUN_TEST(CallStaticShortMethod),
1735 RUN_TEST(CallStaticShortMethodA),
1736 RUN_TEST(CallStaticShortMethodV),
1737
1738 RUN_TEST(CallCharMethod),
1739 RUN_TEST(CallCharMethodA),
1740 RUN_TEST(CallCharMethodV),
1741 RUN_TEST(CallNonvirtualCharMethod),
1742 RUN_TEST(CallNonvirtualCharMethodA),
1743 RUN_TEST(CallNonvirtualCharMethodV),
1744 RUN_TEST(CallStaticCharMethod),
1745 RUN_TEST(CallStaticCharMethodA),
1746 RUN_TEST(CallStaticCharMethodV),
1747
1748 RUN_TEST(CallIntMethod),
1749 RUN_TEST(CallIntMethodA),
1750 RUN_TEST(CallIntMethodV),
1751 RUN_TEST(CallNonvirtualIntMethod),
1752 RUN_TEST(CallNonvirtualIntMethodA),
1753 RUN_TEST(CallNonvirtualIntMethodV),
1754 RUN_TEST(CallStaticIntMethod),
1755 RUN_TEST(CallStaticIntMethodA),
1756 RUN_TEST(CallStaticIntMethodV),
1757
1758 RUN_TEST(CallLongMethod),
1759 RUN_TEST(CallLongMethodA),
1760 RUN_TEST(CallLongMethodV),
1761 RUN_TEST(CallNonvirtualLongMethod),
1762 RUN_TEST(CallNonvirtualLongMethodA),
1763 RUN_TEST(CallNonvirtualLongMethodV),
1764 RUN_TEST(CallStaticLongMethod),
1765 RUN_TEST(CallStaticLongMethodA),
1766 RUN_TEST(CallStaticLongMethodV),
1767
1768 RUN_TEST(CallFloatMethod),
1769 RUN_TEST(CallFloatMethodA),
1770 RUN_TEST(CallFloatMethodV),
1771 RUN_TEST(CallNonvirtualFloatMethod),
1772 RUN_TEST(CallNonvirtualFloatMethodA),
1773 RUN_TEST(CallNonvirtualFloatMethodV),
1774 RUN_TEST(CallStaticFloatMethod),
1775 RUN_TEST(CallStaticFloatMethodA),
1776 RUN_TEST(CallStaticFloatMethodV),
1777
1778 RUN_TEST(CallDoubleMethod),
1779 RUN_TEST(CallDoubleMethodA),
1780 RUN_TEST(CallDoubleMethodV),
1781 RUN_TEST(CallNonvirtualDoubleMethod),
1782 RUN_TEST(CallNonvirtualDoubleMethodA),
1783 RUN_TEST(CallNonvirtualDoubleMethodV),
1784 RUN_TEST(CallStaticDoubleMethod),
1785 RUN_TEST(CallStaticDoubleMethodA),
1786 RUN_TEST(CallStaticDoubleMethodV),
1787
1788 RUN_TEST(CallVoidMethod),
1789 RUN_TEST(CallVoidMethodA),
1790 RUN_TEST(CallVoidMethodV),
1791 RUN_TEST(CallNonvirtualVoidMethod),
1792 RUN_TEST(CallNonvirtualVoidMethodA),
1793 RUN_TEST(CallNonvirtualVoidMethodV),
1794 RUN_TEST(CallStaticVoidMethod),
1795 RUN_TEST(CallStaticVoidMethodA),
1796 RUN_TEST(CallStaticVoidMethodV),
1797
1798 RUN_TEST(CallObjectMethod),
1799 RUN_TEST(CallObjectMethodA),
1800 RUN_TEST(CallObjectMethodV),
1801 RUN_TEST(CallNonvirtualObjectMethod),
1802 RUN_TEST(CallNonvirtualObjectMethodA),
1803 RUN_TEST(CallNonvirtualObjectMethodV),
1804 RUN_TEST(CallStaticObjectMethod),
1805 RUN_TEST(CallStaticObjectMethodA),
1806 RUN_TEST(CallStaticObjectMethodV),
1807
1808 RUN_TEST(TakeOneOfEach),
1809 RUN_TEST(TakeOneOfEachA),
1810 RUN_TEST(TakeOneOfEachV),
1811 RUN_TEST(NonvirtualTakeOneOfEach),
1812 RUN_TEST(NonvirtualTakeOneOfEachA),
1813 RUN_TEST(NonvirtualTakeOneOfEachV),
1814 RUN_TEST(StaticTakeOneOfEach),
1815 RUN_TEST(StaticTakeOneOfEachA),
1816 RUN_TEST(StaticTakeOneOfEachV),
1817
1818 RUN_TEST(TakeCoolHandLuke),
1819 RUN_TEST(TakeCoolHandLukeA),
1820 RUN_TEST(TakeCoolHandLukeV),
1821 RUN_TEST(NonvirtualTakeCoolHandLuke),
1822 RUN_TEST(NonvirtualTakeCoolHandLukeA),
1823 RUN_TEST(NonvirtualTakeCoolHandLukeV),
1824 RUN_TEST(StaticTakeCoolHandLuke),
1825 RUN_TEST(StaticTakeCoolHandLukeA),
1826 RUN_TEST(StaticTakeCoolHandLukeV),
1827
1828 RUN_TEST(DefineClass),
1829 RUN_TEST(GetVersion),
1830 NULL);
1831
1832 // TODO: Add more tests, above.
1833 }
1834
1835 if (result != NULL) {
1836 jstring s = CALL(NewStringUTF, result);
1837 free(result);
1838 return s;
1839 }
1840
1841 return NULL;
1842 }
1843