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