jni_internal_test.cc revision da9b763abc712fd6d1e24170a194abfbe795b8cd
1/* 2 * Copyright (C) 2011 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 "jni_internal.h" 18 19#include "art_method-inl.h" 20#include "common_compiler_test.h" 21#include "indirect_reference_table.h" 22#include "java_vm_ext.h" 23#include "jni_env_ext.h" 24#include "mirror/string-inl.h" 25#include "scoped_thread_state_change.h" 26#include "ScopedLocalRef.h" 27 28namespace art { 29 30// TODO: Convert to CommonRuntimeTest. Currently MakeExecutable is used. 31class JniInternalTest : public CommonCompilerTest { 32 protected: 33 virtual void SetUp() { 34 CommonCompilerTest::SetUp(); 35 36 vm_ = Runtime::Current()->GetJavaVM(); 37 38 // Turn on -verbose:jni for the JNI tests. 39 // gLogVerbosity.jni = true; 40 41 vm_->AttachCurrentThread(&env_, nullptr); 42 43 ScopedLocalRef<jclass> aioobe(env_, 44 env_->FindClass("java/lang/ArrayIndexOutOfBoundsException")); 45 CHECK(aioobe.get() != nullptr); 46 aioobe_ = reinterpret_cast<jclass>(env_->NewGlobalRef(aioobe.get())); 47 48 ScopedLocalRef<jclass> ase(env_, env_->FindClass("java/lang/ArrayStoreException")); 49 CHECK(ase.get() != nullptr); 50 ase_ = reinterpret_cast<jclass>(env_->NewGlobalRef(ase.get())); 51 52 ScopedLocalRef<jclass> sioobe(env_, 53 env_->FindClass("java/lang/StringIndexOutOfBoundsException")); 54 CHECK(sioobe.get() != nullptr); 55 sioobe_ = reinterpret_cast<jclass>(env_->NewGlobalRef(sioobe.get())); 56 } 57 58 void ExpectException(jclass exception_class) { 59 ScopedObjectAccess soa(env_); 60 EXPECT_TRUE(env_->ExceptionCheck()) 61 << PrettyDescriptor(soa.Decode<mirror::Class*>(exception_class)); 62 jthrowable exception = env_->ExceptionOccurred(); 63 EXPECT_NE(nullptr, exception); 64 env_->ExceptionClear(); 65 EXPECT_TRUE(env_->IsInstanceOf(exception, exception_class)); 66 } 67 68 void CleanUpJniEnv() { 69 if (aioobe_ != nullptr) { 70 env_->DeleteGlobalRef(aioobe_); 71 aioobe_ = nullptr; 72 } 73 if (ase_ != nullptr) { 74 env_->DeleteGlobalRef(ase_); 75 ase_ = nullptr; 76 } 77 if (sioobe_ != nullptr) { 78 env_->DeleteGlobalRef(sioobe_); 79 sioobe_ = nullptr; 80 } 81 } 82 83 virtual void TearDown() OVERRIDE { 84 CleanUpJniEnv(); 85 CommonCompilerTest::TearDown(); 86 } 87 88 jclass GetPrimitiveClass(char descriptor) { 89 ScopedObjectAccess soa(env_); 90 mirror::Class* c = class_linker_->FindPrimitiveClass(descriptor); 91 CHECK(c != nullptr); 92 return soa.AddLocalReference<jclass>(c); 93 } 94 95 void ExpectClassFound(const char* name) { 96 EXPECT_NE(env_->FindClass(name), nullptr) << name; 97 EXPECT_FALSE(env_->ExceptionCheck()) << name; 98 } 99 100 void ExpectClassNotFound(const char* name, bool check_jni, const char* check_jni_msg, 101 CheckJniAbortCatcher* abort_catcher) { 102 EXPECT_EQ(env_->FindClass(name), nullptr) << name; 103 if (!check_jni || check_jni_msg == nullptr) { 104 EXPECT_TRUE(env_->ExceptionCheck()) << name; 105 env_->ExceptionClear(); 106 } else { 107 abort_catcher->Check(check_jni_msg); 108 } 109 } 110 111 void FindClassTest(bool check_jni) { 112 bool old_check_jni = vm_->SetCheckJniEnabled(check_jni); 113 CheckJniAbortCatcher check_jni_abort_catcher; 114 115 // Null argument is always an abort. 116 env_->FindClass(nullptr); 117 check_jni_abort_catcher.Check(check_jni ? "non-nullable const char* was NULL" 118 : "name == null"); 119 120 // Reference types... 121 ExpectClassFound("java/lang/String"); 122 // ...for arrays too, where you must include "L;". 123 ExpectClassFound("[Ljava/lang/String;"); 124 // Primitive arrays are okay too, if the primitive type is valid. 125 ExpectClassFound("[C"); 126 127 // But primitive types aren't allowed... 128 ExpectClassNotFound("C", check_jni, nullptr, &check_jni_abort_catcher); 129 ExpectClassNotFound("V", check_jni, nullptr, &check_jni_abort_catcher); 130 ExpectClassNotFound("K", check_jni, nullptr, &check_jni_abort_catcher); 131 132 if (check_jni) { 133 // Check JNI will reject invalid class names as aborts but without pending exceptions. 134 EXPECT_EQ(env_->FindClass("java.lang.String"), nullptr); 135 EXPECT_FALSE(env_->ExceptionCheck()); 136 check_jni_abort_catcher.Check("illegal class name 'java.lang.String'"); 137 138 EXPECT_EQ(env_->FindClass("[Ljava.lang.String;"), nullptr); 139 EXPECT_FALSE(env_->ExceptionCheck()); 140 check_jni_abort_catcher.Check("illegal class name '[Ljava.lang.String;'"); 141 } else { 142 // Without check JNI we're tolerant and replace '.' with '/'. 143 ExpectClassFound("java.lang.String"); 144 ExpectClassFound("[Ljava.lang.String;"); 145 } 146 147 ExpectClassNotFound("Ljava.lang.String;", check_jni, "illegal class name 'Ljava.lang.String;'", 148 &check_jni_abort_catcher); 149 ExpectClassNotFound("[java.lang.String", check_jni, "illegal class name '[java.lang.String'", 150 &check_jni_abort_catcher); 151 152 // You can't include the "L;" in a JNI class descriptor. 153 ExpectClassNotFound("Ljava/lang/String;", check_jni, "illegal class name 'Ljava/lang/String;'", 154 &check_jni_abort_catcher); 155 156 // But you must include it for an array of any reference type. 157 ExpectClassNotFound("[java/lang/String", check_jni, "illegal class name '[java/lang/String'", 158 &check_jni_abort_catcher); 159 160 ExpectClassNotFound("[K", check_jni, "illegal class name '[K'", &check_jni_abort_catcher); 161 162 // Void arrays aren't allowed. 163 ExpectClassNotFound("[V", check_jni, "illegal class name '[V'", &check_jni_abort_catcher); 164 165 EXPECT_EQ(check_jni, vm_->SetCheckJniEnabled(old_check_jni)); 166 } 167 168 void GetFieldIdBadArgumentTest(bool check_jni) { 169 bool old_check_jni = vm_->SetCheckJniEnabled(check_jni); 170 CheckJniAbortCatcher check_jni_abort_catcher; 171 172 jclass c = env_->FindClass("java/lang/String"); 173 ASSERT_NE(c, nullptr); 174 175 jfieldID fid = env_->GetFieldID(nullptr, "count", "I"); 176 EXPECT_EQ(nullptr, fid); 177 check_jni_abort_catcher.Check(check_jni ? "GetFieldID received NULL jclass" 178 : "java_class == null"); 179 fid = env_->GetFieldID(c, nullptr, "I"); 180 EXPECT_EQ(nullptr, fid); 181 check_jni_abort_catcher.Check(check_jni ? "non-nullable const char* was NULL" 182 : "name == null"); 183 fid = env_->GetFieldID(c, "count", nullptr); 184 EXPECT_EQ(nullptr, fid); 185 check_jni_abort_catcher.Check(check_jni ? "non-nullable const char* was NULL" 186 : "sig == null"); 187 188 EXPECT_EQ(check_jni, vm_->SetCheckJniEnabled(old_check_jni)); 189 } 190 191 void GetStaticFieldIdBadArgumentTest(bool check_jni) { 192 bool old_check_jni = vm_->SetCheckJniEnabled(check_jni); 193 CheckJniAbortCatcher check_jni_abort_catcher; 194 195 jclass c = env_->FindClass("java/lang/String"); 196 ASSERT_NE(c, nullptr); 197 198 jfieldID fid = env_->GetStaticFieldID(nullptr, "CASE_INSENSITIVE_ORDER", "Ljava/util/Comparator;"); 199 EXPECT_EQ(nullptr, fid); 200 check_jni_abort_catcher.Check(check_jni ? "GetStaticFieldID received NULL jclass" 201 : "java_class == null"); 202 fid = env_->GetStaticFieldID(c, nullptr, "Ljava/util/Comparator;"); 203 EXPECT_EQ(nullptr, fid); 204 check_jni_abort_catcher.Check(check_jni ? "non-nullable const char* was NULL" 205 : "name == null"); 206 fid = env_->GetStaticFieldID(c, "CASE_INSENSITIVE_ORDER", nullptr); 207 EXPECT_EQ(nullptr, fid); 208 check_jni_abort_catcher.Check(check_jni ? "non-nullable const char* was NULL" 209 : "sig == null"); 210 211 EXPECT_EQ(check_jni, vm_->SetCheckJniEnabled(old_check_jni)); 212 } 213 214 void GetMethodIdBadArgumentTest(bool check_jni) { 215 bool old_check_jni = vm_->SetCheckJniEnabled(check_jni); 216 CheckJniAbortCatcher check_jni_abort_catcher; 217 218 jmethodID method = env_->GetMethodID(nullptr, "<init>", "(Ljava/lang/String;)V"); 219 EXPECT_EQ(nullptr, method); 220 check_jni_abort_catcher.Check(check_jni ? "GetMethodID received NULL jclass" 221 : "java_class == null"); 222 jclass jlnsme = env_->FindClass("java/lang/NoSuchMethodError"); 223 ASSERT_TRUE(jlnsme != nullptr); 224 method = env_->GetMethodID(jlnsme, nullptr, "(Ljava/lang/String;)V"); 225 EXPECT_EQ(nullptr, method); 226 check_jni_abort_catcher.Check(check_jni ? "non-nullable const char* was NULL" 227 : "name == null"); 228 method = env_->GetMethodID(jlnsme, "<init>", nullptr); 229 EXPECT_EQ(nullptr, method); 230 check_jni_abort_catcher.Check(check_jni ? "non-nullable const char* was NULL" 231 : "sig == null"); 232 233 EXPECT_EQ(check_jni, vm_->SetCheckJniEnabled(old_check_jni)); 234 } 235 236 void GetStaticMethodIdBadArgumentTest(bool check_jni) { 237 bool old_check_jni = vm_->SetCheckJniEnabled(check_jni); 238 CheckJniAbortCatcher check_jni_abort_catcher; 239 240 jmethodID method = env_->GetStaticMethodID(nullptr, "valueOf", "(I)Ljava/lang/String;"); 241 EXPECT_EQ(nullptr, method); 242 check_jni_abort_catcher.Check(check_jni ? "GetStaticMethodID received NULL jclass" 243 : "java_class == null"); 244 jclass jlstring = env_->FindClass("java/lang/String"); 245 method = env_->GetStaticMethodID(jlstring, nullptr, "(I)Ljava/lang/String;"); 246 EXPECT_EQ(nullptr, method); 247 check_jni_abort_catcher.Check(check_jni ? "non-nullable const char* was NULL" 248 : "name == null"); 249 method = env_->GetStaticMethodID(jlstring, "valueOf", nullptr); 250 EXPECT_EQ(nullptr, method); 251 check_jni_abort_catcher.Check(check_jni ? "non-nullable const char* was NULL" 252 : "sig == null"); 253 254 EXPECT_EQ(check_jni, vm_->SetCheckJniEnabled(old_check_jni)); 255 } 256 257 void GetFromReflectedField_ToReflectedFieldBadArgumentTest(bool check_jni) { 258 bool old_check_jni = vm_->SetCheckJniEnabled(check_jni); 259 CheckJniAbortCatcher check_jni_abort_catcher; 260 261 jclass c = env_->FindClass("java/lang/String"); 262 ASSERT_NE(c, nullptr); 263 jfieldID fid = env_->GetFieldID(c, "count", "I"); 264 ASSERT_NE(fid, nullptr); 265 266 // Check class argument for null argument, not checked in non-check JNI. 267 jobject field = env_->ToReflectedField(nullptr, fid, JNI_FALSE); 268 if (check_jni) { 269 EXPECT_EQ(field, nullptr); 270 check_jni_abort_catcher.Check("ToReflectedField received NULL jclass"); 271 } else { 272 EXPECT_NE(field, nullptr); 273 } 274 275 field = env_->ToReflectedField(c, nullptr, JNI_FALSE); 276 EXPECT_EQ(field, nullptr); 277 check_jni_abort_catcher.Check(check_jni ? "jfieldID was NULL" 278 : "fid == null"); 279 280 fid = env_->FromReflectedField(nullptr); 281 ASSERT_EQ(fid, nullptr); 282 check_jni_abort_catcher.Check(check_jni ? "expected non-null java.lang.reflect.Field" 283 : "jlr_field == null"); 284 285 EXPECT_EQ(check_jni, vm_->SetCheckJniEnabled(old_check_jni)); 286 } 287 288 void GetFromReflectedMethod_ToReflectedMethodBadArgumentTest(bool check_jni) { 289 bool old_check_jni = vm_->SetCheckJniEnabled(check_jni); 290 CheckJniAbortCatcher check_jni_abort_catcher; 291 292 jclass c = env_->FindClass("java/lang/String"); 293 ASSERT_NE(c, nullptr); 294 jmethodID mid = env_->GetMethodID(c, "<init>", "()V"); 295 ASSERT_NE(mid, nullptr); 296 297 // Check class argument for null argument, not checked in non-check JNI. 298 jobject method = env_->ToReflectedMethod(nullptr, mid, JNI_FALSE); 299 if (check_jni) { 300 EXPECT_EQ(method, nullptr); 301 check_jni_abort_catcher.Check("ToReflectedMethod received NULL jclass"); 302 } else { 303 EXPECT_NE(method, nullptr); 304 } 305 306 method = env_->ToReflectedMethod(c, nullptr, JNI_FALSE); 307 EXPECT_EQ(method, nullptr); 308 check_jni_abort_catcher.Check(check_jni ? "jmethodID was NULL" 309 : "mid == null"); 310 mid = env_->FromReflectedMethod(method); 311 ASSERT_EQ(mid, nullptr); 312 check_jni_abort_catcher.Check(check_jni ? "expected non-null method" : "jlr_method == null"); 313 314 EXPECT_EQ(check_jni, vm_->SetCheckJniEnabled(old_check_jni)); 315 } 316 317 void RegisterAndUnregisterNativesBadArguments(bool check_jni, 318 CheckJniAbortCatcher* check_jni_abort_catcher) { 319 bool old_check_jni = vm_->SetCheckJniEnabled(check_jni); 320 // Passing a class of null is a failure. 321 { 322 JNINativeMethod methods[] = { }; 323 EXPECT_EQ(env_->RegisterNatives(nullptr, methods, 0), JNI_ERR); 324 check_jni_abort_catcher->Check(check_jni ? "RegisterNatives received NULL jclass" 325 : "java_class == null"); 326 } 327 328 // Passing methods as null is a failure. 329 jclass jlobject = env_->FindClass("java/lang/Object"); 330 EXPECT_EQ(env_->RegisterNatives(jlobject, nullptr, 1), JNI_ERR); 331 check_jni_abort_catcher->Check("methods == null"); 332 333 // Unregisters null is a failure. 334 EXPECT_EQ(env_->UnregisterNatives(nullptr), JNI_ERR); 335 check_jni_abort_catcher->Check(check_jni ? "UnregisterNatives received NULL jclass" 336 : "java_class == null"); 337 338 EXPECT_EQ(check_jni, vm_->SetCheckJniEnabled(old_check_jni)); 339 } 340 341 342 void GetPrimitiveArrayElementsOfWrongType(bool check_jni) { 343 bool old_check_jni = vm_->SetCheckJniEnabled(check_jni); 344 CheckJniAbortCatcher jni_abort_catcher; 345 346 jbooleanArray array = env_->NewBooleanArray(10); 347 jboolean is_copy; 348 EXPECT_EQ(env_->GetByteArrayElements(reinterpret_cast<jbyteArray>(array), &is_copy), nullptr); 349 jni_abort_catcher.Check( 350 check_jni ? "incompatible array type boolean[] expected byte[]" 351 : "attempt to get byte primitive array elements with an object of type boolean[]"); 352 EXPECT_EQ(env_->GetShortArrayElements(reinterpret_cast<jshortArray>(array), &is_copy), nullptr); 353 jni_abort_catcher.Check( 354 check_jni ? "incompatible array type boolean[] expected short[]" 355 : "attempt to get short primitive array elements with an object of type boolean[]"); 356 EXPECT_EQ(env_->GetCharArrayElements(reinterpret_cast<jcharArray>(array), &is_copy), nullptr); 357 jni_abort_catcher.Check( 358 check_jni ? "incompatible array type boolean[] expected char[]" 359 : "attempt to get char primitive array elements with an object of type boolean[]"); 360 EXPECT_EQ(env_->GetIntArrayElements(reinterpret_cast<jintArray>(array), &is_copy), nullptr); 361 jni_abort_catcher.Check( 362 check_jni ? "incompatible array type boolean[] expected int[]" 363 : "attempt to get int primitive array elements with an object of type boolean[]"); 364 EXPECT_EQ(env_->GetLongArrayElements(reinterpret_cast<jlongArray>(array), &is_copy), nullptr); 365 jni_abort_catcher.Check( 366 check_jni ? "incompatible array type boolean[] expected long[]" 367 : "attempt to get long primitive array elements with an object of type boolean[]"); 368 EXPECT_EQ(env_->GetFloatArrayElements(reinterpret_cast<jfloatArray>(array), &is_copy), nullptr); 369 jni_abort_catcher.Check( 370 check_jni ? "incompatible array type boolean[] expected float[]" 371 : "attempt to get float primitive array elements with an object of type boolean[]"); 372 EXPECT_EQ(env_->GetDoubleArrayElements(reinterpret_cast<jdoubleArray>(array), &is_copy), nullptr); 373 jni_abort_catcher.Check( 374 check_jni ? "incompatible array type boolean[] expected double[]" 375 : "attempt to get double primitive array elements with an object of type boolean[]"); 376 jbyteArray array2 = env_->NewByteArray(10); 377 EXPECT_EQ(env_->GetBooleanArrayElements(reinterpret_cast<jbooleanArray>(array2), &is_copy), 378 nullptr); 379 jni_abort_catcher.Check( 380 check_jni ? "incompatible array type byte[] expected boolean[]" 381 : "attempt to get boolean primitive array elements with an object of type byte[]"); 382 jobject object = env_->NewStringUTF("Test String"); 383 EXPECT_EQ(env_->GetBooleanArrayElements(reinterpret_cast<jbooleanArray>(object), &is_copy), 384 nullptr); 385 jni_abort_catcher.Check( 386 check_jni ? "jarray argument has non-array type: java.lang.String" 387 : "attempt to get boolean primitive array elements with an object of type java.lang.String"); 388 389 EXPECT_EQ(check_jni, vm_->SetCheckJniEnabled(old_check_jni)); 390 } 391 392 void ReleasePrimitiveArrayElementsOfWrongType(bool check_jni) { 393 bool old_check_jni = vm_->SetCheckJniEnabled(check_jni); 394 CheckJniAbortCatcher jni_abort_catcher; 395 { 396 jbooleanArray array = env_->NewBooleanArray(10); 397 ASSERT_TRUE(array != nullptr); 398 jboolean is_copy; 399 jboolean* elements = env_->GetBooleanArrayElements(array, &is_copy); 400 ASSERT_TRUE(elements != nullptr); 401 env_->ReleaseByteArrayElements(reinterpret_cast<jbyteArray>(array), 402 reinterpret_cast<jbyte*>(elements), 0); 403 jni_abort_catcher.Check( 404 check_jni ? "incompatible array type boolean[] expected byte[]" 405 : "attempt to release byte primitive array elements with an object of type boolean[]"); 406 env_->ReleaseShortArrayElements(reinterpret_cast<jshortArray>(array), 407 reinterpret_cast<jshort*>(elements), 0); 408 jni_abort_catcher.Check( 409 check_jni ? "incompatible array type boolean[] expected short[]" 410 : "attempt to release short primitive array elements with an object of type boolean[]"); 411 env_->ReleaseCharArrayElements(reinterpret_cast<jcharArray>(array), 412 reinterpret_cast<jchar*>(elements), 0); 413 jni_abort_catcher.Check( 414 check_jni ? "incompatible array type boolean[] expected char[]" 415 : "attempt to release char primitive array elements with an object of type boolean[]"); 416 env_->ReleaseIntArrayElements(reinterpret_cast<jintArray>(array), 417 reinterpret_cast<jint*>(elements), 0); 418 jni_abort_catcher.Check( 419 check_jni ? "incompatible array type boolean[] expected int[]" 420 : "attempt to release int primitive array elements with an object of type boolean[]"); 421 env_->ReleaseLongArrayElements(reinterpret_cast<jlongArray>(array), 422 reinterpret_cast<jlong*>(elements), 0); 423 jni_abort_catcher.Check( 424 check_jni ? "incompatible array type boolean[] expected long[]" 425 : "attempt to release long primitive array elements with an object of type boolean[]"); 426 env_->ReleaseFloatArrayElements(reinterpret_cast<jfloatArray>(array), 427 reinterpret_cast<jfloat*>(elements), 0); 428 jni_abort_catcher.Check( 429 check_jni ? "incompatible array type boolean[] expected float[]" 430 : "attempt to release float primitive array elements with an object of type boolean[]"); 431 env_->ReleaseDoubleArrayElements(reinterpret_cast<jdoubleArray>(array), 432 reinterpret_cast<jdouble*>(elements), 0); 433 jni_abort_catcher.Check( 434 check_jni ? "incompatible array type boolean[] expected double[]" 435 : "attempt to release double primitive array elements with an object of type boolean[]"); 436 437 // Don't leak the elements array. 438 env_->ReleaseBooleanArrayElements(array, elements, 0); 439 } 440 { 441 jbyteArray array = env_->NewByteArray(10); 442 jboolean is_copy; 443 jbyte* elements = env_->GetByteArrayElements(array, &is_copy); 444 445 env_->ReleaseBooleanArrayElements(reinterpret_cast<jbooleanArray>(array), 446 reinterpret_cast<jboolean*>(elements), 0); 447 jni_abort_catcher.Check( 448 check_jni ? "incompatible array type byte[] expected boolean[]" 449 : "attempt to release boolean primitive array elements with an object of type byte[]"); 450 jobject object = env_->NewStringUTF("Test String"); 451 env_->ReleaseBooleanArrayElements(reinterpret_cast<jbooleanArray>(object), 452 reinterpret_cast<jboolean*>(elements), 0); 453 jni_abort_catcher.Check( 454 check_jni ? "jarray argument has non-array type: java.lang.String" 455 : "attempt to release boolean primitive array elements with an object of type " 456 "java.lang.String"); 457 458 // Don't leak the elements array. 459 env_->ReleaseByteArrayElements(array, elements, 0); 460 } 461 EXPECT_EQ(check_jni, vm_->SetCheckJniEnabled(old_check_jni)); 462 } 463 464 void GetReleasePrimitiveArrayCriticalOfWrongType(bool check_jni) { 465 bool old_check_jni = vm_->SetCheckJniEnabled(check_jni); 466 CheckJniAbortCatcher jni_abort_catcher; 467 468 jobject object = env_->NewStringUTF("Test String"); 469 jboolean is_copy; 470 void* elements = env_->GetPrimitiveArrayCritical(reinterpret_cast<jarray>(object), &is_copy); 471 jni_abort_catcher.Check(check_jni ? "jarray argument has non-array type: java.lang.String" 472 : "expected primitive array, given java.lang.String"); 473 env_->ReleasePrimitiveArrayCritical(reinterpret_cast<jarray>(object), elements, 0); 474 jni_abort_catcher.Check(check_jni ? "jarray argument has non-array type: java.lang.String" 475 : "expected primitive array, given java.lang.String"); 476 477 EXPECT_EQ(check_jni, vm_->SetCheckJniEnabled(old_check_jni)); 478 } 479 480 void GetPrimitiveArrayRegionElementsOfWrongType(bool check_jni) { 481 bool old_check_jni = vm_->SetCheckJniEnabled(check_jni); 482 CheckJniAbortCatcher jni_abort_catcher; 483 constexpr size_t kLength = 10; 484 jbooleanArray array = env_->NewBooleanArray(kLength); 485 ASSERT_TRUE(array != nullptr); 486 jboolean elements[kLength]; 487 env_->GetByteArrayRegion(reinterpret_cast<jbyteArray>(array), 0, kLength, 488 reinterpret_cast<jbyte*>(elements)); 489 jni_abort_catcher.Check( 490 check_jni ? "incompatible array type boolean[] expected byte[]" 491 : "attempt to get region of byte primitive array elements with an object of type boolean[]"); 492 env_->GetShortArrayRegion(reinterpret_cast<jshortArray>(array), 0, kLength, 493 reinterpret_cast<jshort*>(elements)); 494 jni_abort_catcher.Check( 495 check_jni ? "incompatible array type boolean[] expected short[]" 496 : "attempt to get region of short primitive array elements with an object of type boolean[]"); 497 env_->GetCharArrayRegion(reinterpret_cast<jcharArray>(array), 0, kLength, 498 reinterpret_cast<jchar*>(elements)); 499 jni_abort_catcher.Check( 500 check_jni ? "incompatible array type boolean[] expected char[]" 501 : "attempt to get region of char primitive array elements with an object of type boolean[]"); 502 env_->GetIntArrayRegion(reinterpret_cast<jintArray>(array), 0, kLength, 503 reinterpret_cast<jint*>(elements)); 504 jni_abort_catcher.Check( 505 check_jni ? "incompatible array type boolean[] expected int[]" 506 : "attempt to get region of int primitive array elements with an object of type boolean[]"); 507 env_->GetLongArrayRegion(reinterpret_cast<jlongArray>(array), 0, kLength, 508 reinterpret_cast<jlong*>(elements)); 509 jni_abort_catcher.Check( 510 check_jni ? "incompatible array type boolean[] expected long[]" 511 : "attempt to get region of long primitive array elements with an object of type boolean[]"); 512 env_->GetFloatArrayRegion(reinterpret_cast<jfloatArray>(array), 0, kLength, 513 reinterpret_cast<jfloat*>(elements)); 514 jni_abort_catcher.Check( 515 check_jni ? "incompatible array type boolean[] expected float[]" 516 : "attempt to get region of float primitive array elements with an object of type boolean[]"); 517 env_->GetDoubleArrayRegion(reinterpret_cast<jdoubleArray>(array), 0, kLength, 518 reinterpret_cast<jdouble*>(elements)); 519 jni_abort_catcher.Check( 520 check_jni ? "incompatible array type boolean[] expected double[]" 521 : "attempt to get region of double primitive array elements with an object of type boolean[]"); 522 jbyteArray array2 = env_->NewByteArray(10); 523 env_->GetBooleanArrayRegion(reinterpret_cast<jbooleanArray>(array2), 0, kLength, 524 reinterpret_cast<jboolean*>(elements)); 525 jni_abort_catcher.Check( 526 check_jni ? "incompatible array type byte[] expected boolean[]" 527 : "attempt to get region of boolean primitive array elements with an object of type byte[]"); 528 jobject object = env_->NewStringUTF("Test String"); 529 env_->GetBooleanArrayRegion(reinterpret_cast<jbooleanArray>(object), 0, kLength, 530 reinterpret_cast<jboolean*>(elements)); 531 jni_abort_catcher.Check(check_jni ? "jarray argument has non-array type: java.lang.String" 532 : "attempt to get region of boolean primitive array elements with an object of type " 533 "java.lang.String"); 534 535 EXPECT_EQ(check_jni, vm_->SetCheckJniEnabled(old_check_jni)); 536 } 537 538 void SetPrimitiveArrayRegionElementsOfWrongType(bool check_jni) { 539 bool old_check_jni = vm_->SetCheckJniEnabled(check_jni); 540 CheckJniAbortCatcher jni_abort_catcher; 541 constexpr size_t kLength = 10; 542 jbooleanArray array = env_->NewBooleanArray(kLength); 543 ASSERT_TRUE(array != nullptr); 544 jboolean elements[kLength]; 545 env_->SetByteArrayRegion(reinterpret_cast<jbyteArray>(array), 0, kLength, 546 reinterpret_cast<jbyte*>(elements)); 547 jni_abort_catcher.Check( 548 check_jni ? "incompatible array type boolean[] expected byte[]" 549 : "attempt to set region of byte primitive array elements with an object of type boolean[]"); 550 env_->SetShortArrayRegion(reinterpret_cast<jshortArray>(array), 0, kLength, 551 reinterpret_cast<jshort*>(elements)); 552 jni_abort_catcher.Check( 553 check_jni ? "incompatible array type boolean[] expected short[]" 554 : "attempt to set region of short primitive array elements with an object of type boolean[]"); 555 env_->SetCharArrayRegion(reinterpret_cast<jcharArray>(array), 0, kLength, 556 reinterpret_cast<jchar*>(elements)); 557 jni_abort_catcher.Check( 558 check_jni ? "incompatible array type boolean[] expected char[]" 559 : "attempt to set region of char primitive array elements with an object of type boolean[]"); 560 env_->SetIntArrayRegion(reinterpret_cast<jintArray>(array), 0, kLength, 561 reinterpret_cast<jint*>(elements)); 562 jni_abort_catcher.Check( 563 check_jni ? "incompatible array type boolean[] expected int[]" 564 : "attempt to set region of int primitive array elements with an object of type boolean[]"); 565 env_->SetLongArrayRegion(reinterpret_cast<jlongArray>(array), 0, kLength, 566 reinterpret_cast<jlong*>(elements)); 567 jni_abort_catcher.Check( 568 check_jni ? "incompatible array type boolean[] expected long[]" 569 : "attempt to set region of long primitive array elements with an object of type boolean[]"); 570 env_->SetFloatArrayRegion(reinterpret_cast<jfloatArray>(array), 0, kLength, 571 reinterpret_cast<jfloat*>(elements)); 572 jni_abort_catcher.Check( 573 check_jni ? "incompatible array type boolean[] expected float[]" 574 : "attempt to set region of float primitive array elements with an object of type boolean[]"); 575 env_->SetDoubleArrayRegion(reinterpret_cast<jdoubleArray>(array), 0, kLength, 576 reinterpret_cast<jdouble*>(elements)); 577 jni_abort_catcher.Check( 578 check_jni ? "incompatible array type boolean[] expected double[]" 579 : "attempt to set region of double primitive array elements with an object of type boolean[]"); 580 jbyteArray array2 = env_->NewByteArray(10); 581 env_->SetBooleanArrayRegion(reinterpret_cast<jbooleanArray>(array2), 0, kLength, 582 reinterpret_cast<jboolean*>(elements)); 583 jni_abort_catcher.Check( 584 check_jni ? "incompatible array type byte[] expected boolean[]" 585 : "attempt to set region of boolean primitive array elements with an object of type byte[]"); 586 jobject object = env_->NewStringUTF("Test String"); 587 env_->SetBooleanArrayRegion(reinterpret_cast<jbooleanArray>(object), 0, kLength, 588 reinterpret_cast<jboolean*>(elements)); 589 jni_abort_catcher.Check(check_jni ? "jarray argument has non-array type: java.lang.String" 590 : "attempt to set region of boolean primitive array elements with an object of type " 591 "java.lang.String"); 592 EXPECT_EQ(check_jni, vm_->SetCheckJniEnabled(old_check_jni)); 593 } 594 595 void NewObjectArrayBadArguments(bool check_jni) { 596 bool old_check_jni = vm_->SetCheckJniEnabled(check_jni); 597 CheckJniAbortCatcher jni_abort_catcher; 598 599 jclass element_class = env_->FindClass("java/lang/String"); 600 ASSERT_NE(element_class, nullptr); 601 602 env_->NewObjectArray(-1, element_class, nullptr); 603 jni_abort_catcher.Check(check_jni ? "negative jsize: -1" : "negative array length: -1"); 604 605 env_->NewObjectArray(std::numeric_limits<jint>::min(), element_class, nullptr); 606 jni_abort_catcher.Check(check_jni ? "negative jsize: -2147483648" 607 : "negative array length: -2147483648"); 608 609 EXPECT_EQ(check_jni, vm_->SetCheckJniEnabled(old_check_jni)); 610 } 611 612 void SetUpForTest(bool direct, const char* method_name, const char* method_sig, 613 void* native_fnptr) { 614 // Initialize class loader and set generic JNI entrypoint. 615 // Note: this code is adapted from the jni_compiler_test, and taken with minimal modifications. 616 if (!runtime_->IsStarted()) { 617 { 618 ScopedObjectAccess soa(Thread::Current()); 619 class_loader_ = LoadDex("MyClassNatives"); 620 StackHandleScope<1> hs(soa.Self()); 621 Handle<mirror::ClassLoader> loader( 622 hs.NewHandle(soa.Decode<mirror::ClassLoader*>(class_loader_))); 623 mirror::Class* c = class_linker_->FindClass(soa.Self(), "LMyClassNatives;", loader); 624 const auto pointer_size = class_linker_->GetImagePointerSize(); 625 ArtMethod* method = direct ? c->FindDirectMethod(method_name, method_sig, pointer_size) : 626 c->FindVirtualMethod(method_name, method_sig, pointer_size); 627 ASSERT_TRUE(method != nullptr) << method_name << " " << method_sig; 628 method->SetEntryPointFromQuickCompiledCode(class_linker_->GetRuntimeQuickGenericJniStub()); 629 } 630 // Start runtime. 631 Thread::Current()->TransitionFromSuspendedToRunnable(); 632 bool started = runtime_->Start(); 633 CHECK(started); 634 } 635 // JNI operations after runtime start. 636 env_ = Thread::Current()->GetJniEnv(); 637 jklass_ = env_->FindClass("MyClassNatives"); 638 ASSERT_TRUE(jklass_ != nullptr) << method_name << " " << method_sig; 639 640 if (direct) { 641 jmethod_ = env_->GetStaticMethodID(jklass_, method_name, method_sig); 642 } else { 643 jmethod_ = env_->GetMethodID(jklass_, method_name, method_sig); 644 } 645 ASSERT_TRUE(jmethod_ != nullptr) << method_name << " " << method_sig; 646 647 if (native_fnptr != nullptr) { 648 JNINativeMethod methods[] = { { method_name, method_sig, native_fnptr } }; 649 ASSERT_EQ(JNI_OK, env_->RegisterNatives(jklass_, methods, 1)) 650 << method_name << " " << method_sig; 651 } else { 652 env_->UnregisterNatives(jklass_); 653 } 654 655 jmethodID constructor = env_->GetMethodID(jklass_, "<init>", "()V"); 656 jobj_ = env_->NewObject(jklass_, constructor); 657 ASSERT_TRUE(jobj_ != nullptr) << method_name << " " << method_sig; 658 } 659 660 JavaVMExt* vm_; 661 JNIEnv* env_; 662 jclass aioobe_; 663 jclass ase_; 664 jclass sioobe_; 665 666 jclass jklass_; 667 jobject jobj_; 668 jobject class_loader_; 669 jmethodID jmethod_; 670}; 671 672TEST_F(JniInternalTest, AllocObject) { 673 jclass c = env_->FindClass("java/lang/String"); 674 ASSERT_NE(c, nullptr); 675 jobject o = env_->AllocObject(c); 676 ASSERT_NE(o, nullptr); 677 678 // We have an instance of the class we asked for... 679 ASSERT_TRUE(env_->IsInstanceOf(o, c)); 680 // ...whose fields haven't been initialized because 681 // we didn't call a constructor. 682 ASSERT_EQ(0, env_->GetIntField(o, env_->GetFieldID(c, "count", "I"))); 683} 684 685TEST_F(JniInternalTest, GetVersion) { 686 ASSERT_EQ(JNI_VERSION_1_6, env_->GetVersion()); 687} 688 689TEST_F(JniInternalTest, FindClass) { 690 // This tests leads to warnings in the log. 691 ScopedLogSeverity sls(LogSeverity::ERROR); 692 693 FindClassTest(false); 694 FindClassTest(true); 695} 696 697TEST_F(JniInternalTest, GetFieldID) { 698 jclass jlnsfe = env_->FindClass("java/lang/NoSuchFieldError"); 699 ASSERT_NE(jlnsfe, nullptr); 700 jclass c = env_->FindClass("java/lang/String"); 701 ASSERT_NE(c, nullptr); 702 703 // Wrong type. 704 jfieldID fid = env_->GetFieldID(c, "count", "J"); 705 EXPECT_EQ(nullptr, fid); 706 ExpectException(jlnsfe); 707 708 // Wrong type where type doesn't exist. 709 fid = env_->GetFieldID(c, "count", "Lrod/jane/freddy;"); 710 EXPECT_EQ(nullptr, fid); 711 ExpectException(jlnsfe); 712 713 // Wrong name. 714 fid = env_->GetFieldID(c, "Count", "I"); 715 EXPECT_EQ(nullptr, fid); 716 ExpectException(jlnsfe); 717 718 // Good declared field lookup. 719 fid = env_->GetFieldID(c, "count", "I"); 720 EXPECT_NE(nullptr, fid); 721 EXPECT_FALSE(env_->ExceptionCheck()); 722 723 // Good superclass field lookup. 724 c = env_->FindClass("java/lang/StringBuilder"); 725 fid = env_->GetFieldID(c, "count", "I"); 726 EXPECT_NE(nullptr, fid); 727 EXPECT_NE(fid, nullptr); 728 EXPECT_FALSE(env_->ExceptionCheck()); 729 730 // Not instance. 731 fid = env_->GetFieldID(c, "CASE_INSENSITIVE_ORDER", "Ljava/util/Comparator;"); 732 EXPECT_EQ(nullptr, fid); 733 ExpectException(jlnsfe); 734 735 // Bad arguments. 736 GetFieldIdBadArgumentTest(false); 737 GetFieldIdBadArgumentTest(true); 738} 739 740TEST_F(JniInternalTest, GetStaticFieldID) { 741 jclass jlnsfe = env_->FindClass("java/lang/NoSuchFieldError"); 742 ASSERT_NE(jlnsfe, nullptr); 743 jclass c = env_->FindClass("java/lang/String"); 744 ASSERT_NE(c, nullptr); 745 746 // Wrong type. 747 jfieldID fid = env_->GetStaticFieldID(c, "CASE_INSENSITIVE_ORDER", "J"); 748 EXPECT_EQ(nullptr, fid); 749 ExpectException(jlnsfe); 750 751 // Wrong type where type doesn't exist. 752 fid = env_->GetStaticFieldID(c, "CASE_INSENSITIVE_ORDER", "Lrod/jane/freddy;"); 753 EXPECT_EQ(nullptr, fid); 754 ExpectException(jlnsfe); 755 756 // Wrong name. 757 fid = env_->GetStaticFieldID(c, "cASE_INSENSITIVE_ORDER", "Ljava/util/Comparator;"); 758 EXPECT_EQ(nullptr, fid); 759 ExpectException(jlnsfe); 760 761 // Good declared field lookup. 762 fid = env_->GetStaticFieldID(c, "CASE_INSENSITIVE_ORDER", "Ljava/util/Comparator;"); 763 EXPECT_NE(nullptr, fid); 764 EXPECT_NE(fid, nullptr); 765 EXPECT_FALSE(env_->ExceptionCheck()); 766 767 // Not static. 768 fid = env_->GetStaticFieldID(c, "count", "I"); 769 EXPECT_EQ(nullptr, fid); 770 ExpectException(jlnsfe); 771 772 // Bad arguments. 773 GetStaticFieldIdBadArgumentTest(false); 774 GetStaticFieldIdBadArgumentTest(true); 775} 776 777TEST_F(JniInternalTest, GetMethodID) { 778 jclass jlobject = env_->FindClass("java/lang/Object"); 779 jclass jlstring = env_->FindClass("java/lang/String"); 780 jclass jlnsme = env_->FindClass("java/lang/NoSuchMethodError"); 781 jclass jncrbc = env_->FindClass("java/nio/channels/ReadableByteChannel"); 782 783 // Sanity check that no exceptions are pending. 784 ASSERT_FALSE(env_->ExceptionCheck()); 785 786 // Check that java.lang.Object.foo() doesn't exist and NoSuchMethodError is 787 // a pending exception. 788 jmethodID method = env_->GetMethodID(jlobject, "foo", "()V"); 789 EXPECT_EQ(nullptr, method); 790 ExpectException(jlnsme); 791 792 // Check that java.lang.Object.equals() does exist. 793 method = env_->GetMethodID(jlobject, "equals", "(Ljava/lang/Object;)Z"); 794 EXPECT_NE(nullptr, method); 795 EXPECT_FALSE(env_->ExceptionCheck()); 796 797 // Check that GetMethodID for java.lang.String.valueOf(int) fails as the 798 // method is static. 799 method = env_->GetMethodID(jlstring, "valueOf", "(I)Ljava/lang/String;"); 800 EXPECT_EQ(nullptr, method); 801 ExpectException(jlnsme); 802 803 // Check that GetMethodID for java.lang.NoSuchMethodError.<init>(String) finds the constructor. 804 method = env_->GetMethodID(jlnsme, "<init>", "(Ljava/lang/String;)V"); 805 EXPECT_NE(nullptr, method); 806 EXPECT_FALSE(env_->ExceptionCheck()); 807 808 // Check that GetMethodID can find a interface method inherited from another interface. 809 method = env_->GetMethodID(jncrbc, "close", "()V"); 810 EXPECT_NE(nullptr, method); 811 EXPECT_FALSE(env_->ExceptionCheck()); 812 813 // Bad arguments. 814 GetMethodIdBadArgumentTest(false); 815 GetMethodIdBadArgumentTest(true); 816} 817 818TEST_F(JniInternalTest, CallVoidMethodNullReceiver) { 819 jclass jlobject = env_->FindClass("java/lang/Object"); 820 jmethodID method; 821 822 // Check that GetMethodID for java.lang.NoSuchMethodError.<init>(String) finds the constructor. 823 method = env_->GetMethodID(jlobject, "<init>", "()V"); 824 EXPECT_NE(nullptr, method); 825 EXPECT_FALSE(env_->ExceptionCheck()); 826 827 // Null object to CallVoidMethod. 828 CheckJniAbortCatcher check_jni_abort_catcher; 829 env_->CallVoidMethod(nullptr, method); 830 check_jni_abort_catcher.Check("null"); 831} 832 833TEST_F(JniInternalTest, GetStaticMethodID) { 834 jclass jlobject = env_->FindClass("java/lang/Object"); 835 jclass jlnsme = env_->FindClass("java/lang/NoSuchMethodError"); 836 837 // Sanity check that no exceptions are pending 838 ASSERT_FALSE(env_->ExceptionCheck()); 839 840 // Check that java.lang.Object.foo() doesn't exist and NoSuchMethodError is 841 // a pending exception 842 jmethodID method = env_->GetStaticMethodID(jlobject, "foo", "()V"); 843 EXPECT_EQ(nullptr, method); 844 ExpectException(jlnsme); 845 846 // Check that GetStaticMethodID for java.lang.Object.equals(Object) fails as 847 // the method is not static 848 method = env_->GetStaticMethodID(jlobject, "equals", "(Ljava/lang/Object;)Z"); 849 EXPECT_EQ(nullptr, method); 850 ExpectException(jlnsme); 851 852 // Check that java.lang.String.valueOf(int) does exist 853 jclass jlstring = env_->FindClass("java/lang/String"); 854 method = env_->GetStaticMethodID(jlstring, "valueOf", "(I)Ljava/lang/String;"); 855 EXPECT_NE(nullptr, method); 856 EXPECT_FALSE(env_->ExceptionCheck()); 857 858 // Bad arguments. 859 GetStaticMethodIdBadArgumentTest(false); 860 GetStaticMethodIdBadArgumentTest(true); 861} 862 863TEST_F(JniInternalTest, FromReflectedField_ToReflectedField) { 864 jclass jlrField = env_->FindClass("java/lang/reflect/Field"); 865 jclass c = env_->FindClass("java/lang/String"); 866 ASSERT_NE(c, nullptr); 867 jfieldID fid = env_->GetFieldID(c, "count", "I"); 868 ASSERT_NE(fid, nullptr); 869 // Turn the fid into a java.lang.reflect.Field... 870 jobject field = env_->ToReflectedField(c, fid, JNI_FALSE); 871 for (size_t i = 0; i <= kLocalsMax; ++i) { 872 // Regression test for b/18396311, ToReflectedField leaking local refs causing a local 873 // reference table overflows with 512 references to ArtField 874 env_->DeleteLocalRef(env_->ToReflectedField(c, fid, JNI_FALSE)); 875 } 876 ASSERT_NE(c, nullptr); 877 ASSERT_TRUE(env_->IsInstanceOf(field, jlrField)); 878 // ...and back again. 879 jfieldID fid2 = env_->FromReflectedField(field); 880 ASSERT_NE(fid2, nullptr); 881 // Make sure we can actually use it. 882 jstring s = env_->NewStringUTF("poop"); 883 ASSERT_EQ(4, env_->GetIntField(s, fid2)); 884 885 // Bad arguments. 886 GetFromReflectedField_ToReflectedFieldBadArgumentTest(false); 887 GetFromReflectedField_ToReflectedFieldBadArgumentTest(true); 888} 889 890TEST_F(JniInternalTest, FromReflectedMethod_ToReflectedMethod) { 891 jclass jlrMethod = env_->FindClass("java/lang/reflect/Method"); 892 ASSERT_NE(jlrMethod, nullptr); 893 jclass jlrConstructor = env_->FindClass("java/lang/reflect/Constructor"); 894 ASSERT_NE(jlrConstructor, nullptr); 895 jclass c = env_->FindClass("java/lang/String"); 896 ASSERT_NE(c, nullptr); 897 898 jmethodID mid = env_->GetMethodID(c, "<init>", "()V"); 899 ASSERT_NE(mid, nullptr); 900 // Turn the mid into a java.lang.reflect.Constructor... 901 jobject method = env_->ToReflectedMethod(c, mid, JNI_FALSE); 902 for (size_t i = 0; i <= kLocalsMax; ++i) { 903 // Regression test for b/18396311, ToReflectedMethod leaking local refs causing a local 904 // reference table overflows with 512 references to ArtMethod 905 env_->DeleteLocalRef(env_->ToReflectedMethod(c, mid, JNI_FALSE)); 906 } 907 ASSERT_NE(method, nullptr); 908 ASSERT_TRUE(env_->IsInstanceOf(method, jlrConstructor)); 909 // ...and back again. 910 jmethodID mid2 = env_->FromReflectedMethod(method); 911 ASSERT_NE(mid2, nullptr); 912 // Make sure we can actually use it. 913 jstring s = reinterpret_cast<jstring>(env_->AllocObject(c)); 914 ASSERT_NE(s, nullptr); 915 env_->CallVoidMethod(s, mid2); 916 ASSERT_EQ(JNI_FALSE, env_->ExceptionCheck()); 917 env_->ExceptionClear(); 918 919 mid = env_->GetMethodID(c, "length", "()I"); 920 ASSERT_NE(mid, nullptr); 921 // Turn the mid into a java.lang.reflect.Method... 922 method = env_->ToReflectedMethod(c, mid, JNI_FALSE); 923 ASSERT_NE(method, nullptr); 924 ASSERT_TRUE(env_->IsInstanceOf(method, jlrMethod)); 925 // ...and back again. 926 mid2 = env_->FromReflectedMethod(method); 927 ASSERT_NE(mid2, nullptr); 928 // Make sure we can actually use it. 929 s = env_->NewStringUTF("poop"); 930 ASSERT_NE(s, nullptr); 931 ASSERT_EQ(4, env_->CallIntMethod(s, mid2)); 932 933 // Bad arguments. 934 GetFromReflectedMethod_ToReflectedMethodBadArgumentTest(false); 935 GetFromReflectedMethod_ToReflectedMethodBadArgumentTest(true); 936} 937 938static void BogusMethod() { 939 // You can't pass null function pointers to RegisterNatives. 940} 941 942TEST_F(JniInternalTest, RegisterAndUnregisterNatives) { 943 jclass jlobject = env_->FindClass("java/lang/Object"); 944 jclass jlnsme = env_->FindClass("java/lang/NoSuchMethodError"); 945 void* native_function = reinterpret_cast<void*>(BogusMethod); 946 947 // Sanity check that no exceptions are pending. 948 ASSERT_FALSE(env_->ExceptionCheck()); 949 950 // The following can print errors to the log we'd like to ignore. 951 { 952 ScopedLogSeverity sls(LogSeverity::FATAL); 953 // Check that registering method without name causes a NoSuchMethodError. 954 { 955 JNINativeMethod methods[] = { { nullptr, "()V", native_function } }; 956 EXPECT_EQ(env_->RegisterNatives(jlobject, methods, 1), JNI_ERR); 957 } 958 ExpectException(jlnsme); 959 960 // Check that registering method without signature causes a NoSuchMethodError. 961 { 962 JNINativeMethod methods[] = { { "notify", nullptr, native_function } }; 963 EXPECT_EQ(env_->RegisterNatives(jlobject, methods, 1), JNI_ERR); 964 } 965 ExpectException(jlnsme); 966 967 // Check that registering method without function causes a NoSuchMethodError. 968 { 969 JNINativeMethod methods[] = { { "notify", "()V", nullptr } }; 970 EXPECT_EQ(env_->RegisterNatives(jlobject, methods, 1), JNI_ERR); 971 } 972 ExpectException(jlnsme); 973 974 // Check that registering to a non-existent java.lang.Object.foo() causes a NoSuchMethodError. 975 { 976 JNINativeMethod methods[] = { { "foo", "()V", native_function } }; 977 EXPECT_EQ(env_->RegisterNatives(jlobject, methods, 1), JNI_ERR); 978 } 979 ExpectException(jlnsme); 980 981 // Check that registering non-native methods causes a NoSuchMethodError. 982 { 983 JNINativeMethod methods[] = { { "equals", "(Ljava/lang/Object;)Z", native_function } }; 984 EXPECT_EQ(env_->RegisterNatives(jlobject, methods, 1), JNI_ERR); 985 } 986 ExpectException(jlnsme); 987 } 988 989 // Check that registering native methods is successful. 990 { 991 JNINativeMethod methods[] = { { "notify", "()V", native_function } }; 992 EXPECT_EQ(env_->RegisterNatives(jlobject, methods, 1), JNI_OK); 993 } 994 EXPECT_FALSE(env_->ExceptionCheck()); 995 EXPECT_EQ(env_->UnregisterNatives(jlobject), JNI_OK); 996 997 // Check that registering no methods isn't a failure. 998 { 999 JNINativeMethod methods[] = { }; 1000 EXPECT_EQ(env_->RegisterNatives(jlobject, methods, 0), JNI_OK); 1001 } 1002 EXPECT_FALSE(env_->ExceptionCheck()); 1003 EXPECT_EQ(env_->UnregisterNatives(jlobject), JNI_OK); 1004 1005 // Check that registering a -ve number of methods is a failure. 1006 CheckJniAbortCatcher check_jni_abort_catcher; 1007 for (int i = -10; i < 0; ++i) { 1008 JNINativeMethod methods[] = { }; 1009 EXPECT_EQ(env_->RegisterNatives(jlobject, methods, i), JNI_ERR); 1010 check_jni_abort_catcher.Check("negative method count: "); 1011 } 1012 EXPECT_FALSE(env_->ExceptionCheck()); 1013 1014 // Unregistering a class with no natives is a warning. 1015 EXPECT_EQ(env_->UnregisterNatives(jlnsme), JNI_OK); 1016 1017 RegisterAndUnregisterNativesBadArguments(false, &check_jni_abort_catcher); 1018 RegisterAndUnregisterNativesBadArguments(true, &check_jni_abort_catcher); 1019} 1020 1021#define EXPECT_PRIMITIVE_ARRAY(new_fn, \ 1022 get_region_fn, \ 1023 set_region_fn, \ 1024 get_elements_fn, \ 1025 release_elements_fn, \ 1026 scalar_type, \ 1027 expected_class_descriptor) \ 1028 jsize size = 4; \ 1029 \ 1030 { \ 1031 CheckJniAbortCatcher jni_abort_catcher; \ 1032 down_cast<JNIEnvExt*>(env_)->SetCheckJniEnabled(false); \ 1033 /* Allocate an negative sized array and check it has the right failure type. */ \ 1034 EXPECT_EQ(env_->new_fn(-1), nullptr); \ 1035 jni_abort_catcher.Check("negative array length: -1"); \ 1036 EXPECT_EQ(env_->new_fn(std::numeric_limits<jint>::min()), nullptr); \ 1037 jni_abort_catcher.Check("negative array length: -2147483648"); \ 1038 /* Pass the array as null. */ \ 1039 EXPECT_EQ(0, env_->GetArrayLength(nullptr)); \ 1040 jni_abort_catcher.Check("java_array == null"); \ 1041 env_->get_region_fn(nullptr, 0, 0, nullptr); \ 1042 jni_abort_catcher.Check("java_array == null"); \ 1043 env_->set_region_fn(nullptr, 0, 0, nullptr); \ 1044 jni_abort_catcher.Check("java_array == null"); \ 1045 env_->get_elements_fn(nullptr, nullptr); \ 1046 jni_abort_catcher.Check("java_array == null"); \ 1047 env_->release_elements_fn(nullptr, nullptr, 0); \ 1048 jni_abort_catcher.Check("java_array == null"); \ 1049 /* Pass the elements for region as null. */ \ 1050 scalar_type ## Array a = env_->new_fn(size); \ 1051 env_->get_region_fn(a, 0, size, nullptr); \ 1052 jni_abort_catcher.Check("buf == null"); \ 1053 env_->set_region_fn(a, 0, size, nullptr); \ 1054 jni_abort_catcher.Check("buf == null"); \ 1055 down_cast<JNIEnvExt*>(env_)->SetCheckJniEnabled(true); \ 1056 } \ 1057 /* Allocate an array and check it has the right type and length. */ \ 1058 scalar_type ## Array a = env_->new_fn(size); \ 1059 EXPECT_NE(a, nullptr); \ 1060 EXPECT_TRUE(env_->IsInstanceOf(a, env_->FindClass(expected_class_descriptor))); \ 1061 EXPECT_EQ(size, env_->GetArrayLength(a)); \ 1062 \ 1063 /* GetPrimitiveArrayRegion/SetPrimitiveArrayRegion */ \ 1064 /* AIOOBE for negative start offset. */ \ 1065 env_->get_region_fn(a, -1, 1, nullptr); \ 1066 ExpectException(aioobe_); \ 1067 env_->set_region_fn(a, -1, 1, nullptr); \ 1068 ExpectException(aioobe_); \ 1069 \ 1070 /* AIOOBE for negative length. */ \ 1071 env_->get_region_fn(a, 0, -1, nullptr); \ 1072 ExpectException(aioobe_); \ 1073 env_->set_region_fn(a, 0, -1, nullptr); \ 1074 ExpectException(aioobe_); \ 1075 \ 1076 /* AIOOBE for buffer overrun. */ \ 1077 env_->get_region_fn(a, size - 1, size, nullptr); \ 1078 ExpectException(aioobe_); \ 1079 env_->set_region_fn(a, size - 1, size, nullptr); \ 1080 ExpectException(aioobe_); \ 1081 \ 1082 /* Regression test against integer overflow in range check. */ \ 1083 env_->get_region_fn(a, 0x7fffffff, 0x7fffffff, nullptr); \ 1084 ExpectException(aioobe_); \ 1085 env_->set_region_fn(a, 0x7fffffff, 0x7fffffff, nullptr); \ 1086 ExpectException(aioobe_); \ 1087 \ 1088 /* It's okay for the buffer to be null as long as the length is 0. */ \ 1089 env_->get_region_fn(a, 2, 0, nullptr); \ 1090 /* Even if the offset is invalid... */ \ 1091 env_->get_region_fn(a, 123, 0, nullptr); \ 1092 ExpectException(aioobe_); \ 1093 \ 1094 /* It's okay for the buffer to be null as long as the length is 0. */ \ 1095 env_->set_region_fn(a, 2, 0, nullptr); \ 1096 /* Even if the offset is invalid... */ \ 1097 env_->set_region_fn(a, 123, 0, nullptr); \ 1098 ExpectException(aioobe_); \ 1099 \ 1100 /* Prepare a couple of buffers. */ \ 1101 std::unique_ptr<scalar_type[]> src_buf(new scalar_type[size]); \ 1102 std::unique_ptr<scalar_type[]> dst_buf(new scalar_type[size]); \ 1103 for (jsize i = 0; i < size; ++i) { src_buf[i] = scalar_type(i); } \ 1104 for (jsize i = 0; i < size; ++i) { dst_buf[i] = scalar_type(-1); } \ 1105 \ 1106 /* Copy all of src_buf onto the heap. */ \ 1107 env_->set_region_fn(a, 0, size, &src_buf[0]); \ 1108 /* Copy back only part. */ \ 1109 env_->get_region_fn(a, 1, size - 2, &dst_buf[1]); \ 1110 EXPECT_NE(memcmp(&src_buf[0], &dst_buf[0], size * sizeof(scalar_type)), 0) \ 1111 << "short copy equal"; \ 1112 /* Copy the missing pieces. */ \ 1113 env_->get_region_fn(a, 0, 1, &dst_buf[0]); \ 1114 env_->get_region_fn(a, size - 1, 1, &dst_buf[size - 1]); \ 1115 EXPECT_EQ(memcmp(&src_buf[0], &dst_buf[0], size * sizeof(scalar_type)), 0) \ 1116 << "fixed copy not equal"; \ 1117 /* Copy back the whole array. */ \ 1118 env_->get_region_fn(a, 0, size, &dst_buf[0]); \ 1119 EXPECT_EQ(memcmp(&src_buf[0], &dst_buf[0], size * sizeof(scalar_type)), 0) \ 1120 << "full copy not equal"; \ 1121 /* GetPrimitiveArrayCritical */ \ 1122 void* v = env_->GetPrimitiveArrayCritical(a, nullptr); \ 1123 EXPECT_EQ(memcmp(&src_buf[0], v, size * sizeof(scalar_type)), 0) \ 1124 << "GetPrimitiveArrayCritical not equal"; \ 1125 env_->ReleasePrimitiveArrayCritical(a, v, 0); \ 1126 /* GetXArrayElements */ \ 1127 scalar_type* xs = env_->get_elements_fn(a, nullptr); \ 1128 EXPECT_EQ(memcmp(&src_buf[0], xs, size * sizeof(scalar_type)), 0) \ 1129 << # get_elements_fn " not equal"; \ 1130 env_->release_elements_fn(a, xs, 0); \ 1131 1132TEST_F(JniInternalTest, BooleanArrays) { 1133 EXPECT_PRIMITIVE_ARRAY(NewBooleanArray, GetBooleanArrayRegion, SetBooleanArrayRegion, 1134 GetBooleanArrayElements, ReleaseBooleanArrayElements, jboolean, "[Z"); 1135} 1136TEST_F(JniInternalTest, ByteArrays) { 1137 EXPECT_PRIMITIVE_ARRAY(NewByteArray, GetByteArrayRegion, SetByteArrayRegion, 1138 GetByteArrayElements, ReleaseByteArrayElements, jbyte, "[B"); 1139} 1140TEST_F(JniInternalTest, CharArrays) { 1141 EXPECT_PRIMITIVE_ARRAY(NewCharArray, GetCharArrayRegion, SetCharArrayRegion, 1142 GetCharArrayElements, ReleaseCharArrayElements, jchar, "[C"); 1143} 1144TEST_F(JniInternalTest, DoubleArrays) { 1145 EXPECT_PRIMITIVE_ARRAY(NewDoubleArray, GetDoubleArrayRegion, SetDoubleArrayRegion, 1146 GetDoubleArrayElements, ReleaseDoubleArrayElements, jdouble, "[D"); 1147} 1148TEST_F(JniInternalTest, FloatArrays) { 1149 EXPECT_PRIMITIVE_ARRAY(NewFloatArray, GetFloatArrayRegion, SetFloatArrayRegion, 1150 GetFloatArrayElements, ReleaseFloatArrayElements, jfloat, "[F"); 1151} 1152TEST_F(JniInternalTest, IntArrays) { 1153 EXPECT_PRIMITIVE_ARRAY(NewIntArray, GetIntArrayRegion, SetIntArrayRegion, 1154 GetIntArrayElements, ReleaseIntArrayElements, jint, "[I"); 1155} 1156TEST_F(JniInternalTest, LongArrays) { 1157 EXPECT_PRIMITIVE_ARRAY(NewLongArray, GetLongArrayRegion, SetLongArrayRegion, 1158 GetLongArrayElements, ReleaseLongArrayElements, jlong, "[J"); 1159} 1160TEST_F(JniInternalTest, ShortArrays) { 1161 EXPECT_PRIMITIVE_ARRAY(NewShortArray, GetShortArrayRegion, SetShortArrayRegion, 1162 GetShortArrayElements, ReleaseShortArrayElements, jshort, "[S"); 1163} 1164 1165TEST_F(JniInternalTest, GetPrimitiveArrayElementsOfWrongType) { 1166 GetPrimitiveArrayElementsOfWrongType(false); 1167 GetPrimitiveArrayElementsOfWrongType(true); 1168} 1169 1170TEST_F(JniInternalTest, ReleasePrimitiveArrayElementsOfWrongType) { 1171 ReleasePrimitiveArrayElementsOfWrongType(false); 1172 ReleasePrimitiveArrayElementsOfWrongType(true); 1173} 1174 1175TEST_F(JniInternalTest, GetReleasePrimitiveArrayCriticalOfWrongType) { 1176 GetReleasePrimitiveArrayCriticalOfWrongType(false); 1177 GetReleasePrimitiveArrayCriticalOfWrongType(true); 1178} 1179 1180TEST_F(JniInternalTest, GetPrimitiveArrayRegionElementsOfWrongType) { 1181 GetPrimitiveArrayRegionElementsOfWrongType(false); 1182 GetPrimitiveArrayRegionElementsOfWrongType(true); 1183} 1184 1185TEST_F(JniInternalTest, SetPrimitiveArrayRegionElementsOfWrongType) { 1186 SetPrimitiveArrayRegionElementsOfWrongType(false); 1187 SetPrimitiveArrayRegionElementsOfWrongType(true); 1188} 1189 1190TEST_F(JniInternalTest, NewObjectArray) { 1191 jclass element_class = env_->FindClass("java/lang/String"); 1192 ASSERT_NE(element_class, nullptr); 1193 jclass array_class = env_->FindClass("[Ljava/lang/String;"); 1194 ASSERT_NE(array_class, nullptr); 1195 1196 jobjectArray a = env_->NewObjectArray(0, element_class, nullptr); 1197 EXPECT_NE(a, nullptr); 1198 EXPECT_TRUE(env_->IsInstanceOf(a, array_class)); 1199 EXPECT_EQ(0, env_->GetArrayLength(a)); 1200 1201 a = env_->NewObjectArray(1, element_class, nullptr); 1202 EXPECT_NE(a, nullptr); 1203 EXPECT_TRUE(env_->IsInstanceOf(a, array_class)); 1204 EXPECT_EQ(1, env_->GetArrayLength(a)); 1205 EXPECT_TRUE(env_->IsSameObject(env_->GetObjectArrayElement(a, 0), nullptr)); 1206 1207 // Negative array length checks. 1208 NewObjectArrayBadArguments(false); 1209 NewObjectArrayBadArguments(true); 1210} 1211 1212TEST_F(JniInternalTest, NewObjectArrayWithPrimitiveClasses) { 1213 const char* primitive_descriptors = "VZBSCIJFD"; 1214 const char* primitive_names[] = { 1215 "void", "boolean", "byte", "short", "char", "int", "long", "float", "double" 1216 }; 1217 ASSERT_EQ(strlen(primitive_descriptors), arraysize(primitive_names)); 1218 1219 bool old_check_jni = vm_->SetCheckJniEnabled(false); 1220 CheckJniAbortCatcher jni_abort_catcher; 1221 for (size_t i = 0; i < strlen(primitive_descriptors); ++i) { 1222 env_->NewObjectArray(0, nullptr, nullptr); 1223 jni_abort_catcher.Check("element_jclass == null"); 1224 jclass primitive_class = GetPrimitiveClass(primitive_descriptors[i]); 1225 env_->NewObjectArray(1, primitive_class, nullptr); 1226 std::string error_msg(StringPrintf("not an object type: %s", primitive_names[i])); 1227 jni_abort_catcher.Check(error_msg.c_str()); 1228 } 1229 EXPECT_FALSE(vm_->SetCheckJniEnabled(true)); 1230 for (size_t i = 0; i < strlen(primitive_descriptors); ++i) { 1231 env_->NewObjectArray(0, nullptr, nullptr); 1232 jni_abort_catcher.Check("NewObjectArray received NULL jclass"); 1233 jclass primitive_class = GetPrimitiveClass(primitive_descriptors[i]); 1234 env_->NewObjectArray(1, primitive_class, nullptr); 1235 std::string error_msg(StringPrintf("not an object type: %s", primitive_names[i])); 1236 jni_abort_catcher.Check(error_msg.c_str()); 1237 } 1238 EXPECT_TRUE(vm_->SetCheckJniEnabled(old_check_jni)); 1239} 1240 1241TEST_F(JniInternalTest, NewObjectArrayWithInitialValue) { 1242 jclass element_class = env_->FindClass("java/lang/String"); 1243 ASSERT_NE(element_class, nullptr); 1244 jclass array_class = env_->FindClass("[Ljava/lang/String;"); 1245 ASSERT_NE(array_class, nullptr); 1246 1247 jstring s = env_->NewStringUTF("poop"); 1248 jobjectArray a = env_->NewObjectArray(2, element_class, s); 1249 EXPECT_NE(a, nullptr); 1250 EXPECT_TRUE(env_->IsInstanceOf(a, array_class)); 1251 EXPECT_EQ(2, env_->GetArrayLength(a)); 1252 EXPECT_TRUE(env_->IsSameObject(env_->GetObjectArrayElement(a, 0), s)); 1253 EXPECT_TRUE(env_->IsSameObject(env_->GetObjectArrayElement(a, 1), s)); 1254 1255 // Attempt to incorrect create an array of strings with initial value of string arrays. 1256 CheckJniAbortCatcher jni_abort_catcher; 1257 env_->NewObjectArray(2, element_class, a); 1258 jni_abort_catcher.Check("cannot assign object of type 'java.lang.String[]' to array with element " 1259 "type of 'java.lang.String'"); 1260} 1261 1262TEST_F(JniInternalTest, GetArrayLength) { 1263 // Already tested in NewObjectArray/NewPrimitiveArray except for null. 1264 CheckJniAbortCatcher jni_abort_catcher; 1265 bool old_check_jni = vm_->SetCheckJniEnabled(false); 1266 EXPECT_EQ(0, env_->GetArrayLength(nullptr)); 1267 jni_abort_catcher.Check("java_array == null"); 1268 EXPECT_FALSE(vm_->SetCheckJniEnabled(true)); 1269 EXPECT_EQ(JNI_ERR, env_->GetArrayLength(nullptr)); 1270 jni_abort_catcher.Check("jarray was NULL"); 1271 EXPECT_TRUE(vm_->SetCheckJniEnabled(old_check_jni)); 1272} 1273 1274TEST_F(JniInternalTest, GetObjectClass) { 1275 jclass string_class = env_->FindClass("java/lang/String"); 1276 ASSERT_NE(string_class, nullptr); 1277 jclass class_class = env_->FindClass("java/lang/Class"); 1278 ASSERT_NE(class_class, nullptr); 1279 1280 jstring s = env_->NewStringUTF("poop"); 1281 jclass c = env_->GetObjectClass(s); 1282 ASSERT_TRUE(env_->IsSameObject(string_class, c)); 1283 1284 jclass c2 = env_->GetObjectClass(c); 1285 ASSERT_TRUE(env_->IsSameObject(class_class, env_->GetObjectClass(c2))); 1286 1287 // Null as object should fail. 1288 CheckJniAbortCatcher jni_abort_catcher; 1289 EXPECT_EQ(env_->GetObjectClass(nullptr), nullptr); 1290 jni_abort_catcher.Check("java_object == null"); 1291} 1292 1293TEST_F(JniInternalTest, GetSuperclass) { 1294 jclass object_class = env_->FindClass("java/lang/Object"); 1295 ASSERT_NE(object_class, nullptr); 1296 jclass string_class = env_->FindClass("java/lang/String"); 1297 ASSERT_NE(string_class, nullptr); 1298 jclass runnable_interface = env_->FindClass("java/lang/Runnable"); 1299 ASSERT_NE(runnable_interface, nullptr); 1300 ASSERT_TRUE(env_->IsSameObject(object_class, env_->GetSuperclass(string_class))); 1301 ASSERT_EQ(env_->GetSuperclass(object_class), nullptr); 1302 ASSERT_EQ(env_->GetSuperclass(runnable_interface), nullptr); 1303 1304 // Null as class should fail. 1305 CheckJniAbortCatcher jni_abort_catcher; 1306 bool old_check_jni = vm_->SetCheckJniEnabled(false); 1307 EXPECT_EQ(env_->GetSuperclass(nullptr), nullptr); 1308 jni_abort_catcher.Check("java_class == null"); 1309 EXPECT_FALSE(vm_->SetCheckJniEnabled(true)); 1310 EXPECT_EQ(env_->GetSuperclass(nullptr), nullptr); 1311 jni_abort_catcher.Check("GetSuperclass received NULL jclass"); 1312 EXPECT_TRUE(vm_->SetCheckJniEnabled(old_check_jni)); 1313} 1314 1315TEST_F(JniInternalTest, IsAssignableFrom) { 1316 jclass object_class = env_->FindClass("java/lang/Object"); 1317 ASSERT_NE(object_class, nullptr); 1318 jclass string_class = env_->FindClass("java/lang/String"); 1319 ASSERT_NE(string_class, nullptr); 1320 1321 // A superclass is assignable from an instance of its 1322 // subclass but not vice versa. 1323 ASSERT_TRUE(env_->IsAssignableFrom(string_class, object_class)); 1324 ASSERT_FALSE(env_->IsAssignableFrom(object_class, string_class)); 1325 1326 jclass charsequence_interface = env_->FindClass("java/lang/CharSequence"); 1327 ASSERT_NE(charsequence_interface, nullptr); 1328 1329 // An interface is assignable from an instance of an implementing 1330 // class but not vice versa. 1331 ASSERT_TRUE(env_->IsAssignableFrom(string_class, charsequence_interface)); 1332 ASSERT_FALSE(env_->IsAssignableFrom(charsequence_interface, string_class)); 1333 1334 // Check that arrays are covariant. 1335 jclass string_array_class = env_->FindClass("[Ljava/lang/String;"); 1336 ASSERT_NE(string_array_class, nullptr); 1337 jclass object_array_class = env_->FindClass("[Ljava/lang/Object;"); 1338 ASSERT_NE(object_array_class, nullptr); 1339 ASSERT_TRUE(env_->IsAssignableFrom(string_array_class, object_array_class)); 1340 ASSERT_FALSE(env_->IsAssignableFrom(object_array_class, string_array_class)); 1341 1342 // Primitive types are tested in 004-JniTest. 1343 1344 // Null as either class should fail. 1345 CheckJniAbortCatcher jni_abort_catcher; 1346 bool old_check_jni = vm_->SetCheckJniEnabled(false); 1347 EXPECT_EQ(env_->IsAssignableFrom(nullptr, string_class), JNI_FALSE); 1348 jni_abort_catcher.Check("java_class1 == null"); 1349 EXPECT_EQ(env_->IsAssignableFrom(object_class, nullptr), JNI_FALSE); 1350 jni_abort_catcher.Check("java_class2 == null"); 1351 EXPECT_FALSE(vm_->SetCheckJniEnabled(true)); 1352 EXPECT_EQ(env_->IsAssignableFrom(nullptr, string_class), JNI_FALSE); 1353 jni_abort_catcher.Check("IsAssignableFrom received NULL jclass"); 1354 EXPECT_EQ(env_->IsAssignableFrom(object_class, nullptr), JNI_FALSE); 1355 jni_abort_catcher.Check("IsAssignableFrom received NULL jclass"); 1356 EXPECT_TRUE(vm_->SetCheckJniEnabled(old_check_jni)); 1357} 1358 1359TEST_F(JniInternalTest, GetObjectRefType) { 1360 jclass local = env_->FindClass("java/lang/Object"); 1361 ASSERT_TRUE(local != nullptr); 1362 EXPECT_EQ(JNILocalRefType, env_->GetObjectRefType(local)); 1363 1364 jobject global = env_->NewGlobalRef(local); 1365 EXPECT_EQ(JNIGlobalRefType, env_->GetObjectRefType(global)); 1366 1367 jweak weak_global = env_->NewWeakGlobalRef(local); 1368 EXPECT_EQ(JNIWeakGlobalRefType, env_->GetObjectRefType(weak_global)); 1369 1370 { 1371 CheckJniAbortCatcher jni_abort_catcher; 1372 jobject invalid = reinterpret_cast<jobject>(this); 1373 EXPECT_EQ(JNIInvalidRefType, env_->GetObjectRefType(invalid)); 1374 jni_abort_catcher.Check("use of invalid jobject"); 1375 } 1376 1377 // TODO: invoke a native method and test that its arguments are considered local references. 1378 1379 // Null as pointer should not fail and return invalid-ref. b/18820997 1380 EXPECT_EQ(JNIInvalidRefType, env_->GetObjectRefType(nullptr)); 1381 1382 // TODO: Null as reference should return the original type. 1383 // This requires running a GC so a non-null object gets freed. 1384} 1385 1386TEST_F(JniInternalTest, StaleWeakGlobal) { 1387 jclass java_lang_Class = env_->FindClass("java/lang/Class"); 1388 ASSERT_NE(java_lang_Class, nullptr); 1389 jobjectArray local_ref = env_->NewObjectArray(1, java_lang_Class, nullptr); 1390 ASSERT_NE(local_ref, nullptr); 1391 jweak weak_global = env_->NewWeakGlobalRef(local_ref); 1392 ASSERT_NE(weak_global, nullptr); 1393 env_->DeleteLocalRef(local_ref); 1394 Runtime::Current()->GetHeap()->CollectGarbage(false); // GC should clear the weak global. 1395 jobject new_global_ref = env_->NewGlobalRef(weak_global); 1396 EXPECT_EQ(new_global_ref, nullptr); 1397 jobject new_local_ref = env_->NewLocalRef(weak_global); 1398 EXPECT_EQ(new_local_ref, nullptr); 1399} 1400 1401TEST_F(JniInternalTest, NewStringUTF) { 1402 EXPECT_EQ(env_->NewStringUTF(nullptr), nullptr); 1403 jstring s; 1404 1405 s = env_->NewStringUTF(""); 1406 EXPECT_NE(s, nullptr); 1407 EXPECT_EQ(0, env_->GetStringLength(s)); 1408 EXPECT_EQ(0, env_->GetStringUTFLength(s)); 1409 s = env_->NewStringUTF("hello"); 1410 EXPECT_NE(s, nullptr); 1411 EXPECT_EQ(5, env_->GetStringLength(s)); 1412 EXPECT_EQ(5, env_->GetStringUTFLength(s)); 1413 1414 // Encoded surrogate pair. 1415 s = env_->NewStringUTF("\xed\xa0\x81\xed\xb0\x80"); 1416 EXPECT_NE(s, nullptr); 1417 EXPECT_EQ(2, env_->GetStringLength(s)); 1418 1419 // The surrogate pair gets encoded into a 4 byte UTF sequence.. 1420 EXPECT_EQ(4, env_->GetStringUTFLength(s)); 1421 const char* chars = env_->GetStringUTFChars(s, nullptr); 1422 EXPECT_STREQ("\xf0\x90\x90\x80", chars); 1423 env_->ReleaseStringUTFChars(s, chars); 1424 1425 // .. but is stored as is in the utf-16 representation. 1426 const jchar* jchars = env_->GetStringChars(s, nullptr); 1427 EXPECT_EQ(0xd801, jchars[0]); 1428 EXPECT_EQ(0xdc00, jchars[1]); 1429 env_->ReleaseStringChars(s, jchars); 1430 1431 // 4 byte UTF sequence appended to an encoded surrogate pair. 1432 s = env_->NewStringUTF("\xed\xa0\x81\xed\xb0\x80 \xf0\x9f\x8f\xa0"); 1433 EXPECT_NE(s, nullptr); 1434 1435 // The 4 byte sequence {0xf0, 0x9f, 0x8f, 0xa0} is converted into a surrogate 1436 // pair {0xd83c, 0xdfe0}. 1437 EXPECT_EQ(5, env_->GetStringLength(s)); 1438 jchars = env_->GetStringChars(s, nullptr); 1439 // The first surrogate pair, encoded as such in the input. 1440 EXPECT_EQ(0xd801, jchars[0]); 1441 EXPECT_EQ(0xdc00, jchars[1]); 1442 // The second surrogate pair, from the 4 byte UTF sequence in the input. 1443 EXPECT_EQ(0xd83c, jchars[3]); 1444 EXPECT_EQ(0xdfe0, jchars[4]); 1445 env_->ReleaseStringChars(s, jchars); 1446 1447 EXPECT_EQ(9, env_->GetStringUTFLength(s)); 1448 chars = env_->GetStringUTFChars(s, nullptr); 1449 EXPECT_STREQ("\xf0\x90\x90\x80 \xf0\x9f\x8f\xa0", chars); 1450 env_->ReleaseStringUTFChars(s, chars); 1451 1452 // A string with 1, 2, 3 and 4 byte UTF sequences with spaces 1453 // between them 1454 s = env_->NewStringUTF("\x24 \xc2\xa2 \xe2\x82\xac \xf0\x9f\x8f\xa0"); 1455 EXPECT_NE(s, nullptr); 1456 EXPECT_EQ(8, env_->GetStringLength(s)); 1457 EXPECT_EQ(13, env_->GetStringUTFLength(s)); 1458} 1459 1460TEST_F(JniInternalTest, NewString) { 1461 jchar chars[] = { 'h', 'i' }; 1462 jstring s; 1463 s = env_->NewString(chars, 0); 1464 EXPECT_NE(s, nullptr); 1465 EXPECT_EQ(0, env_->GetStringLength(s)); 1466 EXPECT_EQ(0, env_->GetStringUTFLength(s)); 1467 s = env_->NewString(chars, 2); 1468 EXPECT_NE(s, nullptr); 1469 EXPECT_EQ(2, env_->GetStringLength(s)); 1470 EXPECT_EQ(2, env_->GetStringUTFLength(s)); 1471 1472 // TODO: check some non-ASCII strings. 1473} 1474 1475TEST_F(JniInternalTest, NewStringNullCharsZeroLength) { 1476 jstring s = env_->NewString(nullptr, 0); 1477 EXPECT_NE(s, nullptr); 1478 EXPECT_EQ(0, env_->GetStringLength(s)); 1479} 1480 1481TEST_F(JniInternalTest, NewStringNullCharsNonzeroLength) { 1482 CheckJniAbortCatcher jni_abort_catcher; 1483 env_->NewString(nullptr, 1); 1484 jni_abort_catcher.Check("chars == null && char_count > 0"); 1485} 1486 1487TEST_F(JniInternalTest, NewStringNegativeLength) { 1488 CheckJniAbortCatcher jni_abort_catcher; 1489 bool old_check_jni = vm_->SetCheckJniEnabled(false); 1490 env_->NewString(nullptr, -1); 1491 jni_abort_catcher.Check("char_count < 0: -1"); 1492 env_->NewString(nullptr, std::numeric_limits<jint>::min()); 1493 jni_abort_catcher.Check("char_count < 0: -2147483648"); 1494 EXPECT_FALSE(vm_->SetCheckJniEnabled(true)); 1495 env_->NewString(nullptr, -1); 1496 jni_abort_catcher.Check("negative jsize: -1"); 1497 env_->NewString(nullptr, std::numeric_limits<jint>::min()); 1498 jni_abort_catcher.Check("negative jsize: -2147483648"); 1499 EXPECT_TRUE(vm_->SetCheckJniEnabled(old_check_jni)); 1500} 1501 1502TEST_F(JniInternalTest, GetStringLength_GetStringUTFLength) { 1503 // Already tested in the NewString/NewStringUTF tests. 1504} 1505 1506TEST_F(JniInternalTest, GetStringRegion_GetStringUTFRegion) { 1507 jstring s = env_->NewStringUTF("hello"); 1508 ASSERT_TRUE(s != nullptr); 1509 1510 env_->GetStringRegion(s, -1, 0, nullptr); 1511 ExpectException(sioobe_); 1512 env_->GetStringRegion(s, 0, -1, nullptr); 1513 ExpectException(sioobe_); 1514 env_->GetStringRegion(s, 0, 10, nullptr); 1515 ExpectException(sioobe_); 1516 env_->GetStringRegion(s, 10, 1, nullptr); 1517 ExpectException(sioobe_); 1518 // Regression test against integer overflow in range check. 1519 env_->GetStringRegion(s, 0x7fffffff, 0x7fffffff, nullptr); 1520 ExpectException(sioobe_); 1521 1522 jchar chars[4] = { 'x', 'x', 'x', 'x' }; 1523 env_->GetStringRegion(s, 1, 2, &chars[1]); 1524 EXPECT_EQ('x', chars[0]); 1525 EXPECT_EQ('e', chars[1]); 1526 EXPECT_EQ('l', chars[2]); 1527 EXPECT_EQ('x', chars[3]); 1528 1529 // It's okay for the buffer to be null as long as the length is 0. 1530 env_->GetStringRegion(s, 2, 0, nullptr); 1531 // Even if the offset is invalid... 1532 env_->GetStringRegion(s, 123, 0, nullptr); 1533 ExpectException(sioobe_); 1534 1535 env_->GetStringUTFRegion(s, -1, 0, nullptr); 1536 ExpectException(sioobe_); 1537 env_->GetStringUTFRegion(s, 0, -1, nullptr); 1538 ExpectException(sioobe_); 1539 env_->GetStringUTFRegion(s, 0, 10, nullptr); 1540 ExpectException(sioobe_); 1541 env_->GetStringUTFRegion(s, 10, 1, nullptr); 1542 ExpectException(sioobe_); 1543 // Regression test against integer overflow in range check. 1544 env_->GetStringUTFRegion(s, 0x7fffffff, 0x7fffffff, nullptr); 1545 ExpectException(sioobe_); 1546 1547 char bytes[4] = { 'x', 'x', 'x', 'x' }; 1548 env_->GetStringUTFRegion(s, 1, 2, &bytes[1]); 1549 EXPECT_EQ('x', bytes[0]); 1550 EXPECT_EQ('e', bytes[1]); 1551 EXPECT_EQ('l', bytes[2]); 1552 EXPECT_EQ('x', bytes[3]); 1553 1554 // It's okay for the buffer to be null as long as the length is 0. 1555 env_->GetStringUTFRegion(s, 2, 0, nullptr); 1556 // Even if the offset is invalid... 1557 env_->GetStringUTFRegion(s, 123, 0, nullptr); 1558 ExpectException(sioobe_); 1559} 1560 1561TEST_F(JniInternalTest, GetStringUTFChars_ReleaseStringUTFChars) { 1562 // Passing in a null jstring is ignored normally, but caught by -Xcheck:jni. 1563 bool old_check_jni = vm_->SetCheckJniEnabled(false); 1564 { 1565 CheckJniAbortCatcher check_jni_abort_catcher; 1566 EXPECT_EQ(env_->GetStringUTFChars(nullptr, nullptr), nullptr); 1567 } 1568 { 1569 CheckJniAbortCatcher check_jni_abort_catcher; 1570 EXPECT_FALSE(vm_->SetCheckJniEnabled(true)); 1571 EXPECT_EQ(env_->GetStringUTFChars(nullptr, nullptr), nullptr); 1572 check_jni_abort_catcher.Check("GetStringUTFChars received NULL jstring"); 1573 EXPECT_TRUE(vm_->SetCheckJniEnabled(old_check_jni)); 1574 } 1575 1576 jstring s = env_->NewStringUTF("hello"); 1577 ASSERT_TRUE(s != nullptr); 1578 1579 const char* utf = env_->GetStringUTFChars(s, nullptr); 1580 EXPECT_STREQ("hello", utf); 1581 env_->ReleaseStringUTFChars(s, utf); 1582 1583 jboolean is_copy = JNI_FALSE; 1584 utf = env_->GetStringUTFChars(s, &is_copy); 1585 EXPECT_EQ(JNI_TRUE, is_copy); 1586 EXPECT_STREQ("hello", utf); 1587 env_->ReleaseStringUTFChars(s, utf); 1588} 1589 1590TEST_F(JniInternalTest, GetStringChars_ReleaseStringChars) { 1591 jstring s = env_->NewStringUTF("hello"); 1592 ScopedObjectAccess soa(env_); 1593 mirror::String* s_m = soa.Decode<mirror::String*>(s); 1594 ASSERT_TRUE(s != nullptr); 1595 1596 jchar expected[] = { 'h', 'e', 'l', 'l', 'o' }; 1597 const jchar* chars = env_->GetStringChars(s, nullptr); 1598 EXPECT_EQ(expected[0], chars[0]); 1599 EXPECT_EQ(expected[1], chars[1]); 1600 EXPECT_EQ(expected[2], chars[2]); 1601 EXPECT_EQ(expected[3], chars[3]); 1602 EXPECT_EQ(expected[4], chars[4]); 1603 env_->ReleaseStringChars(s, chars); 1604 1605 jboolean is_copy = JNI_FALSE; 1606 chars = env_->GetStringChars(s, &is_copy); 1607 if (Runtime::Current()->GetHeap()->IsMovableObject(s_m)) { 1608 EXPECT_EQ(JNI_TRUE, is_copy); 1609 } else { 1610 EXPECT_EQ(JNI_FALSE, is_copy); 1611 } 1612 EXPECT_EQ(expected[0], chars[0]); 1613 EXPECT_EQ(expected[1], chars[1]); 1614 EXPECT_EQ(expected[2], chars[2]); 1615 EXPECT_EQ(expected[3], chars[3]); 1616 EXPECT_EQ(expected[4], chars[4]); 1617 env_->ReleaseStringChars(s, chars); 1618} 1619 1620TEST_F(JniInternalTest, GetStringCritical_ReleaseStringCritical) { 1621 jstring s = env_->NewStringUTF("hello"); 1622 ASSERT_TRUE(s != nullptr); 1623 1624 jchar expected[] = { 'h', 'e', 'l', 'l', 'o' }; 1625 const jchar* chars = env_->GetStringCritical(s, nullptr); 1626 EXPECT_EQ(expected[0], chars[0]); 1627 EXPECT_EQ(expected[1], chars[1]); 1628 EXPECT_EQ(expected[2], chars[2]); 1629 EXPECT_EQ(expected[3], chars[3]); 1630 EXPECT_EQ(expected[4], chars[4]); 1631 env_->ReleaseStringCritical(s, chars); 1632 1633 jboolean is_copy = JNI_TRUE; 1634 chars = env_->GetStringCritical(s, &is_copy); 1635 EXPECT_EQ(JNI_FALSE, is_copy); 1636 EXPECT_EQ(expected[0], chars[0]); 1637 EXPECT_EQ(expected[1], chars[1]); 1638 EXPECT_EQ(expected[2], chars[2]); 1639 EXPECT_EQ(expected[3], chars[3]); 1640 EXPECT_EQ(expected[4], chars[4]); 1641 env_->ReleaseStringCritical(s, chars); 1642} 1643 1644TEST_F(JniInternalTest, GetObjectArrayElement_SetObjectArrayElement) { 1645 jclass java_lang_Class = env_->FindClass("java/lang/Class"); 1646 ASSERT_TRUE(java_lang_Class != nullptr); 1647 1648 jobjectArray array = env_->NewObjectArray(1, java_lang_Class, nullptr); 1649 EXPECT_NE(array, nullptr); 1650 EXPECT_EQ(env_->GetObjectArrayElement(array, 0), nullptr); 1651 env_->SetObjectArrayElement(array, 0, java_lang_Class); 1652 EXPECT_TRUE(env_->IsSameObject(env_->GetObjectArrayElement(array, 0), java_lang_Class)); 1653 1654 // ArrayIndexOutOfBounds for negative index. 1655 env_->SetObjectArrayElement(array, -1, java_lang_Class); 1656 ExpectException(aioobe_); 1657 1658 // ArrayIndexOutOfBounds for too-large index. 1659 env_->SetObjectArrayElement(array, 1, java_lang_Class); 1660 ExpectException(aioobe_); 1661 1662 // ArrayStoreException thrown for bad types. 1663 env_->SetObjectArrayElement(array, 0, env_->NewStringUTF("not a jclass!")); 1664 ExpectException(ase_); 1665 1666 // Null as array should fail. 1667 CheckJniAbortCatcher jni_abort_catcher; 1668 bool old_check_jni = vm_->SetCheckJniEnabled(false); 1669 EXPECT_EQ(nullptr, env_->GetObjectArrayElement(nullptr, 0)); 1670 jni_abort_catcher.Check("java_array == null"); 1671 env_->SetObjectArrayElement(nullptr, 0, nullptr); 1672 jni_abort_catcher.Check("java_array == null"); 1673 EXPECT_FALSE(vm_->SetCheckJniEnabled(true)); 1674 EXPECT_EQ(nullptr, env_->GetObjectArrayElement(nullptr, 0)); 1675 jni_abort_catcher.Check("jarray was NULL"); 1676 env_->SetObjectArrayElement(nullptr, 0, nullptr); 1677 jni_abort_catcher.Check("jarray was NULL"); 1678 EXPECT_TRUE(vm_->SetCheckJniEnabled(old_check_jni)); 1679} 1680 1681#define EXPECT_STATIC_PRIMITIVE_FIELD(expect_eq, type, field_name, sig, value1, value2) \ 1682 do { \ 1683 jfieldID fid = env_->GetStaticFieldID(c, field_name, sig); \ 1684 EXPECT_NE(fid, nullptr); \ 1685 env_->SetStatic ## type ## Field(c, fid, value1); \ 1686 expect_eq(value1, env_->GetStatic ## type ## Field(c, fid)); \ 1687 env_->SetStatic ## type ## Field(c, fid, value2); \ 1688 expect_eq(value2, env_->GetStatic ## type ## Field(c, fid)); \ 1689 \ 1690 bool old_check_jni = vm_->SetCheckJniEnabled(false); \ 1691 { \ 1692 CheckJniAbortCatcher jni_abort_catcher; \ 1693 env_->GetStatic ## type ## Field(nullptr, fid); \ 1694 env_->SetStatic ## type ## Field(nullptr, fid, value1); \ 1695 } \ 1696 CheckJniAbortCatcher jni_abort_catcher; \ 1697 env_->GetStatic ## type ## Field(c, nullptr); \ 1698 jni_abort_catcher.Check("fid == null"); \ 1699 env_->SetStatic ## type ## Field(c, nullptr, value1); \ 1700 jni_abort_catcher.Check("fid == null"); \ 1701 \ 1702 EXPECT_FALSE(vm_->SetCheckJniEnabled(true)); \ 1703 env_->GetStatic ## type ## Field(nullptr, fid); \ 1704 jni_abort_catcher.Check("received NULL jclass"); \ 1705 env_->SetStatic ## type ## Field(nullptr, fid, value1); \ 1706 jni_abort_catcher.Check("received NULL jclass"); \ 1707 env_->GetStatic ## type ## Field(c, nullptr); \ 1708 jni_abort_catcher.Check("jfieldID was NULL"); \ 1709 env_->SetStatic ## type ## Field(c, nullptr, value1); \ 1710 jni_abort_catcher.Check("jfieldID was NULL"); \ 1711 EXPECT_TRUE(vm_->SetCheckJniEnabled(old_check_jni)); \ 1712 } while (false) 1713 1714#define EXPECT_PRIMITIVE_FIELD(expect_eq, instance, type, field_name, sig, value1, value2) \ 1715 do { \ 1716 jfieldID fid = env_->GetFieldID(c, field_name, sig); \ 1717 EXPECT_NE(fid, nullptr); \ 1718 env_->Set ## type ## Field(instance, fid, value1); \ 1719 expect_eq(value1, env_->Get ## type ## Field(instance, fid)); \ 1720 env_->Set ## type ## Field(instance, fid, value2); \ 1721 expect_eq(value2, env_->Get ## type ## Field(instance, fid)); \ 1722 \ 1723 bool old_check_jni = vm_->SetCheckJniEnabled(false); \ 1724 CheckJniAbortCatcher jni_abort_catcher; \ 1725 env_->Get ## type ## Field(nullptr, fid); \ 1726 jni_abort_catcher.Check("obj == null"); \ 1727 env_->Set ## type ## Field(nullptr, fid, value1); \ 1728 jni_abort_catcher.Check("obj == null"); \ 1729 env_->Get ## type ## Field(instance, nullptr); \ 1730 jni_abort_catcher.Check("fid == null"); \ 1731 env_->Set ## type ## Field(instance, nullptr, value1); \ 1732 jni_abort_catcher.Check("fid == null"); \ 1733 EXPECT_FALSE(vm_->SetCheckJniEnabled(true)); \ 1734 env_->Get ## type ## Field(nullptr, fid); \ 1735 jni_abort_catcher.Check("field operation on NULL object:"); \ 1736 env_->Set ## type ## Field(nullptr, fid, value1); \ 1737 jni_abort_catcher.Check("field operation on NULL object:"); \ 1738 env_->Get ## type ## Field(instance, nullptr); \ 1739 jni_abort_catcher.Check("jfieldID was NULL"); \ 1740 env_->Set ## type ## Field(instance, nullptr, value1); \ 1741 jni_abort_catcher.Check("jfieldID was NULL"); \ 1742 EXPECT_TRUE(vm_->SetCheckJniEnabled(old_check_jni)); \ 1743 } while (false) 1744 1745 1746TEST_F(JniInternalTest, GetPrimitiveField_SetPrimitiveField) { 1747 Thread::Current()->TransitionFromSuspendedToRunnable(); 1748 LoadDex("AllFields"); 1749 bool started = runtime_->Start(); 1750 ASSERT_TRUE(started); 1751 1752 jclass c = env_->FindClass("AllFields"); 1753 ASSERT_NE(c, nullptr); 1754 jobject o = env_->AllocObject(c); 1755 ASSERT_NE(o, nullptr); 1756 1757 EXPECT_STATIC_PRIMITIVE_FIELD(EXPECT_EQ, Boolean, "sZ", "Z", JNI_TRUE, JNI_FALSE); 1758 EXPECT_STATIC_PRIMITIVE_FIELD(EXPECT_EQ, Byte, "sB", "B", 1, 2); 1759 EXPECT_STATIC_PRIMITIVE_FIELD(EXPECT_EQ, Char, "sC", "C", 'a', 'b'); 1760 EXPECT_STATIC_PRIMITIVE_FIELD(EXPECT_DOUBLE_EQ, Double, "sD", "D", 1.0, 2.0); 1761 EXPECT_STATIC_PRIMITIVE_FIELD(EXPECT_FLOAT_EQ, Float, "sF", "F", 1.0, 2.0); 1762 EXPECT_STATIC_PRIMITIVE_FIELD(EXPECT_EQ, Int, "sI", "I", 1, 2); 1763 EXPECT_STATIC_PRIMITIVE_FIELD(EXPECT_EQ, Long, "sJ", "J", 1, 2); 1764 EXPECT_STATIC_PRIMITIVE_FIELD(EXPECT_EQ, Short, "sS", "S", 1, 2); 1765 1766 EXPECT_PRIMITIVE_FIELD(EXPECT_EQ, o, Boolean, "iZ", "Z", JNI_TRUE, JNI_FALSE); 1767 EXPECT_PRIMITIVE_FIELD(EXPECT_EQ, o, Byte, "iB", "B", 1, 2); 1768 EXPECT_PRIMITIVE_FIELD(EXPECT_EQ, o, Char, "iC", "C", 'a', 'b'); 1769 EXPECT_PRIMITIVE_FIELD(EXPECT_DOUBLE_EQ, o, Double, "iD", "D", 1.0, 2.0); 1770 EXPECT_PRIMITIVE_FIELD(EXPECT_FLOAT_EQ, o, Float, "iF", "F", 1.0, 2.0); 1771 EXPECT_PRIMITIVE_FIELD(EXPECT_EQ, o, Int, "iI", "I", 1, 2); 1772 EXPECT_PRIMITIVE_FIELD(EXPECT_EQ, o, Long, "iJ", "J", 1, 2); 1773 EXPECT_PRIMITIVE_FIELD(EXPECT_EQ, o, Short, "iS", "S", 1, 2); 1774} 1775 1776TEST_F(JniInternalTest, GetObjectField_SetObjectField) { 1777 Thread::Current()->TransitionFromSuspendedToRunnable(); 1778 LoadDex("AllFields"); 1779 runtime_->Start(); 1780 1781 jclass c = env_->FindClass("AllFields"); 1782 ASSERT_NE(c, nullptr); 1783 jobject o = env_->AllocObject(c); 1784 ASSERT_NE(o, nullptr); 1785 1786 jstring s1 = env_->NewStringUTF("hello"); 1787 ASSERT_NE(s1, nullptr); 1788 jstring s2 = env_->NewStringUTF("world"); 1789 ASSERT_NE(s2, nullptr); 1790 1791 jfieldID s_fid = env_->GetStaticFieldID(c, "sObject", "Ljava/lang/Object;"); 1792 ASSERT_NE(s_fid, nullptr); 1793 jfieldID i_fid = env_->GetFieldID(c, "iObject", "Ljava/lang/Object;"); 1794 ASSERT_NE(i_fid, nullptr); 1795 1796 env_->SetStaticObjectField(c, s_fid, s1); 1797 ASSERT_TRUE(env_->IsSameObject(s1, env_->GetStaticObjectField(c, s_fid))); 1798 env_->SetStaticObjectField(c, s_fid, s2); 1799 ASSERT_TRUE(env_->IsSameObject(s2, env_->GetStaticObjectField(c, s_fid))); 1800 1801 env_->SetObjectField(o, i_fid, s1); 1802 ASSERT_TRUE(env_->IsSameObject(s1, env_->GetObjectField(o, i_fid))); 1803 env_->SetObjectField(o, i_fid, s2); 1804 ASSERT_TRUE(env_->IsSameObject(s2, env_->GetObjectField(o, i_fid))); 1805} 1806 1807TEST_F(JniInternalTest, NewLocalRef_nullptr) { 1808 EXPECT_EQ(env_->NewLocalRef(nullptr), nullptr); 1809} 1810 1811TEST_F(JniInternalTest, NewLocalRef) { 1812 jstring s = env_->NewStringUTF(""); 1813 ASSERT_NE(s, nullptr); 1814 jobject o = env_->NewLocalRef(s); 1815 EXPECT_NE(o, nullptr); 1816 EXPECT_NE(o, s); 1817 1818 EXPECT_EQ(JNILocalRefType, env_->GetObjectRefType(o)); 1819} 1820 1821TEST_F(JniInternalTest, DeleteLocalRef_nullptr) { 1822 env_->DeleteLocalRef(nullptr); 1823} 1824 1825TEST_F(JniInternalTest, DeleteLocalRef) { 1826 // This tests leads to warnings and errors in the log. 1827 ScopedLogSeverity sls(LogSeverity::FATAL); 1828 1829 jstring s = env_->NewStringUTF(""); 1830 ASSERT_NE(s, nullptr); 1831 env_->DeleteLocalRef(s); 1832 1833 // Currently, deleting an already-deleted reference is just a CheckJNI warning. 1834 { 1835 bool old_check_jni = vm_->SetCheckJniEnabled(false); 1836 { 1837 CheckJniAbortCatcher check_jni_abort_catcher; 1838 env_->DeleteLocalRef(s); 1839 } 1840 CheckJniAbortCatcher check_jni_abort_catcher; 1841 EXPECT_FALSE(vm_->SetCheckJniEnabled(true)); 1842 env_->DeleteLocalRef(s); 1843 std::string expected(StringPrintf("use of deleted local reference %p", s)); 1844 check_jni_abort_catcher.Check(expected.c_str()); 1845 EXPECT_TRUE(vm_->SetCheckJniEnabled(old_check_jni)); 1846 } 1847 1848 s = env_->NewStringUTF(""); 1849 ASSERT_NE(s, nullptr); 1850 jobject o = env_->NewLocalRef(s); 1851 ASSERT_NE(o, nullptr); 1852 1853 env_->DeleteLocalRef(s); 1854 env_->DeleteLocalRef(o); 1855} 1856 1857TEST_F(JniInternalTest, PushLocalFrame_10395422) { 1858 // The JNI specification is ambiguous about whether the given capacity is to be interpreted as a 1859 // maximum or as a minimum, but it seems like it's supposed to be a minimum, and that's how 1860 // Android historically treated it, and it's how the RI treats it. It's also the more useful 1861 // interpretation! 1862 ASSERT_EQ(JNI_OK, env_->PushLocalFrame(0)); 1863 env_->PopLocalFrame(nullptr); 1864 1865 // The following two tests will print errors to the log. 1866 ScopedLogSeverity sls(LogSeverity::FATAL); 1867 1868 // Negative capacities are not allowed. 1869 ASSERT_EQ(JNI_ERR, env_->PushLocalFrame(-1)); 1870 1871 // And it's okay to have an upper limit. Ours is currently 512. 1872 ASSERT_EQ(JNI_ERR, env_->PushLocalFrame(8192)); 1873} 1874 1875TEST_F(JniInternalTest, PushLocalFrame_PopLocalFrame) { 1876 // This tests leads to errors in the log. 1877 ScopedLogSeverity sls(LogSeverity::FATAL); 1878 1879 jobject original = env_->NewStringUTF(""); 1880 ASSERT_NE(original, nullptr); 1881 1882 jobject outer; 1883 jobject inner1, inner2; 1884 ScopedObjectAccess soa(env_); 1885 { 1886 ASSERT_EQ(JNI_OK, env_->PushLocalFrame(4)); 1887 outer = env_->NewLocalRef(original); 1888 1889 { 1890 ASSERT_EQ(JNI_OK, env_->PushLocalFrame(4)); 1891 inner1 = env_->NewLocalRef(outer); 1892 inner2 = env_->NewStringUTF("survivor"); 1893 EXPECT_NE(env_->PopLocalFrame(inner2), nullptr); 1894 } 1895 1896 EXPECT_EQ(JNILocalRefType, env_->GetObjectRefType(original)); 1897 EXPECT_EQ(JNILocalRefType, env_->GetObjectRefType(outer)); 1898 { 1899 CheckJniAbortCatcher check_jni_abort_catcher; 1900 EXPECT_EQ(JNIInvalidRefType, env_->GetObjectRefType(inner1)); 1901 check_jni_abort_catcher.Check("use of deleted local reference"); 1902 } 1903 1904 // Our local reference for the survivor is invalid because the survivor 1905 // gets a new local reference... 1906 { 1907 CheckJniAbortCatcher check_jni_abort_catcher; 1908 EXPECT_EQ(JNIInvalidRefType, env_->GetObjectRefType(inner2)); 1909 check_jni_abort_catcher.Check("use of deleted local reference"); 1910 } 1911 1912 EXPECT_EQ(env_->PopLocalFrame(nullptr), nullptr); 1913 } 1914 EXPECT_EQ(JNILocalRefType, env_->GetObjectRefType(original)); 1915 CheckJniAbortCatcher check_jni_abort_catcher; 1916 EXPECT_EQ(JNIInvalidRefType, env_->GetObjectRefType(outer)); 1917 check_jni_abort_catcher.Check("use of deleted local reference"); 1918 EXPECT_EQ(JNIInvalidRefType, env_->GetObjectRefType(inner1)); 1919 check_jni_abort_catcher.Check("use of deleted local reference"); 1920 EXPECT_EQ(JNIInvalidRefType, env_->GetObjectRefType(inner2)); 1921 check_jni_abort_catcher.Check("use of deleted local reference"); 1922} 1923 1924TEST_F(JniInternalTest, NewGlobalRef_nullptr) { 1925 EXPECT_EQ(env_->NewGlobalRef(nullptr), nullptr); 1926} 1927 1928TEST_F(JniInternalTest, NewGlobalRef) { 1929 jstring s = env_->NewStringUTF(""); 1930 ASSERT_NE(s, nullptr); 1931 jobject o = env_->NewGlobalRef(s); 1932 EXPECT_NE(o, nullptr); 1933 EXPECT_NE(o, s); 1934 1935 EXPECT_EQ(env_->GetObjectRefType(o), JNIGlobalRefType); 1936} 1937 1938TEST_F(JniInternalTest, DeleteGlobalRef_nullptr) { 1939 env_->DeleteGlobalRef(nullptr); 1940} 1941 1942TEST_F(JniInternalTest, DeleteGlobalRef) { 1943 // This tests leads to warnings and errors in the log. 1944 ScopedLogSeverity sls(LogSeverity::FATAL); 1945 1946 jstring s = env_->NewStringUTF(""); 1947 ASSERT_NE(s, nullptr); 1948 1949 jobject o = env_->NewGlobalRef(s); 1950 ASSERT_NE(o, nullptr); 1951 env_->DeleteGlobalRef(o); 1952 1953 // Currently, deleting an already-deleted reference is just a CheckJNI warning. 1954 { 1955 bool old_check_jni = vm_->SetCheckJniEnabled(false); 1956 { 1957 CheckJniAbortCatcher check_jni_abort_catcher; 1958 env_->DeleteGlobalRef(o); 1959 } 1960 CheckJniAbortCatcher check_jni_abort_catcher; 1961 EXPECT_FALSE(vm_->SetCheckJniEnabled(true)); 1962 env_->DeleteGlobalRef(o); 1963 std::string expected(StringPrintf("use of deleted global reference %p", o)); 1964 check_jni_abort_catcher.Check(expected.c_str()); 1965 EXPECT_TRUE(vm_->SetCheckJniEnabled(old_check_jni)); 1966 } 1967 1968 jobject o1 = env_->NewGlobalRef(s); 1969 ASSERT_NE(o1, nullptr); 1970 jobject o2 = env_->NewGlobalRef(s); 1971 ASSERT_NE(o2, nullptr); 1972 1973 env_->DeleteGlobalRef(o1); 1974 env_->DeleteGlobalRef(o2); 1975} 1976 1977TEST_F(JniInternalTest, NewWeakGlobalRef_nullptr) { 1978 EXPECT_EQ(env_->NewWeakGlobalRef(nullptr), nullptr); 1979} 1980 1981TEST_F(JniInternalTest, NewWeakGlobalRef) { 1982 jstring s = env_->NewStringUTF(""); 1983 ASSERT_NE(s, nullptr); 1984 jobject o = env_->NewWeakGlobalRef(s); 1985 EXPECT_NE(o, nullptr); 1986 EXPECT_NE(o, s); 1987 1988 EXPECT_EQ(env_->GetObjectRefType(o), JNIWeakGlobalRefType); 1989} 1990 1991TEST_F(JniInternalTest, DeleteWeakGlobalRef_nullptr) { 1992 env_->DeleteWeakGlobalRef(nullptr); 1993} 1994 1995TEST_F(JniInternalTest, DeleteWeakGlobalRef) { 1996 // This tests leads to warnings and errors in the log. 1997 ScopedLogSeverity sls(LogSeverity::FATAL); 1998 1999 jstring s = env_->NewStringUTF(""); 2000 ASSERT_NE(s, nullptr); 2001 2002 jobject o = env_->NewWeakGlobalRef(s); 2003 ASSERT_NE(o, nullptr); 2004 env_->DeleteWeakGlobalRef(o); 2005 2006 // Currently, deleting an already-deleted reference is just a CheckJNI warning. 2007 { 2008 bool old_check_jni = vm_->SetCheckJniEnabled(false); 2009 { 2010 CheckJniAbortCatcher check_jni_abort_catcher; 2011 env_->DeleteWeakGlobalRef(o); 2012 } 2013 CheckJniAbortCatcher check_jni_abort_catcher; 2014 EXPECT_FALSE(vm_->SetCheckJniEnabled(true)); 2015 env_->DeleteWeakGlobalRef(o); 2016 std::string expected(StringPrintf("use of deleted weak global reference %p", o)); 2017 check_jni_abort_catcher.Check(expected.c_str()); 2018 EXPECT_TRUE(vm_->SetCheckJniEnabled(old_check_jni)); 2019 } 2020 2021 jobject o1 = env_->NewWeakGlobalRef(s); 2022 ASSERT_NE(o1, nullptr); 2023 jobject o2 = env_->NewWeakGlobalRef(s); 2024 ASSERT_NE(o2, nullptr); 2025 2026 env_->DeleteWeakGlobalRef(o1); 2027 env_->DeleteWeakGlobalRef(o2); 2028} 2029 2030TEST_F(JniInternalTest, ExceptionDescribe) { 2031 // This checks how ExceptionDescribe handles call without exception. 2032 env_->ExceptionClear(); 2033 env_->ExceptionDescribe(); 2034} 2035 2036TEST_F(JniInternalTest, Throw) { 2037 jclass exception_class = env_->FindClass("java/lang/RuntimeException"); 2038 ASSERT_TRUE(exception_class != nullptr); 2039 jthrowable exception = reinterpret_cast<jthrowable>(env_->AllocObject(exception_class)); 2040 ASSERT_TRUE(exception != nullptr); 2041 2042 EXPECT_EQ(JNI_OK, env_->Throw(exception)); 2043 EXPECT_TRUE(env_->ExceptionCheck()); 2044 jthrowable thrown_exception = env_->ExceptionOccurred(); 2045 env_->ExceptionClear(); 2046 EXPECT_TRUE(env_->IsSameObject(exception, thrown_exception)); 2047 2048 // Bad argument. 2049 bool old_check_jni = vm_->SetCheckJniEnabled(false); 2050 EXPECT_EQ(JNI_ERR, env_->Throw(nullptr)); 2051 EXPECT_FALSE(vm_->SetCheckJniEnabled(true)); 2052 CheckJniAbortCatcher check_jni_abort_catcher; 2053 EXPECT_EQ(JNI_ERR, env_->Throw(nullptr)); 2054 check_jni_abort_catcher.Check("Throw received NULL jthrowable"); 2055 EXPECT_TRUE(vm_->SetCheckJniEnabled(old_check_jni)); 2056} 2057 2058TEST_F(JniInternalTest, ThrowNew) { 2059 jclass exception_class = env_->FindClass("java/lang/RuntimeException"); 2060 ASSERT_TRUE(exception_class != nullptr); 2061 2062 jthrowable thrown_exception; 2063 2064 EXPECT_EQ(JNI_OK, env_->ThrowNew(exception_class, "hello world")); 2065 EXPECT_TRUE(env_->ExceptionCheck()); 2066 thrown_exception = env_->ExceptionOccurred(); 2067 env_->ExceptionClear(); 2068 EXPECT_TRUE(env_->IsInstanceOf(thrown_exception, exception_class)); 2069 2070 EXPECT_EQ(JNI_OK, env_->ThrowNew(exception_class, nullptr)); 2071 EXPECT_TRUE(env_->ExceptionCheck()); 2072 thrown_exception = env_->ExceptionOccurred(); 2073 env_->ExceptionClear(); 2074 EXPECT_TRUE(env_->IsInstanceOf(thrown_exception, exception_class)); 2075 2076 // Bad argument. 2077 bool old_check_jni = vm_->SetCheckJniEnabled(false); 2078 CheckJniAbortCatcher check_jni_abort_catcher; 2079 EXPECT_EQ(JNI_ERR, env_->ThrowNew(nullptr, nullptr)); 2080 check_jni_abort_catcher.Check("c == null"); 2081 EXPECT_FALSE(vm_->SetCheckJniEnabled(true)); 2082 EXPECT_EQ(JNI_ERR, env_->ThrowNew(nullptr, nullptr)); 2083 check_jni_abort_catcher.Check("ThrowNew received NULL jclass"); 2084 EXPECT_TRUE(vm_->SetCheckJniEnabled(old_check_jni)); 2085} 2086 2087TEST_F(JniInternalTest, NewDirectBuffer_GetDirectBufferAddress_GetDirectBufferCapacity) { 2088 // Start runtime. 2089 Thread* self = Thread::Current(); 2090 self->TransitionFromSuspendedToRunnable(); 2091 MakeExecutable(nullptr, "java.lang.Class"); 2092 MakeExecutable(nullptr, "java.lang.Object"); 2093 MakeExecutable(nullptr, "java.nio.DirectByteBuffer"); 2094 MakeExecutable(nullptr, "java.nio.Bits"); 2095 MakeExecutable(nullptr, "java.nio.MappedByteBuffer"); 2096 MakeExecutable(nullptr, "java.nio.ByteBuffer"); 2097 MakeExecutable(nullptr, "java.nio.Buffer"); 2098 // TODO: we only load a dex file here as starting the runtime relies upon it. 2099 const char* class_name = "StaticLeafMethods"; 2100 LoadDex(class_name); 2101 bool started = runtime_->Start(); 2102 ASSERT_TRUE(started); 2103 2104 jclass buffer_class = env_->FindClass("java/nio/Buffer"); 2105 ASSERT_NE(buffer_class, nullptr); 2106 2107 char bytes[1024]; 2108 jobject buffer = env_->NewDirectByteBuffer(bytes, sizeof(bytes)); 2109 ASSERT_NE(buffer, nullptr); 2110 ASSERT_TRUE(env_->IsInstanceOf(buffer, buffer_class)); 2111 ASSERT_EQ(env_->GetDirectBufferAddress(buffer), bytes); 2112 ASSERT_EQ(env_->GetDirectBufferCapacity(buffer), static_cast<jlong>(sizeof(bytes))); 2113 2114 { 2115 CheckJniAbortCatcher check_jni_abort_catcher; 2116 env_->NewDirectByteBuffer(bytes, static_cast<jlong>(INT_MAX) + 1); 2117 check_jni_abort_catcher.Check("in call to NewDirectByteBuffer"); 2118 } 2119} 2120 2121TEST_F(JniInternalTest, MonitorEnterExit) { 2122 // This will print some error messages. Suppress. 2123 ScopedLogSeverity sls(LogSeverity::FATAL); 2124 2125 // Create an object to torture. 2126 jclass object_class = env_->FindClass("java/lang/Object"); 2127 ASSERT_NE(object_class, nullptr); 2128 jobject object = env_->AllocObject(object_class); 2129 ASSERT_NE(object, nullptr); 2130 2131 // Expected class of exceptions 2132 jclass imse_class = env_->FindClass("java/lang/IllegalMonitorStateException"); 2133 ASSERT_NE(imse_class, nullptr); 2134 2135 jthrowable thrown_exception; 2136 2137 // Unlock of unowned monitor 2138 env_->MonitorExit(object); 2139 EXPECT_TRUE(env_->ExceptionCheck()); 2140 thrown_exception = env_->ExceptionOccurred(); 2141 env_->ExceptionClear(); 2142 EXPECT_TRUE(env_->IsInstanceOf(thrown_exception, imse_class)); 2143 2144 // Lock of unowned monitor 2145 env_->MonitorEnter(object); 2146 EXPECT_FALSE(env_->ExceptionCheck()); 2147 // Regular unlock 2148 env_->MonitorExit(object); 2149 EXPECT_FALSE(env_->ExceptionCheck()); 2150 2151 // Recursively lock a lot 2152 size_t max_recursive_lock = 1024; 2153 for (size_t i = 0; i < max_recursive_lock; i++) { 2154 env_->MonitorEnter(object); 2155 EXPECT_FALSE(env_->ExceptionCheck()); 2156 } 2157 // Recursively unlock a lot 2158 for (size_t i = 0; i < max_recursive_lock; i++) { 2159 env_->MonitorExit(object); 2160 EXPECT_FALSE(env_->ExceptionCheck()); 2161 } 2162 2163 // Unlock of unowned monitor 2164 env_->MonitorExit(object); 2165 EXPECT_TRUE(env_->ExceptionCheck()); 2166 thrown_exception = env_->ExceptionOccurred(); 2167 env_->ExceptionClear(); 2168 EXPECT_TRUE(env_->IsInstanceOf(thrown_exception, imse_class)); 2169 2170 // It's an error to call MonitorEnter or MonitorExit on null. 2171 { 2172 CheckJniAbortCatcher check_jni_abort_catcher; 2173 env_->MonitorEnter(nullptr); 2174 check_jni_abort_catcher.Check("in call to MonitorEnter"); 2175 env_->MonitorExit(nullptr); 2176 check_jni_abort_catcher.Check("in call to MonitorExit"); 2177 } 2178} 2179 2180void Java_MyClassNatives_foo_exit(JNIEnv* env, jobject thisObj) { 2181 // Release the monitor on self. This should trigger an abort. 2182 env->MonitorExit(thisObj); 2183} 2184 2185TEST_F(JniInternalTest, MonitorExitLockedInDifferentCall) { 2186 SetUpForTest(false, "foo", "()V", reinterpret_cast<void*>(&Java_MyClassNatives_foo_exit)); 2187 ASSERT_NE(jobj_, nullptr); 2188 2189 env_->MonitorEnter(jobj_); 2190 EXPECT_FALSE(env_->ExceptionCheck()); 2191 2192 CheckJniAbortCatcher check_jni_abort_catcher; 2193 env_->CallNonvirtualVoidMethod(jobj_, jklass_, jmethod_); 2194 check_jni_abort_catcher.Check("Unlocking monitor that wasn't locked here"); 2195} 2196 2197void Java_MyClassNatives_foo_enter_no_exit(JNIEnv* env, jobject thisObj) { 2198 // Acquire but don't release the monitor on self. This should trigger an abort on return. 2199 env->MonitorEnter(thisObj); 2200} 2201 2202TEST_F(JniInternalTest, MonitorExitNotAllUnlocked) { 2203 SetUpForTest(false, 2204 "foo", 2205 "()V", 2206 reinterpret_cast<void*>(&Java_MyClassNatives_foo_enter_no_exit)); 2207 ASSERT_NE(jobj_, nullptr); 2208 2209 CheckJniAbortCatcher check_jni_abort_catcher; 2210 env_->CallNonvirtualVoidMethod(jobj_, jklass_, jmethod_); 2211 check_jni_abort_catcher.Check("Still holding a locked object on JNI end"); 2212} 2213 2214static bool IsLocked(JNIEnv* env, jobject jobj) { 2215 ScopedObjectAccess soa(env); 2216 LockWord lock_word = soa.Decode<mirror::Object*>(jobj)->GetLockWord(true); 2217 switch (lock_word.GetState()) { 2218 case LockWord::kHashCode: 2219 case LockWord::kUnlocked: 2220 return false; 2221 case LockWord::kThinLocked: 2222 return true; 2223 case LockWord::kFatLocked: 2224 return lock_word.FatLockMonitor()->IsLocked(); 2225 default: { 2226 LOG(FATAL) << "Invalid monitor state " << lock_word.GetState(); 2227 UNREACHABLE(); 2228 } 2229 } 2230} 2231 2232TEST_F(JniInternalTest, DetachThreadUnlockJNIMonitors) { 2233 // We need to lock an object, detach, reattach, and check the locks. 2234 // 2235 // As re-attaching will create a different thread, we need to use a global 2236 // ref to keep the object around. 2237 2238 // Create an object to torture. 2239 jobject global_ref; 2240 { 2241 jclass object_class = env_->FindClass("java/lang/Object"); 2242 ASSERT_NE(object_class, nullptr); 2243 jobject object = env_->AllocObject(object_class); 2244 ASSERT_NE(object, nullptr); 2245 global_ref = env_->NewGlobalRef(object); 2246 } 2247 2248 // Lock it. 2249 env_->MonitorEnter(global_ref); 2250 ASSERT_TRUE(IsLocked(env_, global_ref)); 2251 2252 // Detach and re-attach. 2253 jint detach_result = vm_->DetachCurrentThread(); 2254 ASSERT_EQ(detach_result, JNI_OK); 2255 jint attach_result = vm_->AttachCurrentThread(&env_, nullptr); 2256 ASSERT_EQ(attach_result, JNI_OK); 2257 2258 // Look at the global ref, check whether it's still locked. 2259 ASSERT_FALSE(IsLocked(env_, global_ref)); 2260 2261 // Delete the global ref. 2262 env_->DeleteGlobalRef(global_ref); 2263} 2264 2265// Test the offset computation of IndirectReferenceTable offsets. b/26071368. 2266TEST_F(JniInternalTest, IndirectReferenceTableOffsets) { 2267 // The segment_state_ field is private, and we want to avoid friend declaration. So we'll check 2268 // by modifying memory. 2269 // The parameters don't really matter here. 2270 IndirectReferenceTable irt(5, 5, IndirectRefKind::kGlobal, true); 2271 uint32_t old_state = irt.GetSegmentState(); 2272 2273 // Write some new state directly. We invert parts of old_state to ensure a new value. 2274 uint32_t new_state = old_state ^ 0x07705005; 2275 ASSERT_NE(old_state, new_state); 2276 2277 uint8_t* base = reinterpret_cast<uint8_t*>(&irt); 2278 int32_t segment_state_offset = 2279 IndirectReferenceTable::SegmentStateOffset(sizeof(void*)).Int32Value(); 2280 *reinterpret_cast<uint32_t*>(base + segment_state_offset) = new_state; 2281 2282 // Read and compare. 2283 EXPECT_EQ(new_state, irt.GetSegmentState()); 2284} 2285 2286// Test the offset computation of JNIEnvExt offsets. b/26071368. 2287TEST_F(JniInternalTest, JNIEnvExtOffsets) { 2288 EXPECT_EQ(OFFSETOF_MEMBER(JNIEnvExt, local_ref_cookie), 2289 JNIEnvExt::LocalRefCookieOffset(sizeof(void*)).Int32Value()); 2290 2291 EXPECT_EQ(OFFSETOF_MEMBER(JNIEnvExt, self), JNIEnvExt::SelfOffset(sizeof(void*)).Int32Value()); 2292 2293 // segment_state_ is private in the IndirectReferenceTable. So this test isn't as good as we'd 2294 // hope it to be. 2295 int32_t segment_state_now = 2296 OFFSETOF_MEMBER(JNIEnvExt, locals) + 2297 IndirectReferenceTable::SegmentStateOffset(sizeof(void*)).Int32Value(); 2298 int32_t segment_state_computed = JNIEnvExt::SegmentStateOffset(sizeof(void*)).Int32Value(); 2299 EXPECT_EQ(segment_state_now, segment_state_computed); 2300} 2301 2302} // namespace art 2303