28 static jclass test_class_A;

    29 static jclass test_class_B;

    30 

    31 static jmethodID test_staticM_id;

    32 static jmethodID test_staticS_id;

    33 static jmethodID test_staticN_id;

    34 static jmethodID test_A_m_id;

    35 

    36 static jfieldID test_staticF_id;

    37 static jfieldID test_A_f_id;

    38 

    50     JNIEXPORT jboolean JNICALL Java_ClassInitBarrier_00024Test_00024A_init(JNIEnv* env, jclass cls, jclass arg1) {

    51         test_class_A = (jclass)env->NewGlobalRef(cls);

    52         if (test_class_A == NULL)  return JNI_FALSE;

    53 

    54         test_class_B = (jclass)env->NewGlobalRef(arg1);

    55         if (test_class_B == NULL)  return JNI_FALSE;

    56 

    57         test_staticM_id = env->GetStaticMethodID(test_class_A, "staticM", "(Ljava/lang/Runnable;)V");

    58         if (test_staticM_id == NULL)  return JNI_FALSE;

    59 

    60         test_staticS_id = env->GetStaticMethodID(test_class_A, "staticS", "(Ljava/lang/Runnable;)V");

    61         if (test_staticS_id == NULL)  return JNI_FALSE;

    62 

    63         test_staticN_id = env->GetStaticMethodID(test_class_A, "staticN", "(Ljava/lang/Runnable;)V");

    64         if (test_staticN_id == NULL)  return JNI_FALSE;

    65 

    66         test_A_m_id = env->GetMethodID(test_class_A, "m", "()V");

    67         if (test_A_m_id == NULL)  return JNI_FALSE;

    68 

    69         test_staticF_id = env->GetStaticFieldID(test_class_A, "staticF", "I");

    70         if (test_staticF_id == NULL)  return JNI_FALSE;

    71 

    72         test_A_f_id = env->GetFieldID(test_class_A, "f", "I");

    73         if (test_A_f_id == NULL)  return JNI_FALSE;

    74 

    75         return JNI_TRUE;

    76     }

    77 

    81 

    82     JNIEXPORT void JNICALL Java_ClassInitBarrier_00024Test_testInvokeStaticJNI(JNIEnv* env, jclass cls, jobject action) {

    83         env->CallStaticVoidMethod(test_class_A, test_staticM_id, action);

    84     }

    85 

    86     JNIEXPORT void JNICALL Java_ClassInitBarrier_00024Test_testInvokeStaticSyncJNI(JNIEnv* env, jclass cls, jobject action) {

    87         env->CallStaticVoidMethod(test_class_A, test_staticS_id, action);

    88     }

    89 

    90     JNIEXPORT void JNICALL Java_ClassInitBarrier_00024Test_testInvokeStaticNativeJNI(JNIEnv* env, jclass cls, jobject action) {

    91         env->CallStaticVoidMethod(test_class_A, test_staticN_id, action);

    92     }

    93 

    94     JNIEXPORT jint JNICALL Java_ClassInitBarrier_00024Test_testGetStaticJNI(JNIEnv* env, jclass cls, jobject action) {

    95         jint v = env->GetStaticIntField(test_class_A, test_staticF_id); // int v = A.staticF;

    96         env->CallVoidMethod(action, methodId);                          // action.run();

    97         return v;

    98     }

    99 

   100     JNIEXPORT void JNICALL Java_ClassInitBarrier_00024Test_testPutStaticJNI(JNIEnv* env, jclass cls, jobject action) {

   101         env->SetStaticIntField(test_class_A, test_staticF_id, 1); // A.staticF = 1;

   102         env->CallVoidMethod(action, methodId);                    // action.run();

   103     }

   104 

   105     JNIEXPORT jobject JNICALL Java_ClassInitBarrier_00024Test_testNewInstanceAJNI(JNIEnv* env, jclass cls, jobject action) {

   106         jobject obj = env->AllocObject(test_class_A); // A obj = new A();

   107         if (env->ExceptionOccurred()) {

   108           return NULL;

   109         } else if (obj == NULL) {

   110           jclass errorClass = env->FindClass("java/lang/AssertionError");

   111           int ret = env->ThrowNew(errorClass, "JNI: AllocObject: allocation failed, but no exception thrown");

   112           return NULL;

   113         }

   114         env->CallVoidMethod(action, methodId);        // action.run();

   115         return obj;

   116     }

   117 

   118     JNIEXPORT jobject JNICALL Java_ClassInitBarrier_00024Test_testNewInstanceBJNI(JNIEnv* env, jclass cls, jobject action) {

   119         jobject obj = env->AllocObject(test_class_B); // B obj = new B();

   120         if (env->ExceptionOccurred()) {

   121           return NULL;

   122         } else if (obj == NULL) {

   123           jclass errorClass = env->FindClass("java/lang/AssertionError");

   124           int ret = env->ThrowNew(errorClass, "JNI: AllocObject: allocation failed, but no exception thrown");

   125           return NULL;

   126         }

   127         env->CallVoidMethod(action, methodId);        // action.run();

   128         return obj;

   129     }

   130 

   131     JNIEXPORT jint JNICALL Java_ClassInitBarrier_00024Test_testGetFieldJNI(JNIEnv* env, jclass cls, jobject recv, jobject action) {

   132         jint v = env->GetIntField(recv, test_A_f_id); // int v = recv.f;

   133         env->CallVoidMethod(action, methodId);        // action.run();

   134         return v;

   135     }

   136 

   137     JNIEXPORT void JNICALL Java_ClassInitBarrier_00024Test_testPutFieldJNI(JNIEnv* env, jclass cls, jobject recv, jobject action) {

   138         env->SetIntField(recv, test_A_f_id, 1); // A.staticF = 1;

   139         env->CallVoidMethod(action, methodId);  // action.run();

   140     }

   141 

   142     JNIEXPORT void JNICALL Java_ClassInitBarrier_00024Test_testInvokeVirtualJNI(JNIEnv* env, jclass cls, jobject recv, jobject action) {

   143         env->CallVoidMethod(recv, test_A_m_id); // recv.m();

   144         if (env->ExceptionOccurred()) {

   145             return;

   146         }

   147         env->CallVoidMethod(action, methodId);  // action.run();

   148     }