| /* |
| * 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. |
| */ |
| |
| /* |
| * Native implementation for the StaticNonce class. See the test code |
| * in JniStaticTest for more info. |
| */ |
| |
| #include <jni.h> |
| |
| #include <stdbool.h> |
| #include <string.h> |
| |
| #include "helper.h" |
| |
| // public static native void nop(); |
| static void StaticNonce_nop(JNIEnv *env, jclass clazz) { |
| // This space intentionally left blank. |
| } |
| |
| // public static native void nopDlsym(); |
| JNIEXPORT void Java_android_jni_cts_StaticNonce_nopDlsym(JNIEnv *env, |
| jclass clazz) { |
| // This space intentionally left blank. |
| } |
| |
| // @FastNative |
| // public static native void nopFast(); |
| static void StaticNonce_nopFast(JNIEnv *env, jclass clazz) { |
| // This space intentionally left blank. |
| } |
| |
| // @FastNative |
| // public static native void nopFastDlsym(); |
| JNIEXPORT void Java_android_jni_cts_StaticNonce_nopFastDlsym(JNIEnv *env, |
| jclass clazz) { |
| // This space intentionally left blank. |
| } |
| |
| // @CriticalNative |
| // public static native void nopCritical(); |
| static void StaticNonce_nopCritical() { |
| // This space intentionally left blank. |
| } |
| |
| // @CriticalNative |
| // public static native void nopCriticalDlsym(); |
| JNIEXPORT void Java_android_jni_cts_StaticNonce_nopCriticalDlsym() { |
| // This space intentionally left blank. |
| } |
| |
| // public static native boolean returnBoolean(); |
| static jboolean StaticNonce_returnBoolean(JNIEnv *env, jclass clazz) { |
| return (jboolean) true; |
| } |
| |
| // @FastNative |
| // public static native boolean returnBooleanFast(); |
| static jboolean StaticNonce_returnBooleanFast(JNIEnv *env, jclass clazz) { |
| return (jboolean) true; |
| } |
| |
| // @CriticalNative |
| // public static native boolean returnBooleanCritical(); |
| static jboolean StaticNonce_returnBooleanCritical() { |
| return (jboolean) true; |
| } |
| |
| // public static native byte returnByte(); |
| static jbyte StaticNonce_returnByte(JNIEnv *env, jclass clazz) { |
| return (jbyte) 123; |
| } |
| |
| // @FastNative |
| // public static native byte returnByteFast(); |
| static jbyte StaticNonce_returnByteFast(JNIEnv *env, jclass clazz) { |
| return (jbyte) 123; |
| } |
| |
| // @CriticalNative |
| // public static native byte returnByteCritical(); |
| static jbyte StaticNonce_returnByteCritical() { |
| return (jbyte) 123; |
| } |
| |
| // public static native short returnShort(); |
| static jshort StaticNonce_returnShort(JNIEnv *env, jclass clazz) { |
| return (jshort) -12345; |
| } |
| |
| // @FastNative |
| // public static native short returnShortFast(); |
| static jshort StaticNonce_returnShortFast(JNIEnv *env, jclass clazz) { |
| return (jshort) -12345; |
| } |
| |
| // @CriticalNative |
| // public static native short returnShortCritical(); |
| static jshort StaticNonce_returnShortCritical() { |
| return (jshort) -12345; |
| } |
| |
| // public static native char returnChar(); |
| static jchar StaticNonce_returnChar(JNIEnv *env, jclass clazz) { |
| return (jchar) 34567; |
| } |
| |
| // @FastNative |
| // public static native char returnCharFast(); |
| static jchar StaticNonce_returnCharFast(JNIEnv *env, jclass clazz) { |
| return (jchar) 34567; |
| } |
| |
| // @CriticalNative |
| // public static native char returnCharCritical(); |
| static jchar StaticNonce_returnCharCritical() { |
| return (jchar) 34567; |
| } |
| |
| // public static native int returnInt(); |
| static jint StaticNonce_returnInt(JNIEnv *env, jclass clazz) { |
| return 12345678; |
| } |
| |
| // @FastNative |
| // public static native int returnIntFast(); |
| static jint StaticNonce_returnIntFast(JNIEnv *env, jclass clazz) { |
| return 12345678; |
| } |
| |
| // @CriticalNative |
| // public static native int returnIntCritical(); |
| static jint StaticNonce_returnIntCritical() { |
| return 12345678; |
| } |
| |
| // public static native long returnLong(); |
| static jlong StaticNonce_returnLong(JNIEnv *env, jclass clazz) { |
| return (jlong) -1098765432109876543LL; |
| } |
| |
| // @FastNative |
| // public static native long returnLongFast(); |
| static jlong StaticNonce_returnLongFast(JNIEnv *env, jclass clazz) { |
| return (jlong) -1098765432109876543LL; |
| } |
| |
| // @CriticalNative |
| // public static native long returnLongCritical(); |
| static jlong StaticNonce_returnLongCritical() { |
| return (jlong) -1098765432109876543LL; |
| } |
| |
| // public static native float returnFloat(); |
| static jfloat StaticNonce_returnFloat(JNIEnv *env, jclass clazz) { |
| return (jfloat) -98765.4321F; |
| } |
| |
| // @FastNative |
| // public static native float returnFloatFast(); |
| static jfloat StaticNonce_returnFloatFast(JNIEnv *env, jclass clazz) { |
| return (jfloat) -98765.4321F; |
| } |
| |
| // @CriticalNative |
| // public static native float returnFloatCritical(); |
| static jfloat StaticNonce_returnFloatCritical() { |
| return (jfloat) -98765.4321F; |
| } |
| |
| // public static native double returnDouble(); |
| static jdouble StaticNonce_returnDouble(JNIEnv *env, jclass clazz) { |
| return 12345678.9; |
| } |
| |
| // @FastNative |
| // public static native double returnDoubleFast(); |
| static jdouble StaticNonce_returnDoubleFast(JNIEnv *env, jclass clazz) { |
| return 12345678.9; |
| } |
| |
| // @CriticalNative |
| // public static native double returnDoubleCritical(); |
| static jdouble StaticNonce_returnDoubleCritical() { |
| return 12345678.9; |
| } |
| |
| // public static native Object returnNull(); |
| static jobject StaticNonce_returnNull(JNIEnv *env, jclass clazz) { |
| return NULL; |
| } |
| |
| // @FastNative |
| // public static native Object returnNullFast(); |
| static jobject StaticNonce_returnNullFast(JNIEnv *env, jclass clazz) { |
| return NULL; |
| } |
| |
| // public static native String returnString(); |
| static jstring StaticNonce_returnString(JNIEnv *env, jclass clazz) { |
| return (*env)->NewStringUTF(env, "blort"); |
| } |
| |
| // @FastNative |
| // public static native String returnStringFast(); |
| static jstring StaticNonce_returnStringFast(JNIEnv *env, jclass clazz) { |
| return (*env)->NewStringUTF(env, "blort"); |
| } |
| |
| // public static native short[] returnShortArray(); |
| static jshortArray StaticNonce_returnShortArray(JNIEnv *env, jclass clazz) { |
| static jshort contents[] = { 10, 20, 30 }; |
| |
| jshortArray result = (*env)->NewShortArray(env, 3); |
| |
| if (result == NULL) { |
| return NULL; |
| } |
| |
| (*env)->SetShortArrayRegion(env, result, 0, 3, contents); |
| return result; |
| } |
| |
| // @FastNative |
| // public static native short[] returnShortArrayFast(); |
| static jshortArray StaticNonce_returnShortArrayFast(JNIEnv *env, |
| jclass clazz) { |
| return StaticNonce_returnShortArray(env, clazz); |
| } |
| |
| // public static native String[] returnStringArray(); |
| static jobjectArray StaticNonce_returnStringArray(JNIEnv *env, jclass clazz) { |
| static int indices[] = { 0, 50, 99 }; |
| static const char *contents[] = { "blort", "zorch", "fizmo" }; |
| |
| jclass stringClass = (*env)->FindClass(env, "java/lang/String"); |
| |
| if ((*env)->ExceptionOccurred(env) != NULL) { |
| return NULL; |
| } |
| |
| if (stringClass == NULL) { |
| throwException(env, "java/lang/AssertionError", |
| "class String not found"); |
| return NULL; |
| } |
| |
| jobjectArray result = (*env)->NewObjectArray(env, 100, stringClass, NULL); |
| |
| if (result == NULL) { |
| return NULL; |
| } |
| |
| jsize i; |
| for (i = 0; i < 3; i++) { |
| jstring s = (*env)->NewStringUTF(env, contents[i]); |
| |
| if (s == NULL) { |
| return NULL; |
| } |
| |
| (*env)->SetObjectArrayElement(env, result, indices[i], s); |
| |
| if ((*env)->ExceptionOccurred(env) != NULL) { |
| return NULL; |
| } |
| } |
| |
| return result; |
| } |
| |
| // @FastNative |
| // public static native String[] returnStringArrayFast(); |
| static jobjectArray StaticNonce_returnStringArrayFast(JNIEnv *env, |
| jclass clazz) { |
| return StaticNonce_returnStringArray(env, clazz); |
| } |
| |
| // public static native Class returnThisClass(); |
| static jclass StaticNonce_returnThisClass(JNIEnv *env, jclass clazz) { |
| return clazz; |
| } |
| |
| // @FastNative |
| // public static native Class returnThisClassFast(); |
| static jclass StaticNonce_returnThisClassFast(JNIEnv *env, jclass clazz) { |
| return clazz; |
| } |
| |
| // public static native StaticNonce returnInstance(); |
| static jobject StaticNonce_returnInstance(JNIEnv *env, jclass clazz) { |
| jmethodID id = (*env)->GetMethodID(env, clazz, "<init>", "()V"); |
| |
| if ((*env)->ExceptionOccurred(env) != NULL) { |
| return NULL; |
| } |
| |
| if (id == NULL) { |
| throwException(env, "java/lang/AssertionError", |
| "constructor not found"); |
| return NULL; |
| } |
| |
| return (*env)->NewObjectA(env, clazz, id, NULL); |
| } |
| |
| // @FastNative |
| // public static native StaticNonce returnInstanceFast(); |
| static jobject StaticNonce_returnInstanceFast(JNIEnv *env, jclass clazz) { |
| return StaticNonce_returnInstance(env, clazz); |
| } |
| |
| // public static native boolean takeBoolean(boolean v); |
| static jboolean StaticNonce_takeBoolean(JNIEnv *env, jclass clazz, |
| jboolean v) { |
| return v == true; |
| } |
| |
| // @FastNative |
| // public static native boolean takeBooleanFast(boolean v); |
| static jboolean StaticNonce_takeBooleanFast(JNIEnv *env, jclass clazz, |
| jboolean v) { |
| return v == true; |
| } |
| |
| // @CriticalNative |
| // public static native boolean takeBooleanCritical(boolean v); |
| static jboolean StaticNonce_takeBooleanCritical(jboolean v) { |
| return v == true; |
| } |
| |
| // public static native boolean takeByte(byte v); |
| static jboolean StaticNonce_takeByte(JNIEnv *env, jclass clazz, jbyte v) { |
| return v == -99; |
| } |
| |
| // @FastNative |
| // public static native boolean takeByteFast(byte v); |
| static jboolean StaticNonce_takeByteFast(JNIEnv *env, jclass clazz, jbyte v) { |
| return v == -99; |
| } |
| |
| // @CriticalNative |
| // public static native boolean takeByteCritical(byte v); |
| static jboolean StaticNonce_takeByteCritical(jbyte v) { |
| return v == -99; |
| } |
| |
| // public static native boolean takeShort(short v); |
| static jboolean StaticNonce_takeShort(JNIEnv *env, jclass clazz, jshort v) { |
| return v == 19991; |
| } |
| |
| // @FastNative |
| // public static native boolean takeShortFast(short v); |
| static jboolean StaticNonce_takeShortFast(JNIEnv *env, jclass clazz, |
| jshort v) { |
| return v == 19991; |
| } |
| |
| // @CriticalNative |
| // public static native boolean takeShortCritical(short v); |
| static jboolean StaticNonce_takeShortCritical(jshort v) { |
| return v == 19991; |
| } |
| |
| // public static native boolean takeChar(char v); |
| static jboolean StaticNonce_takeChar(JNIEnv *env, jclass clazz, jchar v) { |
| return v == 999; |
| } |
| |
| // @FastNative |
| // public static native boolean takeCharFast(char v); |
| static jboolean StaticNonce_takeCharFast(JNIEnv *env, jclass clazz, jchar v) { |
| return v == 999; |
| } |
| |
| // @CriticalNative |
| // public static native boolean takeCharCritical(char v); |
| static jboolean StaticNonce_takeCharCritical(jchar v) { |
| return v == 999; |
| } |
| |
| // public static native boolean takeInt(int v); |
| static jboolean StaticNonce_takeInt(JNIEnv *env, jclass clazz, jint v) { |
| return v == -999888777; |
| } |
| |
| // @FastNative |
| // public static native boolean takeIntFast(int v); |
| static jboolean StaticNonce_takeIntFast(JNIEnv *env, jclass clazz, jint v) { |
| return v == -999888777; |
| } |
| |
| // @CriticalNative |
| // public static native boolean takeIntCritical(int v); |
| static jboolean StaticNonce_takeIntCritical(jint v) { |
| return v == -999888777; |
| } |
| |
| // public static native boolean takeLong(long v); |
| static jboolean StaticNonce_takeLong(JNIEnv *env, jclass clazz, jlong v) { |
| return v == 999888777666555444LL; |
| } |
| |
| // @FastNative |
| // public static native boolean takeLongFast(long v); |
| static jboolean StaticNonce_takeLongFast(JNIEnv *env, jclass clazz, jlong v) { |
| return v == 999888777666555444LL; |
| } |
| |
| // @CriticalNative |
| // public static native boolean takeLongCritical(long v); |
| static jboolean StaticNonce_takeLongCritical(jlong v) { |
| return v == 999888777666555444LL; |
| } |
| |
| // public static native boolean takeFloat(float v); |
| static jboolean StaticNonce_takeFloat(JNIEnv *env, jclass clazz, jfloat v) { |
| return v == -9988.7766F; |
| } |
| |
| // @FastNative |
| // public static native boolean takeFloatFast(float v); |
| static jboolean StaticNonce_takeFloatFast(JNIEnv *env, jclass clazz, |
| jfloat v) { |
| return v == -9988.7766F; |
| } |
| |
| // @CriticalNative |
| // public static native boolean takeFloatCritical(float v); |
| static jboolean StaticNonce_takeFloatCritical(jfloat v) { |
| return v == -9988.7766F; |
| } |
| |
| // public static native boolean takeDouble(double v); |
| static jboolean StaticNonce_takeDouble(JNIEnv *env, jclass clazz, jdouble v) { |
| return v == 999888777.666555; |
| } |
| |
| // @FastNative |
| // public static native boolean takeDoubleFast(double v); |
| static jboolean StaticNonce_takeDoubleFast(JNIEnv *env, jclass clazz, |
| jdouble v) { |
| return v == 999888777.666555; |
| } |
| |
| // @CriticalNative |
| // public static native boolean takeDoubleCritical(double v); |
| static jboolean StaticNonce_takeDoubleCritical(jdouble v) { |
| return v == 999888777.666555; |
| } |
| |
| // public static native boolean takeNull(Object v); |
| static jboolean StaticNonce_takeNull(JNIEnv *env, jclass clazz, jobject v) { |
| return v == NULL; |
| } |
| |
| // @FastNative |
| // public static native boolean takeNullFast(Object v); |
| static jboolean StaticNonce_takeNullFast(JNIEnv *env, jclass clazz, |
| jobject v) { |
| return v == NULL; |
| } |
| |
| // public static native boolean takeString(String v); |
| static jboolean StaticNonce_takeString(JNIEnv *env, jclass clazz, jstring v) { |
| if (v == NULL) { |
| return false; |
| } |
| |
| const char *utf = (*env)->GetStringUTFChars(env, v, NULL); |
| jboolean result = (strcmp("fuzzbot", utf) == 0); |
| |
| (*env)->ReleaseStringUTFChars(env, v, utf); |
| return result; |
| } |
| |
| // @FastNative |
| // public static native boolean takeStringFast(String v); |
| static jboolean StaticNonce_takeStringFast(JNIEnv *env, jclass clazz, |
| jstring v) { |
| return StaticNonce_takeString(env, clazz, v); |
| } |
| |
| // public static native boolean takeThisClass(Class v); |
| static jboolean StaticNonce_takeThisClass(JNIEnv *env, jclass clazz, |
| jclass v) { |
| return (*env)->IsSameObject(env, clazz, v); |
| } |
| |
| // @FastNative |
| // public static native boolean takeThisClassFast(Class v); |
| static jboolean StaticNonce_takeThisClassFast(JNIEnv *env, jclass clazz, |
| jclass v) { |
| return (*env)->IsSameObject(env, clazz, v); |
| } |
| |
| // public static native boolean takeIntLong(int v1, long v2); |
| static jboolean StaticNonce_takeIntLong(JNIEnv *env, jclass clazz, |
| jint v1, jlong v2) { |
| return (v1 == 914) && (v2 == 9140914091409140914LL); |
| } |
| |
| // @FastNative |
| // public static native boolean takeIntLongFast(int v1, long v2); |
| static jboolean StaticNonce_takeIntLongFast(JNIEnv *env, jclass clazz, |
| jint v1, jlong v2) { |
| return (v1 == 914) && (v2 == 9140914091409140914LL); |
| } |
| |
| // @CriticalNative |
| // public static native boolean takeIntLongCritical(int v1, long v2); |
| static jboolean StaticNonce_takeIntLongCritical(jint v1, jlong v2) { |
| return (v1 == 914) && (v2 == 9140914091409140914LL); |
| } |
| |
| // public static native boolean takeLongInt(long v1, int v2); |
| static jboolean StaticNonce_takeLongInt(JNIEnv *env, jclass clazz, |
| jlong v1, jint v2) { |
| return (v1 == -4321LL) && (v2 == 12341234); |
| } |
| |
| // @FastNative |
| // public static native boolean takeLongIntFast(long v1, int v2); |
| static jboolean StaticNonce_takeLongIntFast(JNIEnv *env, jclass clazz, |
| jlong v1, jint v2) { |
| return (v1 == -4321LL) && (v2 == 12341234); |
| } |
| |
| // @CriticalNative |
| // public static native boolean takeLongIntCritical(long v1, int v2); |
| static jboolean StaticNonce_takeLongIntCritical(jlong v1, jint v2) { |
| return (v1 == -4321LL) && (v2 == 12341234); |
| } |
| |
| // public static native boolean takeOneOfEach(boolean v0, byte v1, short v2, |
| // char v3, int v4, long v5, String v6, float v7, double v8, |
| // int[] v9); |
| static jboolean StaticNonce_takeOneOfEach(JNIEnv *env, jclass clazz, |
| jboolean v0, jbyte v1, jshort v2, jchar v3, jint v4, jlong v5, |
| jstring v6, jfloat v7, jdouble v8, jintArray v9) { |
| jsize length; |
| jboolean result; |
| |
| if ((v0 != false) || (v1 != 1) || (v2 != 2) || (v3 != 3) || |
| (v4 != 4) || (v5 != 5) || (v7 != 7.0f) || (v8 != 8.0)) { |
| return false; |
| } |
| |
| length = (*env)->GetStringUTFLength(env, v6); |
| |
| if (length != 3) { |
| throwException(env, "java/lang/AssertionError", |
| "bad string length"); |
| return false; |
| } |
| |
| const char *utf = (*env)->GetStringUTFChars(env, v6, NULL); |
| result = (strncmp("six", utf, 3) == 0); |
| |
| (*env)->ReleaseStringUTFChars(env, v6, utf); |
| |
| if (! result) { |
| return false; |
| } |
| |
| length = (*env)->GetArrayLength(env, v9); |
| if (length != 2) { |
| throwException(env, "java/lang/AssertionError", |
| "bad array length"); |
| return false; |
| } |
| |
| jint *elements = (*env)->GetIntArrayElements(env, v9, NULL); |
| result = (elements[0] == 9) && (elements[1] == 10); |
| (*env)->ReleaseIntArrayElements(env, v9, elements, JNI_ABORT); |
| |
| return result; |
| } |
| |
| // public static native boolean takeOneOfEachDlsym(boolean v0, byte v1, |
| // short v2, char v3, int v4, long v5, String v6, float v7, double v8, |
| // int[] v9); |
| JNIEXPORT jboolean Java_android_jni_cts_StaticNonce_takeOneOfEachDlsym( |
| JNIEnv *env, jclass clazz, jboolean v0, jbyte v1, jshort v2, jchar v3, |
| jint v4, jlong v5, jstring v6, jfloat v7, jdouble v8, jintArray v9) { |
| return StaticNonce_takeOneOfEach( |
| env, clazz, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9); |
| } |
| |
| // @FastNative |
| // public static native boolean takeOneOfEachFast(boolean v0, byte v1, |
| // short v2, char v3, int v4, long v5, String v6, float v7, double v8, |
| // int[] v9); |
| static jboolean StaticNonce_takeOneOfEachFast(JNIEnv *env, jclass clazz, |
| jboolean v0, jbyte v1, jshort v2, jchar v3, jint v4, jlong v5, |
| jstring v6, jfloat v7, jdouble v8, jintArray v9) { |
| return StaticNonce_takeOneOfEach( |
| env, clazz, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9); |
| } |
| |
| // @FastNative |
| // public static native boolean takeOneOfEachFastDlsym(boolean v0, byte v1, |
| // short v2, char v3, int v4, long v5, String v6, float v7, double v8, |
| // int[] v9); |
| JNIEXPORT jboolean Java_android_jni_cts_StaticNonce_takeOneOfEachFastDlsym( |
| JNIEnv *env, jclass clazz, jboolean v0, jbyte v1, jshort v2, jchar v3, |
| jint v4, jlong v5, jstring v6, jfloat v7, jdouble v8, jintArray v9) { |
| return StaticNonce_takeOneOfEach( |
| env, clazz, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9); |
| } |
| |
| // @CriticalNative |
| // public static native boolean takeOneOfEachCritical(boolean v0, byte v1, |
| // short v2, char v3, int v4, long v5, float v6, double v7); |
| static jboolean StaticNonce_takeOneOfEachCritical( |
| jboolean v0, jbyte v1, jshort v2, jchar v3, jint v4, jlong v5, |
| jfloat v6, jdouble v7) { |
| return (v0 == false) && (v1 == 1) && (v2 == 2) && (v3 == 3) && |
| (v4 == 4) && (v5 == 5) && (v6 == 6.0f) && (v7 == 7.0); |
| } |
| |
| // @CriticalNative |
| // public static native boolean takeOneOfEachCriticalDlsym(boolean v0, byte v1, |
| // short v2, char v3, int v4, long v5, float v6, double v7); |
| JNIEXPORT jboolean Java_android_jni_cts_StaticNonce_takeOneOfEachCriticalDlsym( |
| jboolean v0, jbyte v1, jshort v2, jchar v3, jint v4, jlong v5, |
| jfloat v6, jdouble v7) { |
| return StaticNonce_takeOneOfEachCritical(v0, v1, v2, v3, v4, v5, v6, v7); |
| } |
| |
| // public static native boolean takeCoolHandLuke( |
| // int v1, int v2, int v3, int v4, |
| // int v5, int v6, int v7, int v8, int v9, |
| // int v10, int v11, int v12, int v13, int v14, |
| // int v15, int v16, int v17, int v18, int v19, |
| // int v20, int v21, int v22, int v23, int v24, |
| // int v25, int v26, int v27, int v28, int v29, |
| // int v30, int v31, int v32, int v33, int v34, |
| // int v35, int v36, int v37, int v38, int v39, |
| // int v40, int v41, int v42, int v43, int v44, |
| // int v45, int v46, int v47, int v48, int v49, |
| // int v50); |
| static jboolean StaticNonce_takeCoolHandLuke(JNIEnv *env, jclass clazz, |
| jint v1, jint v2, jint v3, jint v4, |
| jint v5, jint v6, jint v7, jint v8, jint v9, |
| jint v10, jint v11, jint v12, jint v13, jint v14, |
| jint v15, jint v16, jint v17, jint v18, jint v19, |
| jint v20, jint v21, jint v22, jint v23, jint v24, |
| jint v25, jint v26, jint v27, jint v28, jint v29, |
| jint v30, jint v31, jint v32, jint v33, jint v34, |
| jint v35, jint v36, jint v37, jint v38, jint v39, |
| jint v40, jint v41, jint v42, jint v43, jint v44, |
| jint v45, jint v46, jint v47, jint v48, jint v49, |
| jint v50) { |
| return (v1 == 1) && (v2 == 2) && (v3 == 3) && |
| (v4 == 4) && (v5 == 5) && (v6 == 6) && (v7 == 7) && |
| (v8 == 8) && (v9 == 9) && |
| (v10 == 10) && (v11 == 11) && (v12 == 12) && (v13 == 13) && |
| (v14 == 14) && (v15 == 15) && (v16 == 16) && (v17 == 17) && |
| (v18 == 18) && (v19 == 19) && |
| (v20 == 20) && (v21 == 21) && (v22 == 22) && (v23 == 23) && |
| (v24 == 24) && (v25 == 25) && (v26 == 26) && (v27 == 27) && |
| (v28 == 28) && (v29 == 29) && |
| (v30 == 30) && (v31 == 31) && (v32 == 32) && (v33 == 33) && |
| (v34 == 34) && (v35 == 35) && (v36 == 36) && (v37 == 37) && |
| (v38 == 38) && (v39 == 39) && |
| (v40 == 40) && (v41 == 41) && (v42 == 42) && (v43 == 43) && |
| (v44 == 44) && (v45 == 45) && (v46 == 46) && (v47 == 47) && |
| (v48 == 48) && (v49 == 49) && |
| (v50 == 50); |
| } |
| |
| // @FastNative |
| // public static native boolean takeCoolHandLukeFast( |
| // int v1, int v2, int v3, int v4, |
| // int v5, int v6, int v7, int v8, int v9, |
| // int v10, int v11, int v12, int v13, int v14, |
| // int v15, int v16, int v17, int v18, int v19, |
| // int v20, int v21, int v22, int v23, int v24, |
| // int v25, int v26, int v27, int v28, int v29, |
| // int v30, int v31, int v32, int v33, int v34, |
| // int v35, int v36, int v37, int v38, int v39, |
| // int v40, int v41, int v42, int v43, int v44, |
| // int v45, int v46, int v47, int v48, int v49, |
| // int v50); |
| static jboolean StaticNonce_takeCoolHandLukeFast(JNIEnv *env, jclass clazz, |
| jint v1, jint v2, jint v3, jint v4, |
| jint v5, jint v6, jint v7, jint v8, jint v9, |
| jint v10, jint v11, jint v12, jint v13, jint v14, |
| jint v15, jint v16, jint v17, jint v18, jint v19, |
| jint v20, jint v21, jint v22, jint v23, jint v24, |
| jint v25, jint v26, jint v27, jint v28, jint v29, |
| jint v30, jint v31, jint v32, jint v33, jint v34, |
| jint v35, jint v36, jint v37, jint v38, jint v39, |
| jint v40, jint v41, jint v42, jint v43, jint v44, |
| jint v45, jint v46, jint v47, jint v48, jint v49, |
| jint v50) { |
| return StaticNonce_takeCoolHandLuke( |
| env, clazz, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, |
| v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, |
| v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, |
| v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, |
| v41, v42, v43, v44, v45, v46, v47, v48, v49, v50); |
| } |
| |
| // @CriticalNative |
| // public static native boolean takeCoolHandLukeCritical( |
| // int v1, int v2, int v3, int v4, |
| // int v5, int v6, int v7, int v8, int v9, |
| // int v10, int v11, int v12, int v13, int v14, |
| // int v15, int v16, int v17, int v18, int v19, |
| // int v20, int v21, int v22, int v23, int v24, |
| // int v25, int v26, int v27, int v28, int v29, |
| // int v30, int v31, int v32, int v33, int v34, |
| // int v35, int v36, int v37, int v38, int v39, |
| // int v40, int v41, int v42, int v43, int v44, |
| // int v45, int v46, int v47, int v48, int v49, |
| // int v50); |
| static jboolean StaticNonce_takeCoolHandLukeCritical( |
| jint v1, jint v2, jint v3, jint v4, |
| jint v5, jint v6, jint v7, jint v8, jint v9, |
| jint v10, jint v11, jint v12, jint v13, jint v14, |
| jint v15, jint v16, jint v17, jint v18, jint v19, |
| jint v20, jint v21, jint v22, jint v23, jint v24, |
| jint v25, jint v26, jint v27, jint v28, jint v29, |
| jint v30, jint v31, jint v32, jint v33, jint v34, |
| jint v35, jint v36, jint v37, jint v38, jint v39, |
| jint v40, jint v41, jint v42, jint v43, jint v44, |
| jint v45, jint v46, jint v47, jint v48, jint v49, |
| jint v50) { |
| return StaticNonce_takeCoolHandLuke( |
| NULL, NULL, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, |
| v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, |
| v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, |
| v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, |
| v41, v42, v43, v44, v45, v46, v47, v48, v49, v50); |
| } |
| |
| static JNINativeMethod methods[] = { |
| // name, signature, function |
| { "nop", "()V", StaticNonce_nop }, |
| { "nopFast", "()V", StaticNonce_nopFast }, |
| { "nopCritical", "()V", StaticNonce_nopCritical }, |
| { "returnBoolean", "()Z", StaticNonce_returnBoolean }, |
| { "returnBooleanFast", "()Z", StaticNonce_returnBooleanFast }, |
| { "returnBooleanCritical", "()Z", StaticNonce_returnBooleanCritical }, |
| { "returnByte", "()B", StaticNonce_returnByte }, |
| { "returnByteFast", "()B", StaticNonce_returnByteFast }, |
| { "returnByteCritical", "()B", StaticNonce_returnByteCritical }, |
| { "returnShort", "()S", StaticNonce_returnShort }, |
| { "returnShortFast", "()S", StaticNonce_returnShortFast }, |
| { "returnShortCritical", "()S", StaticNonce_returnShortCritical }, |
| { "returnChar", "()C", StaticNonce_returnChar }, |
| { "returnCharFast", "()C", StaticNonce_returnCharFast }, |
| { "returnCharCritical", "()C", StaticNonce_returnCharCritical }, |
| { "returnInt", "()I", StaticNonce_returnInt }, |
| { "returnIntFast", "()I", StaticNonce_returnIntFast }, |
| { "returnIntCritical", "()I", StaticNonce_returnIntCritical }, |
| { "returnLong", "()J", StaticNonce_returnLong }, |
| { "returnLongFast", "()J", StaticNonce_returnLongFast }, |
| { "returnLongCritical", "()J", StaticNonce_returnLongCritical }, |
| { "returnFloat", "()F", StaticNonce_returnFloat }, |
| { "returnFloatFast", "()F", StaticNonce_returnFloatFast }, |
| { "returnFloatCritical", "()F", StaticNonce_returnFloatCritical }, |
| { "returnDouble", "()D", StaticNonce_returnDouble }, |
| { "returnDoubleFast", "()D", StaticNonce_returnDoubleFast }, |
| { "returnDoubleCritical", "()D", StaticNonce_returnDoubleCritical }, |
| { "returnNull", "()Ljava/lang/Object;", StaticNonce_returnNull }, |
| { "returnNullFast", "()Ljava/lang/Object;", |
| StaticNonce_returnNullFast }, |
| { "returnString", "()Ljava/lang/String;", StaticNonce_returnString }, |
| { "returnStringFast", "()Ljava/lang/String;", |
| StaticNonce_returnStringFast }, |
| { "returnShortArray", "()[S", StaticNonce_returnShortArray }, |
| { "returnShortArrayFast", "()[S", StaticNonce_returnShortArrayFast }, |
| { "returnStringArray", "()[Ljava/lang/String;", |
| StaticNonce_returnStringArray }, |
| { "returnStringArrayFast", "()[Ljava/lang/String;", |
| StaticNonce_returnStringArrayFast }, |
| { "returnThisClass", "()Ljava/lang/Class;", |
| StaticNonce_returnThisClass }, |
| { "returnThisClassFast", "()Ljava/lang/Class;", |
| StaticNonce_returnThisClassFast }, |
| { "returnInstance", "()Landroid/jni/cts/StaticNonce;", |
| StaticNonce_returnInstance }, |
| { "returnInstanceFast", "()Landroid/jni/cts/StaticNonce;", |
| StaticNonce_returnInstanceFast }, |
| { "takeBoolean", "(Z)Z", StaticNonce_takeBoolean }, |
| { "takeBooleanFast", "(Z)Z", StaticNonce_takeBooleanFast }, |
| { "takeBooleanCritical", "(Z)Z", StaticNonce_takeBooleanCritical }, |
| { "takeByte", "(B)Z", StaticNonce_takeByte }, |
| { "takeByteFast", "(B)Z", StaticNonce_takeByteFast }, |
| { "takeByteCritical", "(B)Z", StaticNonce_takeByteCritical }, |
| { "takeShort", "(S)Z", StaticNonce_takeShort }, |
| { "takeShortFast", "(S)Z", StaticNonce_takeShortFast }, |
| { "takeShortCritical", "(S)Z", StaticNonce_takeShortCritical }, |
| { "takeChar", "(C)Z", StaticNonce_takeChar }, |
| { "takeCharFast", "(C)Z", StaticNonce_takeCharFast }, |
| { "takeCharCritical", "(C)Z", StaticNonce_takeCharCritical }, |
| { "takeInt", "(I)Z", StaticNonce_takeInt }, |
| { "takeIntFast", "(I)Z", StaticNonce_takeIntFast }, |
| { "takeIntCritical", "(I)Z", StaticNonce_takeIntCritical }, |
| { "takeLong", "(J)Z", StaticNonce_takeLong }, |
| { "takeLongFast", "(J)Z", StaticNonce_takeLongFast }, |
| { "takeLongCritical", "(J)Z", StaticNonce_takeLongCritical }, |
| { "takeFloat", "(F)Z", StaticNonce_takeFloat }, |
| { "takeFloatFast", "(F)Z", StaticNonce_takeFloatFast }, |
| { "takeFloatCritical", "(F)Z", StaticNonce_takeFloatCritical }, |
| { "takeDouble", "(D)Z", StaticNonce_takeDouble }, |
| { "takeDoubleFast", "(D)Z", StaticNonce_takeDoubleFast }, |
| { "takeDoubleCritical", "(D)Z", StaticNonce_takeDoubleCritical }, |
| { "takeNull", "(Ljava/lang/Object;)Z", StaticNonce_takeNull }, |
| { "takeNullFast", "(Ljava/lang/Object;)Z", StaticNonce_takeNullFast }, |
| { "takeString", "(Ljava/lang/String;)Z", StaticNonce_takeString }, |
| { "takeStringFast", "(Ljava/lang/String;)Z", |
| StaticNonce_takeStringFast }, |
| { "takeThisClass", "(Ljava/lang/Class;)Z", StaticNonce_takeThisClass }, |
| { "takeThisClassFast", "(Ljava/lang/Class;)Z", |
| StaticNonce_takeThisClassFast }, |
| { "takeIntLong", "(IJ)Z", StaticNonce_takeIntLong }, |
| { "takeIntLongFast", "(IJ)Z", StaticNonce_takeIntLongFast }, |
| { "takeIntLongCritical", "(IJ)Z", StaticNonce_takeIntLongCritical }, |
| { "takeLongInt", "(JI)Z", StaticNonce_takeLongInt }, |
| { "takeLongIntFast", "(JI)Z", StaticNonce_takeLongIntFast }, |
| { "takeLongIntCritical", "(JI)Z", StaticNonce_takeLongIntCritical }, |
| { "takeOneOfEach", "(ZBSCIJLjava/lang/String;FD[I)Z", |
| StaticNonce_takeOneOfEach }, |
| { "takeOneOfEachFast", "(ZBSCIJLjava/lang/String;FD[I)Z", |
| StaticNonce_takeOneOfEachFast }, |
| { "takeOneOfEachCritical", "(ZBSCIJFD)Z", |
| StaticNonce_takeOneOfEachCritical }, |
| { "takeCoolHandLuke", |
| "(IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII)Z", |
| StaticNonce_takeCoolHandLuke }, |
| { "takeCoolHandLukeFast", |
| "(IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII)Z", |
| StaticNonce_takeCoolHandLukeFast }, |
| { "takeCoolHandLukeCritical", |
| "(IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII)Z", |
| StaticNonce_takeCoolHandLukeCritical }, |
| }; |
| |
| int register_StaticNonce(JNIEnv *env) { |
| return registerJniMethods( |
| env, "android/jni/cts/StaticNonce", |
| methods, sizeof(methods) / sizeof(JNINativeMethod)); |
| } |