| /* |
| * Copyright (C) 2009 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /* |
| * These are all tests of JNI, but where the JNI calls themselves are |
| * represented as macro invocations. There are both C and C++ files which |
| * include this file. A #if at the top of this file (immediately below) |
| * detects which language is being used and defines macros accordingly. |
| * |
| * This file also defines a static method called runAllTests(), which |
| * does what it says. |
| */ |
| |
| #ifndef INCLUDED_FROM_WRAPPER |
| #error "This file should only be compiled by including it from a wrapper file." |
| #endif |
| |
| #include "helper.h" |
| #include <stdbool.h> |
| #include <stdlib.h> |
| #include <string.h> |
| |
| |
| /** reference to test class {@code InstanceFromNative} */ |
| static jclass InstanceFromNative; |
| |
| /** reference to test class {@code StaticFromNative} */ |
| static jclass StaticFromNative; |
| |
| /** reference to field {@code InstanceFromNative.theOne} */ |
| static jfieldID InstanceFromNative_theOne; |
| |
| /** reference to string {@code "biscuits"} */ |
| static jstring biscuits; |
| |
| /** |
| * how to call a method: (virtual, direct, static) x (standard, array of |
| * args, va_list) */ |
| typedef enum { |
| VIRTUAL_PLAIN, VIRTUAL_ARRAY, VIRTUAL_VA, |
| DIRECT_PLAIN, DIRECT_ARRAY, DIRECT_VA, |
| STATIC_PLAIN, STATIC_ARRAY, STATIC_VA, |
| } callType; |
| |
| /* |
| * CALL() calls the JNI function with the given name, using a JNIEnv |
| * pointer named "env", and passing along any other arguments given. |
| */ |
| #ifdef __cplusplus |
| #define CALL(name, args...) env->name(args) |
| #else |
| /* |
| * Note: The space before the comma below is significant with respect to |
| * the processing of the ## operator. |
| */ |
| #define CALL(name, args...) (*env)->name(env , ## args) |
| #endif |
| |
| |
| /** |
| * Simple assert-like macro which returns NULL if the two values are |
| * equal, or an error message if they aren't. |
| */ |
| #define FAIL_IF_UNEQUAL(printfType, expected, actual) \ |
| ((expected) == (actual)) ? NULL : \ |
| failure("expected " printfType " but got " printfType, \ |
| expected, actual); |
| |
| |
| /** |
| * Initializes the static variables. Returns NULL on success or an |
| * error string on failure. |
| */ |
| static char *initializeVariables(JNIEnv *env) { |
| jclass clazz; |
| jfieldID field; |
| |
| clazz = CALL(FindClass, "android/jni/cts/StaticFromNative"); |
| if (clazz == NULL) { |
| return failure("could not find StaticFromNative"); |
| } |
| |
| StaticFromNative = (jclass) CALL(NewGlobalRef, clazz); |
| |
| clazz = CALL(FindClass, "android/jni/cts/InstanceFromNative"); |
| if (clazz == NULL) { |
| return failure("could not find InstanceFromNative"); |
| } |
| |
| InstanceFromNative = (jclass) CALL(NewGlobalRef, clazz); |
| |
| field = CALL(GetStaticFieldID, InstanceFromNative, "theOne", |
| "Landroid/jni/cts/InstanceFromNative;"); |
| if (field == NULL) { |
| return failure("could not find InstanceFromNative.theOne"); |
| } |
| |
| InstanceFromNative_theOne = field; |
| |
| biscuits = CALL(NewStringUTF, "biscuits"); |
| if (biscuits == NULL) { |
| return failure("could not construct string"); |
| } |
| |
| biscuits = (jstring) CALL(NewGlobalRef, biscuits); |
| |
| return NULL; |
| } |
| |
| /** |
| * Gets the standard instance of InstanceFromNative. |
| */ |
| static jobject getStandardInstance(JNIEnv *env) { |
| return CALL(GetStaticObjectField, InstanceFromNative, |
| InstanceFromNative_theOne); |
| } |
| |
| /** |
| * Looks up a static method on StaticFromNative. |
| */ |
| static jmethodID findStaticMethod(JNIEnv *env, char **errorMsg, |
| const char *name, const char *sig) { |
| jmethodID result = CALL(GetStaticMethodID, StaticFromNative, |
| name, sig); |
| |
| if (result == NULL) { |
| *errorMsg = failure("could not find static test method %s:%s", |
| name, sig); |
| } |
| |
| return result; |
| } |
| |
| /** |
| * Looks up an instance method on InstanceFromNative. |
| */ |
| static jmethodID findInstanceMethod(JNIEnv *env, char **errorMsg, |
| const char *name, const char *sig) { |
| jmethodID result = CALL(GetMethodID, InstanceFromNative, name, sig); |
| |
| if (result == NULL) { |
| *errorMsg = failure("could not find instance test method %s:%s", |
| name, sig); |
| } |
| |
| return result; |
| } |
| |
| /** |
| * Looks up either an instance method on InstanceFromNative or a |
| * static method on StaticFromNative, depending on the given |
| * call type. |
| */ |
| static jmethodID findAppropriateMethod(JNIEnv *env, char **errorMsg, |
| callType ct, const char *name, const char *sig) { |
| if ((ct == STATIC_PLAIN) || (ct == STATIC_ARRAY) || |
| (ct == STATIC_VA)) { |
| return findStaticMethod(env, errorMsg, name, sig); |
| } else { |
| return findInstanceMethod(env, errorMsg, name, sig); |
| } |
| } |
| |
| |
| /* |
| * The tests. |
| */ |
| |
| // TODO: Missing functions: |
| // AllocObject |
| |
| static char *help_CallBooleanMethod(JNIEnv *env, int ct, ...) { |
| va_list args; |
| va_start(args, ct); |
| |
| char *msg; |
| jobject o = getStandardInstance(env); |
| jmethodID method = findAppropriateMethod(env, &msg, (callType)ct, |
| "returnBoolean", "()Z"); |
| |
| if (method == NULL) { |
| va_end(args); |
| return msg; |
| } |
| |
| jboolean result; |
| |
| switch (ct) { |
| case VIRTUAL_PLAIN: { |
| result = CALL(CallBooleanMethod, o, method); |
| break; |
| } |
| case VIRTUAL_ARRAY: { |
| result = CALL(CallBooleanMethodA, o, method, NULL); |
| break; |
| } |
| case VIRTUAL_VA: { |
| result = CALL(CallBooleanMethodV, o, method, args); |
| break; |
| } |
| case DIRECT_PLAIN: { |
| result = CALL(CallNonvirtualBooleanMethod, o, InstanceFromNative, |
| method); |
| break; |
| } |
| case DIRECT_ARRAY: { |
| result = CALL(CallNonvirtualBooleanMethodA, o, InstanceFromNative, |
| method, NULL); |
| break; |
| } |
| case DIRECT_VA: { |
| result = CALL(CallNonvirtualBooleanMethodV, o, InstanceFromNative, |
| method, args); |
| break; |
| } |
| case STATIC_PLAIN: { |
| result = CALL(CallStaticBooleanMethod, StaticFromNative, method); |
| break; |
| } |
| case STATIC_ARRAY: { |
| result = CALL(CallStaticBooleanMethodA, StaticFromNative, method, |
| NULL); |
| break; |
| } |
| case STATIC_VA: { |
| result = CALL(CallStaticBooleanMethodV, StaticFromNative, method, |
| args); |
| break; |
| } |
| default: { |
| va_end(args); |
| return failure("shouldn't happen"); |
| } |
| } |
| |
| va_end(args); |
| |
| return FAIL_IF_UNEQUAL("%d", true, result); |
| } |
| |
| TEST_DECLARATION(CallBooleanMethod) { |
| return help_CallBooleanMethod(env, VIRTUAL_PLAIN); |
| } |
| |
| TEST_DECLARATION(CallBooleanMethodA) { |
| return help_CallBooleanMethod(env, VIRTUAL_ARRAY); |
| } |
| |
| TEST_DECLARATION(CallBooleanMethodV) { |
| return help_CallBooleanMethod(env, VIRTUAL_VA); |
| } |
| |
| TEST_DECLARATION(CallNonvirtualBooleanMethod) { |
| return help_CallBooleanMethod(env, DIRECT_PLAIN); |
| } |
| |
| TEST_DECLARATION(CallNonvirtualBooleanMethodA) { |
| return help_CallBooleanMethod(env, DIRECT_ARRAY); |
| } |
| |
| TEST_DECLARATION(CallNonvirtualBooleanMethodV) { |
| return help_CallBooleanMethod(env, DIRECT_VA); |
| } |
| |
| TEST_DECLARATION(CallStaticBooleanMethod) { |
| return help_CallBooleanMethod(env, STATIC_PLAIN); |
| } |
| |
| TEST_DECLARATION(CallStaticBooleanMethodA) { |
| return help_CallBooleanMethod(env, STATIC_ARRAY); |
| } |
| |
| TEST_DECLARATION(CallStaticBooleanMethodV) { |
| return help_CallBooleanMethod(env, STATIC_VA); |
| } |
| |
| static char *help_CallByteMethod(JNIEnv *env, int ct, ...) { |
| va_list args; |
| va_start(args, ct); |
| |
| char *msg; |
| jobject o = getStandardInstance(env); |
| jmethodID method = findAppropriateMethod(env, &msg, (callType)ct, |
| "returnByte", "()B"); |
| |
| if (method == NULL) { |
| va_end(args); |
| return msg; |
| } |
| |
| jbyte result; |
| |
| switch (ct) { |
| case VIRTUAL_PLAIN: { |
| result = CALL(CallByteMethod, o, method); |
| break; |
| } |
| case VIRTUAL_ARRAY: { |
| result = CALL(CallByteMethodA, o, method, NULL); |
| break; |
| } |
| case VIRTUAL_VA: { |
| result = CALL(CallByteMethodV, o, method, args); |
| break; |
| } |
| case DIRECT_PLAIN: { |
| result = CALL(CallNonvirtualByteMethod, o, InstanceFromNative, |
| method); |
| break; |
| } |
| case DIRECT_ARRAY: { |
| result = CALL(CallNonvirtualByteMethodA, o, InstanceFromNative, |
| method, NULL); |
| break; |
| } |
| case DIRECT_VA: { |
| result = CALL(CallNonvirtualByteMethodV, o, InstanceFromNative, |
| method, args); |
| break; |
| } |
| case STATIC_PLAIN: { |
| result = CALL(CallStaticByteMethod, StaticFromNative, method); |
| break; |
| } |
| case STATIC_ARRAY: { |
| result = CALL(CallStaticByteMethodA, StaticFromNative, method, |
| NULL); |
| break; |
| } |
| case STATIC_VA: { |
| result = CALL(CallStaticByteMethodV, StaticFromNative, method, |
| args); |
| break; |
| } |
| default: { |
| va_end(args); |
| return failure("shouldn't happen"); |
| } |
| } |
| |
| va_end(args); |
| |
| return FAIL_IF_UNEQUAL("%d", 14, result); |
| } |
| |
| TEST_DECLARATION(CallByteMethod) { |
| return help_CallByteMethod(env, VIRTUAL_PLAIN); |
| } |
| |
| TEST_DECLARATION(CallByteMethodA) { |
| return help_CallByteMethod(env, VIRTUAL_ARRAY); |
| } |
| |
| TEST_DECLARATION(CallByteMethodV) { |
| return help_CallByteMethod(env, VIRTUAL_VA); |
| } |
| |
| TEST_DECLARATION(CallNonvirtualByteMethod) { |
| return help_CallByteMethod(env, DIRECT_PLAIN); |
| } |
| |
| TEST_DECLARATION(CallNonvirtualByteMethodA) { |
| return help_CallByteMethod(env, DIRECT_ARRAY); |
| } |
| |
| TEST_DECLARATION(CallNonvirtualByteMethodV) { |
| return help_CallByteMethod(env, DIRECT_VA); |
| } |
| |
| TEST_DECLARATION(CallStaticByteMethod) { |
| return help_CallByteMethod(env, STATIC_PLAIN); |
| } |
| |
| TEST_DECLARATION(CallStaticByteMethodA) { |
| return help_CallByteMethod(env, STATIC_ARRAY); |
| } |
| |
| TEST_DECLARATION(CallStaticByteMethodV) { |
| return help_CallByteMethod(env, STATIC_VA); |
| } |
| |
| static char *help_CallShortMethod(JNIEnv *env, int ct, ...) { |
| va_list args; |
| va_start(args, ct); |
| |
| char *msg; |
| jobject o = getStandardInstance(env); |
| jmethodID method = findAppropriateMethod(env, &msg, (callType)ct, |
| "returnShort", "()S"); |
| |
| if (method == NULL) { |
| va_end(args); |
| return msg; |
| } |
| |
| jshort result; |
| |
| switch (ct) { |
| case VIRTUAL_PLAIN: { |
| result = CALL(CallShortMethod, o, method); |
| break; |
| } |
| case VIRTUAL_ARRAY: { |
| result = CALL(CallShortMethodA, o, method, NULL); |
| break; |
| } |
| case VIRTUAL_VA: { |
| result = CALL(CallShortMethodV, o, method, args); |
| break; |
| } |
| case DIRECT_PLAIN: { |
| result = CALL(CallNonvirtualShortMethod, o, InstanceFromNative, |
| method); |
| break; |
| } |
| case DIRECT_ARRAY: { |
| result = CALL(CallNonvirtualShortMethodA, o, InstanceFromNative, |
| method, NULL); |
| break; |
| } |
| case DIRECT_VA: { |
| result = CALL(CallNonvirtualShortMethodV, o, InstanceFromNative, |
| method, args); |
| break; |
| } |
| case STATIC_PLAIN: { |
| result = CALL(CallStaticShortMethod, StaticFromNative, method); |
| break; |
| } |
| case STATIC_ARRAY: { |
| result = CALL(CallStaticShortMethodA, StaticFromNative, method, |
| NULL); |
| break; |
| } |
| case STATIC_VA: { |
| result = CALL(CallStaticShortMethodV, StaticFromNative, method, |
| args); |
| break; |
| } |
| default: { |
| va_end(args); |
| return failure("shouldn't happen"); |
| } |
| } |
| |
| va_end(args); |
| |
| return FAIL_IF_UNEQUAL("%d", -608, result); |
| } |
| |
| TEST_DECLARATION(CallShortMethod) { |
| return help_CallShortMethod(env, VIRTUAL_PLAIN); |
| } |
| |
| TEST_DECLARATION(CallShortMethodA) { |
| return help_CallShortMethod(env, VIRTUAL_ARRAY); |
| } |
| |
| TEST_DECLARATION(CallShortMethodV) { |
| return help_CallShortMethod(env, VIRTUAL_VA); |
| } |
| |
| TEST_DECLARATION(CallNonvirtualShortMethod) { |
| return help_CallShortMethod(env, DIRECT_PLAIN); |
| } |
| |
| TEST_DECLARATION(CallNonvirtualShortMethodA) { |
| return help_CallShortMethod(env, DIRECT_ARRAY); |
| } |
| |
| TEST_DECLARATION(CallNonvirtualShortMethodV) { |
| return help_CallShortMethod(env, DIRECT_VA); |
| } |
| |
| TEST_DECLARATION(CallStaticShortMethod) { |
| return help_CallShortMethod(env, STATIC_PLAIN); |
| } |
| |
| TEST_DECLARATION(CallStaticShortMethodA) { |
| return help_CallShortMethod(env, STATIC_ARRAY); |
| } |
| |
| TEST_DECLARATION(CallStaticShortMethodV) { |
| return help_CallShortMethod(env, STATIC_VA); |
| } |
| |
| static char *help_CallCharMethod(JNIEnv *env, int ct, ...) { |
| va_list args; |
| va_start(args, ct); |
| |
| char *msg; |
| jobject o = getStandardInstance(env); |
| jmethodID method = findAppropriateMethod(env, &msg, (callType)ct, |
| "returnChar", "()C"); |
| |
| if (method == NULL) { |
| va_end(args); |
| return msg; |
| } |
| |
| jchar result; |
| |
| switch (ct) { |
| case VIRTUAL_PLAIN: { |
| result = CALL(CallCharMethod, o, method); |
| break; |
| } |
| case VIRTUAL_ARRAY: { |
| result = CALL(CallCharMethodA, o, method, NULL); |
| break; |
| } |
| case VIRTUAL_VA: { |
| result = CALL(CallCharMethodV, o, method, args); |
| break; |
| } |
| case DIRECT_PLAIN: { |
| result = CALL(CallNonvirtualCharMethod, o, InstanceFromNative, |
| method); |
| break; |
| } |
| case DIRECT_ARRAY: { |
| result = CALL(CallNonvirtualCharMethodA, o, InstanceFromNative, |
| method, NULL); |
| break; |
| } |
| case DIRECT_VA: { |
| result = CALL(CallNonvirtualCharMethodV, o, InstanceFromNative, |
| method, args); |
| break; |
| } |
| case STATIC_PLAIN: { |
| result = CALL(CallStaticCharMethod, StaticFromNative, method); |
| break; |
| } |
| case STATIC_ARRAY: { |
| result = CALL(CallStaticCharMethodA, StaticFromNative, method, |
| NULL); |
| break; |
| } |
| case STATIC_VA: { |
| result = CALL(CallStaticCharMethodV, StaticFromNative, method, |
| args); |
| break; |
| } |
| default: { |
| va_end(args); |
| return failure("shouldn't happen"); |
| } |
| } |
| |
| va_end(args); |
| |
| return FAIL_IF_UNEQUAL("%d", 9000, result); |
| } |
| |
| TEST_DECLARATION(CallCharMethod) { |
| return help_CallCharMethod(env, VIRTUAL_PLAIN); |
| } |
| |
| TEST_DECLARATION(CallCharMethodA) { |
| return help_CallCharMethod(env, VIRTUAL_ARRAY); |
| } |
| |
| TEST_DECLARATION(CallCharMethodV) { |
| return help_CallCharMethod(env, VIRTUAL_VA); |
| } |
| |
| TEST_DECLARATION(CallNonvirtualCharMethod) { |
| return help_CallCharMethod(env, DIRECT_PLAIN); |
| } |
| |
| TEST_DECLARATION(CallNonvirtualCharMethodA) { |
| return help_CallCharMethod(env, DIRECT_ARRAY); |
| } |
| |
| TEST_DECLARATION(CallNonvirtualCharMethodV) { |
| return help_CallCharMethod(env, DIRECT_VA); |
| } |
| |
| TEST_DECLARATION(CallStaticCharMethod) { |
| return help_CallCharMethod(env, STATIC_PLAIN); |
| } |
| |
| TEST_DECLARATION(CallStaticCharMethodA) { |
| return help_CallCharMethod(env, STATIC_ARRAY); |
| } |
| |
| TEST_DECLARATION(CallStaticCharMethodV) { |
| return help_CallCharMethod(env, STATIC_VA); |
| } |
| |
| static char *help_CallIntMethod(JNIEnv *env, int ct, ...) { |
| va_list args; |
| va_start(args, ct); |
| |
| char *msg; |
| jobject o = getStandardInstance(env); |
| jmethodID method = findAppropriateMethod(env, &msg, (callType)ct, |
| "returnInt", "()I"); |
| |
| if (method == NULL) { |
| va_end(args); |
| return msg; |
| } |
| |
| jint result; |
| |
| switch (ct) { |
| case VIRTUAL_PLAIN: { |
| result = CALL(CallIntMethod, o, method); |
| break; |
| } |
| case VIRTUAL_ARRAY: { |
| result = CALL(CallIntMethodA, o, method, NULL); |
| break; |
| } |
| case VIRTUAL_VA: { |
| result = CALL(CallIntMethodV, o, method, args); |
| break; |
| } |
| case DIRECT_PLAIN: { |
| result = CALL(CallNonvirtualIntMethod, o, InstanceFromNative, |
| method); |
| break; |
| } |
| case DIRECT_ARRAY: { |
| result = CALL(CallNonvirtualIntMethodA, o, InstanceFromNative, |
| method, NULL); |
| break; |
| } |
| case DIRECT_VA: { |
| result = CALL(CallNonvirtualIntMethodV, o, InstanceFromNative, |
| method, args); |
| break; |
| } |
| case STATIC_PLAIN: { |
| result = CALL(CallStaticIntMethod, StaticFromNative, method); |
| break; |
| } |
| case STATIC_ARRAY: { |
| result = CALL(CallStaticIntMethodA, StaticFromNative, method, |
| NULL); |
| break; |
| } |
| case STATIC_VA: { |
| result = CALL(CallStaticIntMethodV, StaticFromNative, method, |
| args); |
| break; |
| } |
| default: { |
| va_end(args); |
| return failure("shouldn't happen"); |
| } |
| } |
| |
| va_end(args); |
| |
| return FAIL_IF_UNEQUAL("%d", 4004004, result); |
| } |
| |
| TEST_DECLARATION(CallIntMethod) { |
| return help_CallIntMethod(env, VIRTUAL_PLAIN); |
| } |
| |
| TEST_DECLARATION(CallIntMethodA) { |
| return help_CallIntMethod(env, VIRTUAL_ARRAY); |
| } |
| |
| TEST_DECLARATION(CallIntMethodV) { |
| return help_CallIntMethod(env, VIRTUAL_VA); |
| } |
| |
| TEST_DECLARATION(CallNonvirtualIntMethod) { |
| return help_CallIntMethod(env, DIRECT_PLAIN); |
| } |
| |
| TEST_DECLARATION(CallNonvirtualIntMethodA) { |
| return help_CallIntMethod(env, DIRECT_ARRAY); |
| } |
| |
| TEST_DECLARATION(CallNonvirtualIntMethodV) { |
| return help_CallIntMethod(env, DIRECT_VA); |
| } |
| |
| TEST_DECLARATION(CallStaticIntMethod) { |
| return help_CallIntMethod(env, STATIC_PLAIN); |
| } |
| |
| TEST_DECLARATION(CallStaticIntMethodA) { |
| return help_CallIntMethod(env, STATIC_ARRAY); |
| } |
| |
| TEST_DECLARATION(CallStaticIntMethodV) { |
| return help_CallIntMethod(env, STATIC_VA); |
| } |
| |
| static char *help_CallLongMethod(JNIEnv *env, int ct, ...) { |
| va_list args; |
| va_start(args, ct); |
| |
| char *msg; |
| jobject o = getStandardInstance(env); |
| jmethodID method = findAppropriateMethod(env, &msg, (callType)ct, |
| "returnLong", "()J"); |
| |
| if (method == NULL) { |
| va_end(args); |
| return msg; |
| } |
| |
| jlong result; |
| |
| switch (ct) { |
| case VIRTUAL_PLAIN: { |
| result = CALL(CallLongMethod, o, method); |
| break; |
| } |
| case VIRTUAL_ARRAY: { |
| result = CALL(CallLongMethodA, o, method, NULL); |
| break; |
| } |
| case VIRTUAL_VA: { |
| result = CALL(CallLongMethodV, o, method, args); |
| break; |
| } |
| case DIRECT_PLAIN: { |
| result = CALL(CallNonvirtualLongMethod, o, InstanceFromNative, |
| method); |
| break; |
| } |
| case DIRECT_ARRAY: { |
| result = CALL(CallNonvirtualLongMethodA, o, InstanceFromNative, |
| method, NULL); |
| break; |
| } |
| case DIRECT_VA: { |
| result = CALL(CallNonvirtualLongMethodV, o, InstanceFromNative, |
| method, args); |
| break; |
| } |
| case STATIC_PLAIN: { |
| result = CALL(CallStaticLongMethod, StaticFromNative, method); |
| break; |
| } |
| case STATIC_ARRAY: { |
| result = CALL(CallStaticLongMethodA, StaticFromNative, method, |
| NULL); |
| break; |
| } |
| case STATIC_VA: { |
| result = CALL(CallStaticLongMethodV, StaticFromNative, method, |
| args); |
| break; |
| } |
| default: { |
| va_end(args); |
| return failure("shouldn't happen"); |
| } |
| } |
| |
| va_end(args); |
| |
| return FAIL_IF_UNEQUAL("%lld", -80080080087LL, result); |
| } |
| |
| TEST_DECLARATION(CallLongMethod) { |
| return help_CallLongMethod(env, VIRTUAL_PLAIN); |
| } |
| |
| TEST_DECLARATION(CallLongMethodA) { |
| return help_CallLongMethod(env, VIRTUAL_ARRAY); |
| } |
| |
| TEST_DECLARATION(CallLongMethodV) { |
| return help_CallLongMethod(env, VIRTUAL_VA); |
| } |
| |
| TEST_DECLARATION(CallNonvirtualLongMethod) { |
| return help_CallLongMethod(env, DIRECT_PLAIN); |
| } |
| |
| TEST_DECLARATION(CallNonvirtualLongMethodA) { |
| return help_CallLongMethod(env, DIRECT_ARRAY); |
| } |
| |
| TEST_DECLARATION(CallNonvirtualLongMethodV) { |
| return help_CallLongMethod(env, DIRECT_VA); |
| } |
| |
| TEST_DECLARATION(CallStaticLongMethod) { |
| return help_CallLongMethod(env, STATIC_PLAIN); |
| } |
| |
| TEST_DECLARATION(CallStaticLongMethodA) { |
| return help_CallLongMethod(env, STATIC_ARRAY); |
| } |
| |
| TEST_DECLARATION(CallStaticLongMethodV) { |
| return help_CallLongMethod(env, STATIC_VA); |
| } |
| |
| static char *help_CallFloatMethod(JNIEnv *env, int ct, ...) { |
| va_list args; |
| va_start(args, ct); |
| |
| char *msg; |
| jobject o = getStandardInstance(env); |
| jmethodID method = findAppropriateMethod(env, &msg, (callType)ct, |
| "returnFloat", "()F"); |
| |
| if (method == NULL) { |
| va_end(args); |
| return msg; |
| } |
| |
| jfloat result; |
| |
| switch (ct) { |
| case VIRTUAL_PLAIN: { |
| result = CALL(CallFloatMethod, o, method); |
| break; |
| } |
| case VIRTUAL_ARRAY: { |
| result = CALL(CallFloatMethodA, o, method, NULL); |
| break; |
| } |
| case VIRTUAL_VA: { |
| result = CALL(CallFloatMethodV, o, method, args); |
| break; |
| } |
| case DIRECT_PLAIN: { |
| result = CALL(CallNonvirtualFloatMethod, o, InstanceFromNative, |
| method); |
| break; |
| } |
| case DIRECT_ARRAY: { |
| result = CALL(CallNonvirtualFloatMethodA, o, InstanceFromNative, |
| method, NULL); |
| break; |
| } |
| case DIRECT_VA: { |
| result = CALL(CallNonvirtualFloatMethodV, o, InstanceFromNative, |
| method, args); |
| break; |
| } |
| case STATIC_PLAIN: { |
| result = CALL(CallStaticFloatMethod, StaticFromNative, method); |
| break; |
| } |
| case STATIC_ARRAY: { |
| result = CALL(CallStaticFloatMethodA, StaticFromNative, method, |
| NULL); |
| break; |
| } |
| case STATIC_VA: { |
| result = CALL(CallStaticFloatMethodV, StaticFromNative, method, |
| args); |
| break; |
| } |
| default: { |
| va_end(args); |
| return failure("shouldn't happen"); |
| } |
| } |
| |
| va_end(args); |
| |
| return FAIL_IF_UNEQUAL("%g", 2.5e22f, result); |
| } |
| |
| TEST_DECLARATION(CallFloatMethod) { |
| return help_CallFloatMethod(env, VIRTUAL_PLAIN); |
| } |
| |
| TEST_DECLARATION(CallFloatMethodA) { |
| return help_CallFloatMethod(env, VIRTUAL_ARRAY); |
| } |
| |
| TEST_DECLARATION(CallFloatMethodV) { |
| return help_CallFloatMethod(env, VIRTUAL_VA); |
| } |
| |
| TEST_DECLARATION(CallNonvirtualFloatMethod) { |
| return help_CallFloatMethod(env, DIRECT_PLAIN); |
| } |
| |
| TEST_DECLARATION(CallNonvirtualFloatMethodA) { |
| return help_CallFloatMethod(env, DIRECT_ARRAY); |
| } |
| |
| TEST_DECLARATION(CallNonvirtualFloatMethodV) { |
| return help_CallFloatMethod(env, DIRECT_VA); |
| } |
| |
| TEST_DECLARATION(CallStaticFloatMethod) { |
| return help_CallFloatMethod(env, STATIC_PLAIN); |
| } |
| |
| TEST_DECLARATION(CallStaticFloatMethodA) { |
| return help_CallFloatMethod(env, STATIC_ARRAY); |
| } |
| |
| TEST_DECLARATION(CallStaticFloatMethodV) { |
| return help_CallFloatMethod(env, STATIC_VA); |
| } |
| |
| static char *help_CallDoubleMethod(JNIEnv *env, int ct, ...) { |
| va_list args; |
| va_start(args, ct); |
| |
| char *msg; |
| jobject o = getStandardInstance(env); |
| jmethodID method = findAppropriateMethod(env, &msg, (callType)ct, |
| "returnDouble", "()D"); |
| |
| if (method == NULL) { |
| va_end(args); |
| return msg; |
| } |
| |
| jdouble result; |
| |
| switch (ct) { |
| case VIRTUAL_PLAIN: { |
| result = CALL(CallDoubleMethod, o, method); |
| break; |
| } |
| case VIRTUAL_ARRAY: { |
| result = CALL(CallDoubleMethodA, o, method, NULL); |
| break; |
| } |
| case VIRTUAL_VA: { |
| result = CALL(CallDoubleMethodV, o, method, args); |
| break; |
| } |
| case DIRECT_PLAIN: { |
| result = CALL(CallNonvirtualDoubleMethod, o, InstanceFromNative, |
| method); |
| break; |
| } |
| case DIRECT_ARRAY: { |
| result = CALL(CallNonvirtualDoubleMethodA, o, InstanceFromNative, |
| method, NULL); |
| break; |
| } |
| case DIRECT_VA: { |
| result = CALL(CallNonvirtualDoubleMethodV, o, InstanceFromNative, |
| method, args); |
| break; |
| } |
| case STATIC_PLAIN: { |
| result = CALL(CallStaticDoubleMethod, StaticFromNative, method); |
| break; |
| } |
| case STATIC_ARRAY: { |
| result = CALL(CallStaticDoubleMethodA, StaticFromNative, method, |
| NULL); |
| break; |
| } |
| case STATIC_VA: { |
| result = CALL(CallStaticDoubleMethodV, StaticFromNative, method, |
| args); |
| break; |
| } |
| default: { |
| va_end(args); |
| return failure("shouldn't happen"); |
| } |
| } |
| |
| va_end(args); |
| |
| return FAIL_IF_UNEQUAL("%g", 7.503e100, result); |
| } |
| |
| TEST_DECLARATION(CallDoubleMethod) { |
| return help_CallDoubleMethod(env, VIRTUAL_PLAIN); |
| } |
| |
| TEST_DECLARATION(CallDoubleMethodA) { |
| return help_CallDoubleMethod(env, VIRTUAL_ARRAY); |
| } |
| |
| TEST_DECLARATION(CallDoubleMethodV) { |
| return help_CallDoubleMethod(env, VIRTUAL_VA); |
| } |
| |
| TEST_DECLARATION(CallNonvirtualDoubleMethod) { |
| return help_CallDoubleMethod(env, DIRECT_PLAIN); |
| } |
| |
| TEST_DECLARATION(CallNonvirtualDoubleMethodA) { |
| return help_CallDoubleMethod(env, DIRECT_ARRAY); |
| } |
| |
| TEST_DECLARATION(CallNonvirtualDoubleMethodV) { |
| return help_CallDoubleMethod(env, DIRECT_VA); |
| } |
| |
| TEST_DECLARATION(CallStaticDoubleMethod) { |
| return help_CallDoubleMethod(env, STATIC_PLAIN); |
| } |
| |
| TEST_DECLARATION(CallStaticDoubleMethodA) { |
| return help_CallDoubleMethod(env, STATIC_ARRAY); |
| } |
| |
| TEST_DECLARATION(CallStaticDoubleMethodV) { |
| return help_CallDoubleMethod(env, STATIC_VA); |
| } |
| |
| static char *help_CallVoidMethod(JNIEnv *env, int ct, ...) { |
| va_list args; |
| va_start(args, ct); |
| |
| char *msg; |
| jobject o = getStandardInstance(env); |
| jmethodID method = findAppropriateMethod(env, &msg, (callType)ct, |
| "nop", "()V"); |
| |
| if (method == NULL) { |
| va_end(args); |
| return msg; |
| } |
| |
| // For these, we simply consider "success" to be "didn't crash." |
| |
| switch (ct) { |
| case VIRTUAL_PLAIN: { |
| CALL(CallVoidMethod, o, method); |
| break; |
| } |
| case VIRTUAL_ARRAY: { |
| CALL(CallVoidMethodA, o, method, NULL); |
| break; |
| } |
| case VIRTUAL_VA: { |
| CALL(CallVoidMethodV, o, method, args); |
| break; |
| } |
| case DIRECT_PLAIN: { |
| CALL(CallNonvirtualVoidMethod, o, InstanceFromNative, |
| method); |
| break; |
| } |
| case DIRECT_ARRAY: { |
| CALL(CallNonvirtualVoidMethodA, o, InstanceFromNative, |
| method, NULL); |
| break; |
| } |
| case DIRECT_VA: { |
| CALL(CallNonvirtualVoidMethodV, o, InstanceFromNative, |
| method, args); |
| break; |
| } |
| case STATIC_PLAIN: { |
| CALL(CallStaticVoidMethod, StaticFromNative, method); |
| break; |
| } |
| case STATIC_ARRAY: { |
| CALL(CallStaticVoidMethodA, StaticFromNative, method, |
| NULL); |
| break; |
| } |
| case STATIC_VA: { |
| CALL(CallStaticVoidMethodV, StaticFromNative, method, |
| args); |
| break; |
| } |
| default: { |
| va_end(args); |
| return failure("shouldn't happen"); |
| } |
| } |
| |
| va_end(args); |
| |
| return NULL; |
| } |
| |
| TEST_DECLARATION(CallVoidMethod) { |
| return help_CallVoidMethod(env, VIRTUAL_PLAIN); |
| } |
| |
| TEST_DECLARATION(CallVoidMethodA) { |
| return help_CallVoidMethod(env, VIRTUAL_ARRAY); |
| } |
| |
| TEST_DECLARATION(CallVoidMethodV) { |
| return help_CallVoidMethod(env, VIRTUAL_VA); |
| } |
| |
| TEST_DECLARATION(CallNonvirtualVoidMethod) { |
| return help_CallVoidMethod(env, DIRECT_PLAIN); |
| } |
| |
| TEST_DECLARATION(CallNonvirtualVoidMethodA) { |
| return help_CallVoidMethod(env, DIRECT_ARRAY); |
| } |
| |
| TEST_DECLARATION(CallNonvirtualVoidMethodV) { |
| return help_CallVoidMethod(env, DIRECT_VA); |
| } |
| |
| TEST_DECLARATION(CallStaticVoidMethod) { |
| return help_CallVoidMethod(env, STATIC_PLAIN); |
| } |
| |
| TEST_DECLARATION(CallStaticVoidMethodA) { |
| return help_CallVoidMethod(env, STATIC_ARRAY); |
| } |
| |
| TEST_DECLARATION(CallStaticVoidMethodV) { |
| return help_CallVoidMethod(env, STATIC_VA); |
| } |
| |
| static char *help_CallObjectMethod(JNIEnv *env, int ct, ...) { |
| va_list args; |
| va_start(args, ct); |
| |
| char *msg; |
| jobject o = getStandardInstance(env); |
| jmethodID method = findAppropriateMethod(env, &msg, (callType)ct, |
| "returnString", "()Ljava/lang/String;"); |
| |
| if (method == NULL) { |
| va_end(args); |
| return msg; |
| } |
| |
| jstring result; |
| |
| switch (ct) { |
| case VIRTUAL_PLAIN: { |
| result = (jstring) CALL(CallObjectMethod, o, method); |
| break; |
| } |
| case VIRTUAL_ARRAY: { |
| result = (jstring) CALL(CallObjectMethodA, o, method, NULL); |
| break; |
| } |
| case VIRTUAL_VA: { |
| result = (jstring) CALL(CallObjectMethodV, o, method, args); |
| break; |
| } |
| case DIRECT_PLAIN: { |
| result = (jstring) |
| CALL(CallNonvirtualObjectMethod, o, InstanceFromNative, |
| method); |
| break; |
| } |
| case DIRECT_ARRAY: { |
| result = (jstring) |
| CALL(CallNonvirtualObjectMethodA, o, InstanceFromNative, |
| method, NULL); |
| break; |
| } |
| case DIRECT_VA: { |
| result = (jstring) |
| CALL(CallNonvirtualObjectMethodV, o, InstanceFromNative, |
| method, args); |
| break; |
| } |
| case STATIC_PLAIN: { |
| result = (jstring) |
| CALL(CallStaticObjectMethod, StaticFromNative, method); |
| break; |
| } |
| case STATIC_ARRAY: { |
| result = (jstring) |
| CALL(CallStaticObjectMethodA, StaticFromNative, method, NULL); |
| break; |
| } |
| case STATIC_VA: { |
| result = (jstring) |
| CALL(CallStaticObjectMethodV, StaticFromNative, method, args); |
| break; |
| } |
| default: { |
| va_end(args); |
| return failure("shouldn't happen"); |
| } |
| } |
| |
| va_end(args); |
| |
| if (result == NULL) { |
| return failure("got null from call"); |
| } |
| |
| const char *utf = CALL(GetStringUTFChars, result, NULL); |
| |
| if (strcmp(utf, "muffins") == 0) { |
| msg = NULL; |
| } else { |
| msg = failure("unexpected string: %s", utf); |
| } |
| |
| CALL(ReleaseStringUTFChars, result, utf); |
| |
| return msg; |
| } |
| |
| TEST_DECLARATION(CallObjectMethod) { |
| return help_CallObjectMethod(env, VIRTUAL_PLAIN); |
| } |
| |
| TEST_DECLARATION(CallObjectMethodA) { |
| return help_CallObjectMethod(env, VIRTUAL_ARRAY); |
| } |
| |
| TEST_DECLARATION(CallObjectMethodV) { |
| return help_CallObjectMethod(env, VIRTUAL_VA); |
| } |
| |
| TEST_DECLARATION(CallNonvirtualObjectMethod) { |
| return help_CallObjectMethod(env, DIRECT_PLAIN); |
| } |
| |
| TEST_DECLARATION(CallNonvirtualObjectMethodA) { |
| return help_CallObjectMethod(env, DIRECT_ARRAY); |
| } |
| |
| TEST_DECLARATION(CallNonvirtualObjectMethodV) { |
| return help_CallObjectMethod(env, DIRECT_VA); |
| } |
| |
| TEST_DECLARATION(CallStaticObjectMethod) { |
| return help_CallObjectMethod(env, STATIC_PLAIN); |
| } |
| |
| TEST_DECLARATION(CallStaticObjectMethodA) { |
| return help_CallObjectMethod(env, STATIC_ARRAY); |
| } |
| |
| TEST_DECLARATION(CallStaticObjectMethodV) { |
| return help_CallObjectMethod(env, STATIC_VA); |
| } |
| |
| static char *help_TakeOneOfEach(JNIEnv *env, int ct, ...) { |
| va_list args; |
| va_start(args, ct); |
| |
| char *msg; |
| jobject o = getStandardInstance(env); |
| jmethodID method = findAppropriateMethod(env, &msg, (callType)ct, |
| "takeOneOfEach", "(DFJICSBZLjava/lang/String;)Z"); |
| |
| if (method == NULL) { |
| va_end(args); |
| return msg; |
| } |
| |
| jvalue jargs[] = { |
| {d: 0.0}, {f: 1.0f}, {j: 2LL}, {i: 3}, {c: 4}, {s: 5}, {b: 6}, |
| {z: true}, {l: biscuits} |
| }; |
| |
| jboolean result; |
| |
| switch (ct) { |
| case VIRTUAL_PLAIN: { |
| result = CALL(CallBooleanMethod, o, method, |
| 0.0, 1.0f, 2LL, 3, (jchar) 4, (jshort) 5, (jbyte) 6, |
| (jboolean) true, biscuits); |
| break; |
| } |
| case VIRTUAL_ARRAY: { |
| result = CALL(CallBooleanMethodA, o, method, jargs); |
| break; |
| } |
| case VIRTUAL_VA: { |
| result = CALL(CallBooleanMethodV, o, method, args); |
| break; |
| } |
| case DIRECT_PLAIN: { |
| result = CALL(CallNonvirtualBooleanMethod, o, InstanceFromNative, |
| method, |
| 0.0, 1.0f, 2LL, 3, (jchar) 4, (jshort) 5, (jbyte) 6, |
| (jboolean) true, biscuits); |
| break; |
| } |
| case DIRECT_ARRAY: { |
| result = CALL(CallNonvirtualBooleanMethodA, o, InstanceFromNative, |
| method, jargs); |
| break; |
| } |
| case DIRECT_VA: { |
| result = CALL(CallNonvirtualBooleanMethodV, o, InstanceFromNative, |
| method, args); |
| break; |
| } |
| case STATIC_PLAIN: { |
| result = CALL(CallStaticBooleanMethod, StaticFromNative, method, |
| 0.0, 1.0f, 2LL, 3, (jchar) 4, (jshort) 5, (jbyte) 6, |
| (jboolean) true, biscuits); |
| break; |
| } |
| case STATIC_ARRAY: { |
| result = CALL(CallStaticBooleanMethodA, StaticFromNative, method, |
| jargs); |
| break; |
| } |
| case STATIC_VA: { |
| result = CALL(CallStaticBooleanMethodV, StaticFromNative, method, |
| args); |
| break; |
| } |
| default: { |
| va_end(args); |
| return failure("shouldn't happen"); |
| } |
| } |
| |
| va_end(args); |
| |
| return FAIL_IF_UNEQUAL("%d", true, result); |
| } |
| |
| TEST_DECLARATION(TakeOneOfEach) { |
| return help_TakeOneOfEach(env, VIRTUAL_PLAIN); |
| } |
| |
| TEST_DECLARATION(TakeOneOfEachA) { |
| return help_TakeOneOfEach(env, VIRTUAL_ARRAY); |
| } |
| |
| TEST_DECLARATION(TakeOneOfEachV) { |
| return help_TakeOneOfEach(env, VIRTUAL_VA, |
| 0.0, 1.0f, 2LL, 3, (jchar) 4, (jshort) 5, (jbyte) 6, |
| (jboolean) true, biscuits); |
| } |
| |
| TEST_DECLARATION(NonvirtualTakeOneOfEach) { |
| return help_TakeOneOfEach(env, DIRECT_PLAIN); |
| } |
| |
| TEST_DECLARATION(NonvirtualTakeOneOfEachA) { |
| return help_TakeOneOfEach(env, DIRECT_ARRAY); |
| } |
| |
| TEST_DECLARATION(NonvirtualTakeOneOfEachV) { |
| return help_TakeOneOfEach(env, DIRECT_VA, |
| 0.0, 1.0f, 2LL, 3, (jchar) 4, (jshort) 5, (jbyte) 6, |
| (jboolean) true, biscuits); |
| } |
| |
| TEST_DECLARATION(StaticTakeOneOfEach) { |
| return help_TakeOneOfEach(env, STATIC_PLAIN); |
| } |
| |
| TEST_DECLARATION(StaticTakeOneOfEachA) { |
| return help_TakeOneOfEach(env, STATIC_ARRAY); |
| } |
| |
| TEST_DECLARATION(StaticTakeOneOfEachV) { |
| return help_TakeOneOfEach(env, STATIC_VA, |
| 0.0, 1.0f, 2LL, 3, (jchar) 4, (jshort) 5, (jbyte) 6, |
| (jboolean) true, biscuits); |
| } |
| |
| static char *help_TakeCoolHandLuke(JNIEnv *env, int ct, ...) { |
| va_list args; |
| va_start(args, ct); |
| |
| char *msg; |
| jobject o = getStandardInstance(env); |
| jmethodID method = findAppropriateMethod(env, &msg, (callType)ct, |
| "takeCoolHandLuke", |
| "(IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII)Z"); |
| |
| if (method == NULL) { |
| va_end(args); |
| return msg; |
| } |
| |
| jvalue jargs[] = { |
| {i: 1}, {i: 2}, {i: 3}, {i: 4}, |
| {i: 5}, {i: 6}, {i: 7}, {i: 8}, {i: 9}, |
| {i: 10}, {i: 11}, {i: 12}, {i: 13}, {i: 14}, |
| {i: 15}, {i: 16}, {i: 17}, {i: 18}, {i: 19}, |
| {i: 20}, {i: 21}, {i: 22}, {i: 23}, {i: 24}, |
| {i: 25}, {i: 26}, {i: 27}, {i: 28}, {i: 29}, |
| {i: 30}, {i: 31}, {i: 32}, {i: 33}, {i: 34}, |
| {i: 35}, {i: 36}, {i: 37}, {i: 38}, {i: 39}, |
| {i: 40}, {i: 41}, {i: 42}, {i: 43}, {i: 44}, |
| {i: 45}, {i: 46}, {i: 47}, {i: 48}, {i: 49}, |
| {i: 50} |
| }; |
| |
| jboolean result; |
| |
| switch (ct) { |
| case VIRTUAL_PLAIN: { |
| result = CALL(CallBooleanMethod, o, method, |
| 1, 2, 3, 4, 5, 6, 7, 8, 9, |
| 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, |
| 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, |
| 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, |
| 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, |
| 50); |
| break; |
| } |
| case VIRTUAL_ARRAY: { |
| result = CALL(CallBooleanMethodA, o, method, jargs); |
| break; |
| } |
| case VIRTUAL_VA: { |
| result = CALL(CallBooleanMethodV, o, method, args); |
| break; |
| } |
| case DIRECT_PLAIN: { |
| result = CALL(CallNonvirtualBooleanMethod, o, InstanceFromNative, |
| method, |
| 1, 2, 3, 4, 5, 6, 7, 8, 9, |
| 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, |
| 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, |
| 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, |
| 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, |
| 50); |
| break; |
| } |
| case DIRECT_ARRAY: { |
| result = CALL(CallNonvirtualBooleanMethodA, o, InstanceFromNative, |
| method, jargs); |
| break; |
| } |
| case DIRECT_VA: { |
| result = CALL(CallNonvirtualBooleanMethodV, o, InstanceFromNative, |
| method, args); |
| break; |
| } |
| case STATIC_PLAIN: { |
| result = CALL(CallStaticBooleanMethod, StaticFromNative, method, |
| 1, 2, 3, 4, 5, 6, 7, 8, 9, |
| 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, |
| 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, |
| 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, |
| 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, |
| 50); |
| break; |
| } |
| case STATIC_ARRAY: { |
| result = CALL(CallStaticBooleanMethodA, StaticFromNative, method, |
| jargs); |
| break; |
| } |
| case STATIC_VA: { |
| result = CALL(CallStaticBooleanMethodV, StaticFromNative, method, |
| args); |
| break; |
| } |
| default: { |
| va_end(args); |
| return failure("shouldn't happen"); |
| } |
| } |
| |
| va_end(args); |
| |
| return FAIL_IF_UNEQUAL("%d", true, result); |
| } |
| |
| TEST_DECLARATION(TakeCoolHandLuke) { |
| return help_TakeCoolHandLuke(env, VIRTUAL_PLAIN); |
| } |
| |
| TEST_DECLARATION(TakeCoolHandLukeA) { |
| return help_TakeCoolHandLuke(env, VIRTUAL_ARRAY); |
| } |
| |
| TEST_DECLARATION(TakeCoolHandLukeV) { |
| return help_TakeCoolHandLuke(env, VIRTUAL_VA, |
| 1, 2, 3, 4, 5, 6, 7, 8, 9, |
| 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, |
| 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, |
| 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, |
| 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, |
| 50); |
| } |
| |
| TEST_DECLARATION(NonvirtualTakeCoolHandLuke) { |
| return help_TakeCoolHandLuke(env, DIRECT_PLAIN); |
| } |
| |
| TEST_DECLARATION(NonvirtualTakeCoolHandLukeA) { |
| return help_TakeCoolHandLuke(env, DIRECT_ARRAY); |
| } |
| |
| TEST_DECLARATION(NonvirtualTakeCoolHandLukeV) { |
| return help_TakeCoolHandLuke(env, DIRECT_VA, |
| 1, 2, 3, 4, 5, 6, 7, 8, 9, |
| 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, |
| 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, |
| 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, |
| 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, |
| 50); |
| } |
| |
| TEST_DECLARATION(StaticTakeCoolHandLuke) { |
| return help_TakeCoolHandLuke(env, STATIC_PLAIN); |
| } |
| |
| TEST_DECLARATION(StaticTakeCoolHandLukeA) { |
| return help_TakeCoolHandLuke(env, STATIC_ARRAY); |
| } |
| |
| TEST_DECLARATION(StaticTakeCoolHandLukeV) { |
| return help_TakeCoolHandLuke(env, STATIC_VA, |
| 1, 2, 3, 4, 5, 6, 7, 8, 9, |
| 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, |
| 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, |
| 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, |
| 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, |
| 50); |
| } |
| |
| TEST_DECLARATION(DefineClass) { |
| // Android implementations should always return NULL. |
| jclass clazz = CALL(DefineClass, "foo", NULL, NULL, 0); |
| |
| if (clazz != NULL) { |
| return failure("Expected NULL but got %p", clazz); |
| } |
| |
| return NULL; |
| } |
| |
| // TODO: Missing functions: |
| // DeleteLocalRef |
| // DeleteWeakGlobalRef |
| // EnsureLocalCapacity |
| // ExceptionCheck |
| // ExceptionClear |
| // ExceptionDescribe |
| // ExceptionOccurred |
| // FatalError (Note: impossible to test in this framework) |
| // FindClass |
| // FromReflectedField |
| // FromReflectedMethod |
| // GetArrayLength |
| // GetBooleanArrayElements |
| // GetBooleanArrayRegion |
| // GetBooleanField |
| // GetByteArrayElements |
| // GetByteArrayRegion |
| // GetByteField |
| // GetCharArrayElements |
| // GetCharArrayRegion |
| // GetCharField |
| // GetDirectBufferAddress |
| // GetDirectBufferCapacity |
| // GetDoubleArrayElements |
| // GetDoubleArrayRegion |
| // GetDoubleField |
| // GetFieldID |
| // GetFloatArrayElements |
| // GetFloatArrayRegion |
| // GetFloatField |
| // GetIntArrayElements |
| // GetIntArrayRegion |
| // GetIntField |
| // GetJavaVM |
| // GetLongArrayElements |
| // GetLongArrayRegion |
| // GetLongField |
| // GetMethodID |
| // GetObjectArrayElement |
| // GetObjectClass |
| // GetObjectField |
| // GetObjectRefType (since 1.6) |
| // GetPrimitiveArrayCritical |
| // GetShortArrayElements |
| // GetShortArrayRegion |
| // GetShortField |
| // GetStaticBooleanField |
| // GetStaticByteField |
| // GetStaticCharField |
| // GetStaticDoubleField |
| // GetStaticFieldID |
| // GetStaticFloatField |
| // GetStaticIntField |
| // GetStaticLongField |
| // GetStaticMethodID |
| // GetStaticObjectField |
| // GetStaticShortField |
| // GetStringChars |
| // GetStringCritical |
| // GetStringLength |
| // GetStringRegion |
| // GetStringUTFChars |
| // GetStringUTFLength |
| // GetStringUTFRegion |
| // GetSuperclass |
| |
| TEST_DECLARATION(GetVersion) { |
| // Android implementations should all be at version 1.6. |
| jint version = CALL(GetVersion); |
| |
| if (version != JNI_VERSION_1_6) { |
| return failure("Expected JNI_VERSION_1_6 but got 0x%x", version); |
| } |
| |
| return NULL; |
| } |
| |
| // TODO: Missing functions: |
| // IsAssignableFrom |
| // IsInstanceOf |
| // IsSameObject |
| // MonitorEnter |
| // MonitorExit |
| // NewBooleanArray |
| // NewByteArray |
| // NewCharArray |
| // NewDirectByteBuffer |
| // NewDoubleArray |
| // NewFloatArray |
| // NewGlobalRef |
| // NewIntArray |
| // NewLocalRef |
| // NewLongArray |
| // NewObject |
| // NewObjectA |
| // NewObjectArray |
| // NewObjectV |
| // NewShortArray |
| // NewString |
| // NewStringUTF |
| // NewWeakGlobalRef |
| // PopLocalFrame |
| // PushLocalFrame |
| // RegisterNatives |
| // ReleaseBooleanArrayElements |
| // ReleaseByteArrayElements |
| // ReleaseCharArrayElements |
| // ReleaseDoubleArrayElements |
| // ReleaseFloatArrayElements |
| // ReleaseIntArrayElements |
| // ReleaseLongArrayElements |
| // ReleasePrimitiveArrayCritical |
| // ReleaseShortArrayElements |
| // ReleaseStringChars |
| // ReleaseStringCritical |
| // ReleaseStringUTFChars |
| // SetBooleanArrayRegion |
| // SetBooleanField |
| // SetByteArrayRegion |
| // SetByteField |
| // SetCharArrayRegion |
| // SetCharField |
| // SetDoubleArrayRegion |
| // SetDoubleField |
| // SetFloatArrayRegion |
| // SetFloatField |
| // SetIntArrayRegion |
| // SetIntField |
| // SetLongArrayRegion |
| // SetLongField |
| // SetObjectArrayElement |
| // SetObjectField |
| // SetShortArrayRegion |
| // SetShortField |
| // SetStaticBooleanField |
| // SetStaticByteField |
| // SetStaticCharField |
| // SetStaticDoubleField |
| // SetStaticFloatField |
| // SetStaticIntField |
| // SetStaticLongField |
| // SetStaticObjectField |
| // SetStaticShortField |
| // Throw |
| // ThrowNew |
| // ToReflectedField |
| // ToReflectedMethod |
| // UnregisterNatives |
| |
| |
| |
| /** |
| * Runs all the tests, returning NULL if they all succeeded, or |
| * a string listing information about all the failures. |
| */ |
| static jstring runAllTests(JNIEnv *env) { |
| char *result = initializeVariables(env); |
| |
| if (CALL(ExceptionOccurred)) { |
| CALL(ExceptionDescribe); |
| CALL(ExceptionClear); |
| } |
| |
| if (result == NULL) { |
| result = runJniTests(env, |
| RUN_TEST(CallBooleanMethod), |
| RUN_TEST(CallBooleanMethodA), |
| RUN_TEST(CallBooleanMethodV), |
| RUN_TEST(CallNonvirtualBooleanMethod), |
| RUN_TEST(CallNonvirtualBooleanMethodA), |
| RUN_TEST(CallNonvirtualBooleanMethodV), |
| RUN_TEST(CallStaticBooleanMethod), |
| RUN_TEST(CallStaticBooleanMethodA), |
| RUN_TEST(CallStaticBooleanMethodV), |
| |
| RUN_TEST(CallByteMethod), |
| RUN_TEST(CallByteMethodA), |
| RUN_TEST(CallByteMethodV), |
| RUN_TEST(CallNonvirtualByteMethod), |
| RUN_TEST(CallNonvirtualByteMethodA), |
| RUN_TEST(CallNonvirtualByteMethodV), |
| RUN_TEST(CallStaticByteMethod), |
| RUN_TEST(CallStaticByteMethodA), |
| RUN_TEST(CallStaticByteMethodV), |
| |
| RUN_TEST(CallShortMethod), |
| RUN_TEST(CallShortMethodA), |
| RUN_TEST(CallShortMethodV), |
| RUN_TEST(CallNonvirtualShortMethod), |
| RUN_TEST(CallNonvirtualShortMethodA), |
| RUN_TEST(CallNonvirtualShortMethodV), |
| RUN_TEST(CallStaticShortMethod), |
| RUN_TEST(CallStaticShortMethodA), |
| RUN_TEST(CallStaticShortMethodV), |
| |
| RUN_TEST(CallCharMethod), |
| RUN_TEST(CallCharMethodA), |
| RUN_TEST(CallCharMethodV), |
| RUN_TEST(CallNonvirtualCharMethod), |
| RUN_TEST(CallNonvirtualCharMethodA), |
| RUN_TEST(CallNonvirtualCharMethodV), |
| RUN_TEST(CallStaticCharMethod), |
| RUN_TEST(CallStaticCharMethodA), |
| RUN_TEST(CallStaticCharMethodV), |
| |
| RUN_TEST(CallIntMethod), |
| RUN_TEST(CallIntMethodA), |
| RUN_TEST(CallIntMethodV), |
| RUN_TEST(CallNonvirtualIntMethod), |
| RUN_TEST(CallNonvirtualIntMethodA), |
| RUN_TEST(CallNonvirtualIntMethodV), |
| RUN_TEST(CallStaticIntMethod), |
| RUN_TEST(CallStaticIntMethodA), |
| RUN_TEST(CallStaticIntMethodV), |
| |
| RUN_TEST(CallLongMethod), |
| RUN_TEST(CallLongMethodA), |
| RUN_TEST(CallLongMethodV), |
| RUN_TEST(CallNonvirtualLongMethod), |
| RUN_TEST(CallNonvirtualLongMethodA), |
| RUN_TEST(CallNonvirtualLongMethodV), |
| RUN_TEST(CallStaticLongMethod), |
| RUN_TEST(CallStaticLongMethodA), |
| RUN_TEST(CallStaticLongMethodV), |
| |
| RUN_TEST(CallFloatMethod), |
| RUN_TEST(CallFloatMethodA), |
| RUN_TEST(CallFloatMethodV), |
| RUN_TEST(CallNonvirtualFloatMethod), |
| RUN_TEST(CallNonvirtualFloatMethodA), |
| RUN_TEST(CallNonvirtualFloatMethodV), |
| RUN_TEST(CallStaticFloatMethod), |
| RUN_TEST(CallStaticFloatMethodA), |
| RUN_TEST(CallStaticFloatMethodV), |
| |
| RUN_TEST(CallDoubleMethod), |
| RUN_TEST(CallDoubleMethodA), |
| RUN_TEST(CallDoubleMethodV), |
| RUN_TEST(CallNonvirtualDoubleMethod), |
| RUN_TEST(CallNonvirtualDoubleMethodA), |
| RUN_TEST(CallNonvirtualDoubleMethodV), |
| RUN_TEST(CallStaticDoubleMethod), |
| RUN_TEST(CallStaticDoubleMethodA), |
| RUN_TEST(CallStaticDoubleMethodV), |
| |
| RUN_TEST(CallVoidMethod), |
| RUN_TEST(CallVoidMethodA), |
| RUN_TEST(CallVoidMethodV), |
| RUN_TEST(CallNonvirtualVoidMethod), |
| RUN_TEST(CallNonvirtualVoidMethodA), |
| RUN_TEST(CallNonvirtualVoidMethodV), |
| RUN_TEST(CallStaticVoidMethod), |
| RUN_TEST(CallStaticVoidMethodA), |
| RUN_TEST(CallStaticVoidMethodV), |
| |
| RUN_TEST(CallObjectMethod), |
| RUN_TEST(CallObjectMethodA), |
| RUN_TEST(CallObjectMethodV), |
| RUN_TEST(CallNonvirtualObjectMethod), |
| RUN_TEST(CallNonvirtualObjectMethodA), |
| RUN_TEST(CallNonvirtualObjectMethodV), |
| RUN_TEST(CallStaticObjectMethod), |
| RUN_TEST(CallStaticObjectMethodA), |
| RUN_TEST(CallStaticObjectMethodV), |
| |
| RUN_TEST(TakeOneOfEach), |
| RUN_TEST(TakeOneOfEachA), |
| RUN_TEST(TakeOneOfEachV), |
| RUN_TEST(NonvirtualTakeOneOfEach), |
| RUN_TEST(NonvirtualTakeOneOfEachA), |
| RUN_TEST(NonvirtualTakeOneOfEachV), |
| RUN_TEST(StaticTakeOneOfEach), |
| RUN_TEST(StaticTakeOneOfEachA), |
| RUN_TEST(StaticTakeOneOfEachV), |
| |
| RUN_TEST(TakeCoolHandLuke), |
| RUN_TEST(TakeCoolHandLukeA), |
| RUN_TEST(TakeCoolHandLukeV), |
| RUN_TEST(NonvirtualTakeCoolHandLuke), |
| RUN_TEST(NonvirtualTakeCoolHandLukeA), |
| RUN_TEST(NonvirtualTakeCoolHandLukeV), |
| RUN_TEST(StaticTakeCoolHandLuke), |
| RUN_TEST(StaticTakeCoolHandLukeA), |
| RUN_TEST(StaticTakeCoolHandLukeV), |
| |
| RUN_TEST(DefineClass), |
| RUN_TEST(GetVersion), |
| NULL); |
| |
| // TODO: Add more tests, above. |
| } |
| |
| if (result != NULL) { |
| jstring s = CALL(NewStringUTF, result); |
| free(result); |
| return s; |
| } |
| |
| return NULL; |
| } |