1 /*
2  * Copyright (C) 2013 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 #include <iostream>
18 #include <pthread.h>
19 #include <stdio.h>
20 #include <vector>
21 
22 #include "art_method-inl.h"
23 #include "base/logging.h"
24 #include "jni.h"
25 
26 namespace art {
27 
28 static JavaVM* jvm = nullptr;
29 
JNI_OnLoad(JavaVM * vm,void *)30 extern "C" JNIEXPORT jint JNI_OnLoad(JavaVM *vm, void*) {
31   CHECK(vm != nullptr);
32   CHECK(jvm == nullptr);
33   jvm = vm;
34   std::cout << "JNI_OnLoad called" << std::endl;
35   return JNI_VERSION_1_6;
36 }
37 
JNI_OnUnload(JavaVM *,void *)38 extern "C" JNIEXPORT void JNI_OnUnload(JavaVM*, void*) {
39   // std::cout since LOG(INFO) adds extra stuff like pid.
40   std::cout << "JNI_OnUnload called" << std::endl;
41   // Clear jvm for CHECK in test 004-JniTest.
42   jvm = nullptr;
43 }
44 
AttachHelper(void * arg)45 static void* AttachHelper(void* arg) {
46   CHECK(jvm != nullptr);
47 
48   JNIEnv* env = nullptr;
49   JavaVMAttachArgs args = { JNI_VERSION_1_6, __FUNCTION__, nullptr };
50   int attach_result = jvm->AttachCurrentThread(&env, &args);
51   CHECK_EQ(attach_result, 0);
52 
53   typedef void (*Fn)(JNIEnv*);
54   Fn fn = reinterpret_cast<Fn>(arg);
55   fn(env);
56 
57   int detach_result = jvm->DetachCurrentThread();
58   CHECK_EQ(detach_result, 0);
59   return nullptr;
60 }
61 
PthreadHelper(void (* fn)(JNIEnv *))62 static void PthreadHelper(void (*fn)(JNIEnv*)) {
63   pthread_t pthread;
64   int pthread_create_result = pthread_create(&pthread, nullptr, AttachHelper,
65                                              reinterpret_cast<void*>(fn));
66   CHECK_EQ(pthread_create_result, 0);
67   int pthread_join_result = pthread_join(pthread, nullptr);
68   CHECK_EQ(pthread_join_result, 0);
69 }
70 
testFindClassOnAttachedNativeThread(JNIEnv * env)71 static void testFindClassOnAttachedNativeThread(JNIEnv* env) {
72   jclass clazz = env->FindClass("Main");
73   CHECK(clazz != nullptr);
74   CHECK(!env->ExceptionCheck());
75 
76   jobjectArray array = env->NewObjectArray(0, clazz, nullptr);
77   CHECK(array != nullptr);
78   CHECK(!env->ExceptionCheck());
79 }
80 
81 // http://b/10994325
Java_Main_testFindClassOnAttachedNativeThread(JNIEnv *,jclass)82 extern "C" JNIEXPORT void JNICALL Java_Main_testFindClassOnAttachedNativeThread(JNIEnv*, jclass) {
83   PthreadHelper(&testFindClassOnAttachedNativeThread);
84 }
85 
testFindFieldOnAttachedNativeThread(JNIEnv * env)86 static void testFindFieldOnAttachedNativeThread(JNIEnv* env) {
87   jclass clazz = env->FindClass("Main");
88   CHECK(clazz != nullptr);
89   CHECK(!env->ExceptionCheck());
90 
91   jfieldID field = env->GetStaticFieldID(clazz, "testFindFieldOnAttachedNativeThreadField", "Z");
92   CHECK(field != nullptr);
93   CHECK(!env->ExceptionCheck());
94 
95   env->SetStaticBooleanField(clazz, field, JNI_TRUE);
96 }
97 
Java_Main_testFindFieldOnAttachedNativeThreadNative(JNIEnv *,jclass)98 extern "C" JNIEXPORT void JNICALL Java_Main_testFindFieldOnAttachedNativeThreadNative(JNIEnv*,
99                                                                                       jclass) {
100   PthreadHelper(&testFindFieldOnAttachedNativeThread);
101 }
102 
testReflectFieldGetFromAttachedNativeThread(JNIEnv * env)103 static void testReflectFieldGetFromAttachedNativeThread(JNIEnv* env) {
104   jclass clazz = env->FindClass("Main");
105   CHECK(clazz != nullptr);
106   CHECK(!env->ExceptionCheck());
107 
108   jclass class_clazz = env->FindClass("java/lang/Class");
109   CHECK(class_clazz != nullptr);
110   CHECK(!env->ExceptionCheck());
111 
112   jmethodID getFieldMetodId = env->GetMethodID(class_clazz, "getField",
113                                                "(Ljava/lang/String;)Ljava/lang/reflect/Field;");
114   CHECK(getFieldMetodId != nullptr);
115   CHECK(!env->ExceptionCheck());
116 
117   jstring field_name = env->NewStringUTF("testReflectFieldGetFromAttachedNativeThreadField");
118   CHECK(field_name != nullptr);
119   CHECK(!env->ExceptionCheck());
120 
121   jobject field = env->CallObjectMethod(clazz, getFieldMetodId, field_name);
122   CHECK(field != nullptr);
123   CHECK(!env->ExceptionCheck());
124 
125   jclass field_clazz = env->FindClass("java/lang/reflect/Field");
126   CHECK(field_clazz != nullptr);
127   CHECK(!env->ExceptionCheck());
128 
129   jmethodID getBooleanMetodId = env->GetMethodID(field_clazz, "getBoolean",
130                                                  "(Ljava/lang/Object;)Z");
131   CHECK(getBooleanMetodId != nullptr);
132   CHECK(!env->ExceptionCheck());
133 
134   jboolean value = env->CallBooleanMethod(field, getBooleanMetodId, /* ignored */ clazz);
135   CHECK(value == false);
136   CHECK(!env->ExceptionCheck());
137 }
138 
139 // http://b/15539150
Java_Main_testReflectFieldGetFromAttachedNativeThreadNative(JNIEnv *,jclass)140 extern "C" JNIEXPORT void JNICALL Java_Main_testReflectFieldGetFromAttachedNativeThreadNative(
141     JNIEnv*, jclass) {
142   PthreadHelper(&testReflectFieldGetFromAttachedNativeThread);
143 }
144 
145 
146 // http://b/11243757
Java_Main_testCallStaticVoidMethodOnSubClassNative(JNIEnv * env,jclass)147 extern "C" JNIEXPORT void JNICALL Java_Main_testCallStaticVoidMethodOnSubClassNative(JNIEnv* env,
148                                                                                      jclass) {
149   jclass super_class = env->FindClass("Main$testCallStaticVoidMethodOnSubClass_SuperClass");
150   CHECK(super_class != nullptr);
151 
152   jmethodID execute = env->GetStaticMethodID(super_class, "execute", "()V");
153   CHECK(execute != nullptr);
154 
155   jclass sub_class = env->FindClass("Main$testCallStaticVoidMethodOnSubClass_SubClass");
156   CHECK(sub_class != nullptr);
157 
158   env->CallStaticVoidMethod(sub_class, execute);
159 }
160 
Java_Main_testGetMirandaMethodNative(JNIEnv * env,jclass)161 extern "C" JNIEXPORT jobject JNICALL Java_Main_testGetMirandaMethodNative(JNIEnv* env, jclass) {
162   jclass abstract_class = env->FindClass("Main$testGetMirandaMethod_MirandaAbstract");
163   CHECK(abstract_class != nullptr);
164   jmethodID miranda_method = env->GetMethodID(abstract_class, "inInterface", "()Z");
165   CHECK(miranda_method != nullptr);
166   return env->ToReflectedMethod(abstract_class, miranda_method, JNI_FALSE);
167 }
168 
169 // https://code.google.com/p/android/issues/detail?id=63055
Java_Main_testZeroLengthByteBuffers(JNIEnv * env,jclass)170 extern "C" void JNICALL Java_Main_testZeroLengthByteBuffers(JNIEnv* env, jclass) {
171   std::vector<uint8_t> buffer(1);
172   jobject byte_buffer = env->NewDirectByteBuffer(&buffer[0], 0);
173   CHECK(byte_buffer != nullptr);
174   CHECK(!env->ExceptionCheck());
175 
176   CHECK_EQ(env->GetDirectBufferAddress(byte_buffer), &buffer[0]);
177   CHECK_EQ(env->GetDirectBufferCapacity(byte_buffer), 0);
178 }
179 
180 constexpr size_t kByteReturnSize = 7;
181 jbyte byte_returns[kByteReturnSize] = { 0, 1, 2, 127, -1, -2, -128 };
182 
Java_Main_byteMethod(JNIEnv *,jclass,jbyte b1,jbyte b2,jbyte b3,jbyte b4,jbyte b5,jbyte b6,jbyte b7,jbyte b8,jbyte b9,jbyte b10)183 extern "C" jbyte JNICALL Java_Main_byteMethod(JNIEnv*, jclass, jbyte b1, jbyte b2,
184                                               jbyte b3, jbyte b4, jbyte b5, jbyte b6,
185                                               jbyte b7, jbyte b8, jbyte b9, jbyte b10) {
186   // We use b1 to drive the output.
187   CHECK_EQ(b2, 2);
188   CHECK_EQ(b3, -3);
189   CHECK_EQ(b4, 4);
190   CHECK_EQ(b5, -5);
191   CHECK_EQ(b6, 6);
192   CHECK_EQ(b7, -7);
193   CHECK_EQ(b8, 8);
194   CHECK_EQ(b9, -9);
195   CHECK_EQ(b10, 10);
196 
197   CHECK_LE(0, b1);
198   CHECK_LT(b1, static_cast<jbyte>(kByteReturnSize));
199 
200   return byte_returns[b1];
201 }
202 
203 constexpr size_t kShortReturnSize = 9;
204 jshort short_returns[kShortReturnSize] = { 0, 1, 2, 127, 32767, -1, -2, -128,
205     static_cast<jshort>(0x8000) };
206 // The weird static_cast is because short int is only guaranteed down to -32767, not Java's -32768.
207 
Java_Main_shortMethod(JNIEnv *,jclass,jshort s1,jshort s2,jshort s3,jshort s4,jshort s5,jshort s6,jshort s7,jshort s8,jshort s9,jshort s10)208 extern "C" jshort JNICALL Java_Main_shortMethod(JNIEnv*, jclass, jshort s1, jshort s2,
209                                                 jshort s3, jshort s4, jshort s5, jshort s6,
210                                                 jshort s7, jshort s8, jshort s9, jshort s10) {
211   // We use s1 to drive the output.
212   CHECK_EQ(s2, 2);
213   CHECK_EQ(s3, -3);
214   CHECK_EQ(s4, 4);
215   CHECK_EQ(s5, -5);
216   CHECK_EQ(s6, 6);
217   CHECK_EQ(s7, -7);
218   CHECK_EQ(s8, 8);
219   CHECK_EQ(s9, -9);
220   CHECK_EQ(s10, 10);
221 
222   CHECK_LE(0, s1);
223   CHECK_LT(s1, static_cast<jshort>(kShortReturnSize));
224 
225   return short_returns[s1];
226 }
227 
Java_Main_booleanMethod(JNIEnv *,jclass,jboolean b1,jboolean b2,jboolean b3,jboolean b4,jboolean b5,jboolean b6,jboolean b7,jboolean b8,jboolean b9,jboolean b10)228 extern "C" jboolean JNICALL Java_Main_booleanMethod(JNIEnv*, jclass, jboolean b1,
229                                                     jboolean b2, jboolean b3, jboolean b4,
230                                                     jboolean b5, jboolean b6, jboolean b7,
231                                                     jboolean b8, jboolean b9, jboolean b10) {
232   // We use b1 to drive the output.
233   CHECK_EQ(b2, JNI_TRUE);
234   CHECK_EQ(b3, JNI_FALSE);
235   CHECK_EQ(b4, JNI_TRUE);
236   CHECK_EQ(b5, JNI_FALSE);
237   CHECK_EQ(b6, JNI_TRUE);
238   CHECK_EQ(b7, JNI_FALSE);
239   CHECK_EQ(b8, JNI_TRUE);
240   CHECK_EQ(b9, JNI_FALSE);
241   CHECK_EQ(b10, JNI_TRUE);
242 
243   CHECK(b1 == JNI_TRUE || b1 == JNI_FALSE);
244   return b1;
245 }
246 
247 constexpr size_t kCharReturnSize = 8;
248 jchar char_returns[kCharReturnSize] = { 0, 1, 2, 127, 255, 256, 15000, 34000 };
249 
Java_Main_charMethod(JNIEnv *,jclass,jchar c1,jchar c2,jchar c3,jchar c4,jchar c5,jchar c6,jchar c7,jchar c8,jchar c9,jchar c10)250 extern "C" jchar JNICALL Java_Main_charMethod(JNIEnv*, jclass, jchar c1, jchar c2,
251                                               jchar c3, jchar c4, jchar c5, jchar c6, jchar c7,
252                                               jchar c8, jchar c9, jchar c10) {
253   // We use c1 to drive the output.
254   CHECK_EQ(c2, 'a');
255   CHECK_EQ(c3, 'b');
256   CHECK_EQ(c4, 'c');
257   CHECK_EQ(c5, '0');
258   CHECK_EQ(c6, '1');
259   CHECK_EQ(c7, '2');
260   CHECK_EQ(c8, 1234);
261   CHECK_EQ(c9, 2345);
262   CHECK_EQ(c10, 3456);
263 
264   CHECK_LT(c1, static_cast<jchar>(kCharReturnSize));
265 
266   return char_returns[c1];
267 }
268 
Java_Main_removeLocalObject(JNIEnv * env,jclass,jclass o)269 extern "C" JNIEXPORT void JNICALL Java_Main_removeLocalObject(JNIEnv* env, jclass, jclass o) {
270   // Delete the arg to see if it crashes.
271   env->DeleteLocalRef(o);
272 }
273 
Java_Main_nativeIsAssignableFrom(JNIEnv * env,jclass,jclass from,jclass to)274 extern "C" JNIEXPORT jboolean JNICALL Java_Main_nativeIsAssignableFrom(JNIEnv* env, jclass,
275                                                                        jclass from, jclass to) {
276   return env->IsAssignableFrom(from, to);
277 }
278 
testShallowGetCallingClassLoader(JNIEnv * env)279 static void testShallowGetCallingClassLoader(JNIEnv* env) {
280   // Test direct call.
281   {
282     jclass vmstack_clazz = env->FindClass("dalvik/system/VMStack");
283     CHECK(vmstack_clazz != nullptr);
284     CHECK(!env->ExceptionCheck());
285 
286     jmethodID getCallingClassLoaderMethodId = env->GetStaticMethodID(vmstack_clazz,
287                                                                      "getCallingClassLoader",
288                                                                      "()Ljava/lang/ClassLoader;");
289     CHECK(getCallingClassLoaderMethodId != nullptr);
290     CHECK(!env->ExceptionCheck());
291 
292     jobject class_loader = env->CallStaticObjectMethod(vmstack_clazz,
293                                                        getCallingClassLoaderMethodId);
294     CHECK(class_loader == nullptr);
295     CHECK(!env->ExceptionCheck());
296   }
297 
298   // Test one-level call. Use System.loadLibrary().
299   {
300     jclass system_clazz = env->FindClass("java/lang/System");
301     CHECK(system_clazz != nullptr);
302     CHECK(!env->ExceptionCheck());
303 
304     jmethodID loadLibraryMethodId = env->GetStaticMethodID(system_clazz, "loadLibrary",
305                                                            "(Ljava/lang/String;)V");
306     CHECK(loadLibraryMethodId != nullptr);
307     CHECK(!env->ExceptionCheck());
308 
309     // Create a string object.
310     jobject library_string = env->NewStringUTF("non_existing_library");
311     CHECK(library_string != nullptr);
312     CHECK(!env->ExceptionCheck());
313 
314     env->CallStaticVoidMethod(system_clazz, loadLibraryMethodId, library_string);
315     CHECK(env->ExceptionCheck());
316 
317     // We expect UnsatisfiedLinkError.
318     jthrowable thrown = env->ExceptionOccurred();
319     env->ExceptionClear();
320 
321     jclass unsatisfied_link_error_clazz = env->FindClass("java/lang/UnsatisfiedLinkError");
322     jclass thrown_class = env->GetObjectClass(thrown);
323     CHECK(env->IsSameObject(unsatisfied_link_error_clazz, thrown_class));
324   }
325 }
326 
327 // http://b/16867274
Java_Main_nativeTestShallowGetCallingClassLoader(JNIEnv *,jclass)328 extern "C" JNIEXPORT void JNICALL Java_Main_nativeTestShallowGetCallingClassLoader(JNIEnv*,
329                                                                                    jclass) {
330   PthreadHelper(&testShallowGetCallingClassLoader);
331 }
332 
testShallowGetStackClass2(JNIEnv * env)333 static void testShallowGetStackClass2(JNIEnv* env) {
334   jclass vmstack_clazz = env->FindClass("dalvik/system/VMStack");
335   CHECK(vmstack_clazz != nullptr);
336   CHECK(!env->ExceptionCheck());
337 
338   // Test direct call.
339   {
340     jmethodID getStackClass2MethodId = env->GetStaticMethodID(vmstack_clazz, "getStackClass2",
341                                                               "()Ljava/lang/Class;");
342     CHECK(getStackClass2MethodId != nullptr);
343     CHECK(!env->ExceptionCheck());
344 
345     jobject caller_class = env->CallStaticObjectMethod(vmstack_clazz, getStackClass2MethodId);
346     CHECK(caller_class == nullptr);
347     CHECK(!env->ExceptionCheck());
348   }
349 
350   // Test one-level call. Use VMStack.getStackClass1().
351   {
352     jmethodID getStackClass1MethodId = env->GetStaticMethodID(vmstack_clazz, "getStackClass1",
353                                                               "()Ljava/lang/Class;");
354     CHECK(getStackClass1MethodId != nullptr);
355     CHECK(!env->ExceptionCheck());
356 
357     jobject caller_class = env->CallStaticObjectMethod(vmstack_clazz, getStackClass1MethodId);
358     CHECK(caller_class == nullptr);
359     CHECK(!env->ExceptionCheck());
360   }
361 
362   // For better testing we would need to compile against libcore and have a two-deep stack
363   // ourselves.
364 }
365 
Java_Main_nativeTestShallowGetStackClass2(JNIEnv *,jclass)366 extern "C" JNIEXPORT void JNICALL Java_Main_nativeTestShallowGetStackClass2(JNIEnv*, jclass) {
367   PthreadHelper(&testShallowGetStackClass2);
368 }
369 
370 class JniCallNonvirtualVoidMethodTest {
371  public:
JniCallNonvirtualVoidMethodTest(JNIEnv * env)372   explicit JniCallNonvirtualVoidMethodTest(JNIEnv* env)
373       : env_(env),
374         check_jni_ri_(true),
375         check_jni_android_(true),
376         super_(GetClass("JniCallNonvirtualTest")),
377         sub_(GetClass("JniCallNonvirtualTestSubclass")),
378         super_constructor_(GetMethodID(super_, true, "<init>")),
379         super_static_(GetMethodID(super_, false, "staticMethod")),
380         super_nonstatic_(GetMethodID(super_, true, "nonstaticMethod")),
381         sub_constructor_(GetMethodID(sub_, true, "<init>")),
382         sub_static_(GetMethodID(sub_, false, "staticMethod")),
383         sub_nonstatic_(GetMethodID(sub_, true, "nonstaticMethod")),
384         super_field_(GetFieldID(super_, "nonstaticMethodSuperCalled")),
385         sub_field_(GetFieldID(super_, "nonstaticMethodSubCalled")) {}
386 
Test()387   void Test() {
388     TestStaticCallNonvirtualMethod();
389     TestNewObject();
390     TestnonstaticCallNonvirtualMethod();
391   }
392 
393   JNIEnv* const env_;
394 
395   bool const check_jni_ri_;
396   bool const check_jni_android_;
397 
398   jclass const super_;
399   jclass const sub_;
400 
401   jmethodID const super_constructor_;
402   jmethodID const super_static_;
403   jmethodID const super_nonstatic_;
404   jmethodID const sub_constructor_;
405   jmethodID const sub_static_;
406   jmethodID const sub_nonstatic_;
407 
408   jfieldID const super_field_;
409   jfieldID const sub_field_;
410 
411  private:
GetClass(const char * class_name)412   jclass GetClass(const char* class_name) {
413     jclass c = env_->FindClass(class_name);
414     if (env_->ExceptionCheck()) {
415       env_->ExceptionDescribe();
416       env_->FatalError(__FUNCTION__);
417     }
418     CHECK(!env_->ExceptionCheck());
419     CHECK(c != nullptr);
420     return c;
421   }
422 
GetMethodID(jclass c,bool nonstatic,const char * method_name)423   jmethodID GetMethodID(jclass c, bool nonstatic, const char* method_name) {
424     jmethodID m = ((nonstatic) ?
425                    env_->GetMethodID(c, method_name, "()V") :
426                    env_->GetStaticMethodID(c, method_name, "()V"));
427     if (env_->ExceptionCheck()) {
428       env_->ExceptionDescribe();
429       env_->FatalError(__FUNCTION__);
430     }
431     CHECK(m != nullptr);
432     return m;
433   }
434 
CallConstructor(jclass c,jmethodID m)435   jobject CallConstructor(jclass c, jmethodID m) {
436     jobject o = env_->NewObject(c, m);
437     if (env_->ExceptionCheck()) {
438       env_->ExceptionDescribe();
439       env_->FatalError(__FUNCTION__);
440     }
441     CHECK(o != nullptr);
442     return o;
443   }
444 
CallMethod(jobject o,jclass c,jmethodID m,bool nonstatic,const char * test_case)445   void CallMethod(jobject o, jclass c, jmethodID m, bool nonstatic, const char* test_case) {
446     printf("RUNNING %s\n", test_case);
447     env_->CallNonvirtualVoidMethod(o, c, m);
448     bool exception_check = env_->ExceptionCheck();
449     if (c == nullptr || !nonstatic) {
450       if (!exception_check) {
451         printf("FAILED %s due to missing exception\n", test_case);
452         env_->FatalError("Expected NullPointerException with null jclass");
453       }
454       env_->ExceptionClear();
455     } else if (exception_check) {
456       printf("FAILED %s due to pending exception\n", test_case);
457       env_->ExceptionDescribe();
458       env_->FatalError(test_case);
459     }
460     printf("PASSED %s\n", test_case);
461   }
462 
GetFieldID(jclass c,const char * field_name)463   jfieldID GetFieldID(jclass c, const char* field_name) {
464     jfieldID m = env_->GetFieldID(c, field_name, "Z");
465     if (env_->ExceptionCheck()) {
466       env_->ExceptionDescribe();
467       env_->FatalError(__FUNCTION__);
468     }
469     CHECK(m != nullptr);
470     return m;
471   }
472 
GetBooleanField(jobject o,jfieldID f)473   jboolean GetBooleanField(jobject o, jfieldID f) {
474     jboolean b = env_->GetBooleanField(o, f);
475     if (env_->ExceptionCheck()) {
476       env_->ExceptionDescribe();
477       env_->FatalError(__FUNCTION__);
478     }
479     return b;
480   }
481 
TestStaticCallNonvirtualMethod()482   void TestStaticCallNonvirtualMethod() {
483     if (!check_jni_ri_&& !check_jni_android_) {
484       CallMethod(nullptr, nullptr, super_static_, false, "null object, null class, super static");
485     }
486     if (!check_jni_android_) {
487       CallMethod(nullptr, super_, super_static_, false, "null object, super class, super static");
488     }
489     if (!check_jni_android_) {
490       CallMethod(nullptr, sub_, super_static_, false, "null object, sub class, super static");
491     }
492 
493     if (!check_jni_ri_ && !check_jni_android_) {
494       CallMethod(nullptr, nullptr, sub_static_, false, "null object, null class, sub static");
495     }
496     if (!check_jni_android_) {
497       CallMethod(nullptr, sub_, sub_static_, false, "null object, super class, sub static");
498     }
499     if (!check_jni_android_) {
500       CallMethod(nullptr, super_, sub_static_, false, "null object, super class, sub static");
501     }
502   }
503 
TestNewObject()504   void TestNewObject() {
505     jobject super_super = CallConstructor(super_, super_constructor_);
506     jobject super_sub = CallConstructor(super_, sub_constructor_);
507     jobject sub_super = CallConstructor(sub_, super_constructor_);
508     jobject sub_sub = CallConstructor(sub_, sub_constructor_);
509 
510     CHECK(env_->IsInstanceOf(super_super, super_));
511     CHECK(!env_->IsInstanceOf(super_super, sub_));
512 
513     // Note that even though we called (and ran) the subclass
514     // constructor, we are not the subclass.
515     CHECK(env_->IsInstanceOf(super_sub, super_));
516     CHECK(!env_->IsInstanceOf(super_sub, sub_));
517 
518     // Note that even though we called the superclass constructor, we
519     // are still the subclass.
520     CHECK(env_->IsInstanceOf(sub_super, super_));
521     CHECK(env_->IsInstanceOf(sub_super, sub_));
522 
523     CHECK(env_->IsInstanceOf(sub_sub, super_));
524     CHECK(env_->IsInstanceOf(sub_sub, sub_));
525   }
526 
TestnonstaticCallNonvirtualMethod(bool super_object,bool super_class,bool super_method,const char * test_case)527   void TestnonstaticCallNonvirtualMethod(bool super_object, bool super_class, bool super_method, const char* test_case) {
528     if (check_jni_android_) {
529       if (super_object && !super_method) {
530         return;  // We don't allow a call with sub class method on the super class instance.
531       }
532       if (super_class && !super_method) {
533         return;  // We don't allow a call with the sub class method with the super class argument.
534       }
535     }
536     jobject o = ((super_object) ?
537                  CallConstructor(super_, super_constructor_) :
538                  CallConstructor(sub_, sub_constructor_));
539     jclass c = (super_class) ? super_ : sub_;
540     jmethodID m = (super_method) ? super_nonstatic_ : sub_nonstatic_;
541     CallMethod(o, c, m, true, test_case);
542     jboolean super_field = GetBooleanField(o, super_field_);
543     jboolean sub_field = GetBooleanField(o, sub_field_);
544     CHECK_EQ(super_field, super_method);
545     CHECK_NE(sub_field, super_method);
546   }
547 
TestnonstaticCallNonvirtualMethod()548   void TestnonstaticCallNonvirtualMethod() {
549     TestnonstaticCallNonvirtualMethod(true, true, true, "super object, super class, super nonstatic");
550     TestnonstaticCallNonvirtualMethod(true, false, true, "super object, sub class, super nonstatic");
551     TestnonstaticCallNonvirtualMethod(true, false, false, "super object, sub class, sub nonstatic");
552     TestnonstaticCallNonvirtualMethod(true, true, false, "super object, super class, sub nonstatic");
553 
554     TestnonstaticCallNonvirtualMethod(false, true, true, "sub object, super class, super nonstatic");
555     TestnonstaticCallNonvirtualMethod(false, false, true, "sub object, sub class, super nonstatic");
556     TestnonstaticCallNonvirtualMethod(false, false, false, "sub object, sub class, sub nonstatic");
557     TestnonstaticCallNonvirtualMethod(false, true, false, "sub object, super class, sub nonstatic");
558   }
559 };
560 
Java_Main_testCallNonvirtual(JNIEnv * env,jclass)561 extern "C" void JNICALL Java_Main_testCallNonvirtual(JNIEnv* env, jclass) {
562   JniCallNonvirtualVoidMethodTest(env).Test();
563 }
564 
Java_Main_testNewStringObject(JNIEnv * env,jclass)565 extern "C" JNIEXPORT void JNICALL Java_Main_testNewStringObject(JNIEnv* env, jclass) {
566   jclass c = env->FindClass("java/lang/String");
567   CHECK(c != nullptr);
568 
569   jmethodID mid1 = env->GetMethodID(c, "<init>", "()V");
570   CHECK(mid1 != nullptr);
571   CHECK(!env->ExceptionCheck());
572   jmethodID mid2 = env->GetMethodID(c, "<init>", "([B)V");
573   CHECK(mid2 != nullptr);
574   CHECK(!env->ExceptionCheck());
575   jmethodID mid3 = env->GetMethodID(c, "<init>", "([C)V");
576   CHECK(mid3 != nullptr);
577   CHECK(!env->ExceptionCheck());
578   jmethodID mid4 = env->GetMethodID(c, "<init>", "(Ljava/lang/String;)V");
579   CHECK(mid4 != nullptr);
580   CHECK(!env->ExceptionCheck());
581 
582   const char* test_array = "Test";
583   int byte_array_length = strlen(test_array);
584   jbyteArray byte_array = env->NewByteArray(byte_array_length);
585   env->SetByteArrayRegion(byte_array, 0, byte_array_length, reinterpret_cast<const jbyte*>(test_array));
586 
587   // Test NewObject
588   jstring s = reinterpret_cast<jstring>(env->NewObject(c, mid2, byte_array));
589   CHECK(s != nullptr);
590   CHECK_EQ(env->GetStringLength(s), byte_array_length);
591   CHECK_EQ(env->GetStringUTFLength(s), byte_array_length);
592   const char* chars = env->GetStringUTFChars(s, nullptr);
593   CHECK_EQ(strcmp(test_array, chars), 0);
594   env->ReleaseStringUTFChars(s, chars);
595 
596   // Test AllocObject and Call(Nonvirtual)VoidMethod
597   jstring s1 = reinterpret_cast<jstring>(env->AllocObject(c));
598   CHECK(s1 != nullptr);
599   jstring s2 = reinterpret_cast<jstring>(env->AllocObject(c));
600   CHECK(s2 != nullptr);
601   jstring s3 = reinterpret_cast<jstring>(env->AllocObject(c));
602   CHECK(s3 != nullptr);
603   jstring s4 = reinterpret_cast<jstring>(env->AllocObject(c));
604   CHECK(s4 != nullptr);
605 
606   jcharArray char_array = env->NewCharArray(5);
607   jstring string_arg = env->NewStringUTF("helloworld");
608 
609   // With Var Args
610   env->CallVoidMethod(s1, mid1);
611   env->CallNonvirtualVoidMethod(s2, c, mid2, byte_array);
612 
613   // With JValues
614   jvalue args3[1];
615   args3[0].l = char_array;
616   jvalue args4[1];
617   args4[0].l = string_arg;
618   env->CallVoidMethodA(s3, mid3, args3);
619   env->CallNonvirtualVoidMethodA(s4, c, mid4, args4);
620 
621   // Test with global and weak global references
622   jstring s5 = reinterpret_cast<jstring>(env->AllocObject(c));
623   CHECK(s5 != nullptr);
624   s5 = reinterpret_cast<jstring>(env->NewGlobalRef(s5));
625   jstring s6 = reinterpret_cast<jstring>(env->AllocObject(c));
626   CHECK(s6 != nullptr);
627   s6 = reinterpret_cast<jstring>(env->NewWeakGlobalRef(s6));
628 
629   env->CallVoidMethod(s5, mid1);
630   env->CallNonvirtualVoidMethod(s6, c, mid2, byte_array);
631   CHECK_EQ(env->GetStringLength(s5), 0);
632   CHECK_EQ(env->GetStringLength(s6), byte_array_length);
633   const char* chars6 = env->GetStringUTFChars(s6, nullptr);
634   CHECK_EQ(strcmp(test_array, chars6), 0);
635   env->ReleaseStringUTFChars(s6, chars6);
636 }
637 
Java_Main_testGetMethodID(JNIEnv * env,jclass,jclass c)638 extern "C" JNIEXPORT jlong JNICALL Java_Main_testGetMethodID(JNIEnv* env, jclass, jclass c) {
639   return reinterpret_cast<jlong>(env->GetMethodID(c, "a", "()V"));
640 }
641 
Java_Main_enterJniCriticalSection(JNIEnv * env,jclass,jint arraySize,jbyteArray array0,jbyteArray array1)642 extern "C" JNIEXPORT void JNICALL Java_Main_enterJniCriticalSection(JNIEnv* env, jclass,
643                                                                     jint arraySize,
644                                                                     jbyteArray array0,
645                                                                     jbyteArray array1) {
646   for (int i = 0; i < 50000; ++i) {
647     char* data0 = reinterpret_cast<char*>(env->GetPrimitiveArrayCritical(array0, nullptr));
648     char* data1 = reinterpret_cast<char*>(env->GetPrimitiveArrayCritical(array1, nullptr));
649     bool up = i % 2 == 0;
650     for (int j = 0; j < arraySize; ++j) {
651       if (up) {
652         data1[j] = data0[j] + 1;
653       } else {
654         data0[j] = data1[j] + 1;
655       }
656     }
657     env->ReleasePrimitiveArrayCritical(array1, data1, 0);
658     env->ReleasePrimitiveArrayCritical(array0, data0, 0);
659   }
660 }
661 
662 class JniCallDefaultMethodsTest {
663  public:
JniCallDefaultMethodsTest(JNIEnv * env)664   explicit JniCallDefaultMethodsTest(JNIEnv* env)
665       : env_(env), concrete_class_(env_->FindClass("ConcreteClass")) {
666     CHECK(!env_->ExceptionCheck());
667     CHECK(concrete_class_ != nullptr);
668   }
669 
Test()670   void Test() {
671     TestCalls("ConcreteClass", { "JniCallNonOverridenDefaultMethod",
672                                  "JniCallOverridenDefaultMethod",
673                                  "JniCallOverridenDefaultMethodWithSuper",
674                                  "JniCallOverridenAbstractMethod",
675                                  "JniCallConflictDefaultMethod",
676                                  "JniCallSoftConflictMethod" });
677     TestCalls("DefaultInterface", { "JniCallNonOverridenDefaultMethod",
678                                     "JniCallOverridenDefaultMethod",
679                                     "JniCallOverridenAbstractMethod",
680                                     "JniCallConflictDefaultMethod",
681                                     "JniCallSoftConflictMethod" });
682     TestCalls("AbstractInterface", { "JniCallSoftConflictMethod" });
683     TestCalls("ConflictInterface", { "JniCallConflictDefaultMethod" });
684   }
685 
686  private:
TestCalls(const char * declaring_class,std::vector<const char * > methods)687   void TestCalls(const char* declaring_class, std::vector<const char*> methods) {
688     jmethodID new_method = env_->GetMethodID(concrete_class_, "<init>", "()V");
689     jobject obj = env_->NewObject(concrete_class_, new_method);
690     CHECK(!env_->ExceptionCheck());
691     CHECK(obj != nullptr);
692     jclass decl_class = env_->FindClass(declaring_class);
693     CHECK(!env_->ExceptionCheck());
694     CHECK(decl_class != nullptr);
695     for (const char* method : methods) {
696       jmethodID method_id = env_->GetMethodID(decl_class, method, "()V");
697       CHECK(!env_->ExceptionCheck());
698       printf("Calling method %s->%s on object of type ConcreteClass\n", declaring_class, method);
699       env_->CallVoidMethod(obj, method_id);
700       if (env_->ExceptionCheck()) {
701         jthrowable thrown = env_->ExceptionOccurred();
702         env_->ExceptionClear();
703         jmethodID to_string = env_->GetMethodID(
704             env_->FindClass("java/lang/Object"), "toString", "()Ljava/lang/String;");
705         jstring exception_string = (jstring) env_->CallObjectMethod(thrown, to_string);
706         CHECK(!env_->ExceptionCheck());
707         const char* exception_string_utf8 = env_->GetStringUTFChars(exception_string, nullptr);
708         CHECK(!env_->ExceptionCheck());
709         CHECK(exception_string_utf8 != nullptr);
710         printf("EXCEPTION OCCURED: %s\n", exception_string_utf8);
711         env_->ReleaseStringUTFChars(exception_string, exception_string_utf8);
712       }
713     }
714   }
715 
716   JNIEnv* env_;
717   jclass concrete_class_;
718 };
719 
Java_Main_testCallDefaultMethods(JNIEnv * env)720 extern "C" JNIEXPORT void JNICALL Java_Main_testCallDefaultMethods(JNIEnv* env) {
721   JniCallDefaultMethodsTest(env).Test();
722 }
723 
InvokeSpecificMethod(JNIEnv * env,jobject obj,const char * method)724 static void InvokeSpecificMethod(JNIEnv* env, jobject obj, const char* method) {
725   jclass lambda_class = env->FindClass("LambdaInterface");
726   CHECK(!env->ExceptionCheck());
727   CHECK(lambda_class != nullptr);
728   jmethodID method_id = env->GetMethodID(lambda_class, method, "()V");
729   CHECK(!env->ExceptionCheck());
730   env->CallVoidMethod(obj, method_id);
731   CHECK(!env->ExceptionCheck());
732 }
733 
Java_Main_testInvokeLambdaDefaultMethod(JNIEnv * e,jclass,jobject l)734 extern "C" JNIEXPORT void JNICALL Java_Main_testInvokeLambdaDefaultMethod(
735     JNIEnv* e, jclass, jobject l) {
736   InvokeSpecificMethod(e, l, "sayHiTwice");
737 }
738 
Java_Main_testInvokeLambdaMethod(JNIEnv * e,jclass,jobject l)739 extern "C" JNIEXPORT void JNICALL Java_Main_testInvokeLambdaMethod(JNIEnv* e, jclass, jobject l) {
740   InvokeSpecificMethod(e, l, "sayHi");
741 }
742 
743 }  // namespace art
744 
745