jni_compiler_test.cc revision 38bd1e1b8aa39bdc6e67c5dc205cc8d294d985c5
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 <memory> 18 19#include <math.h> 20 21#include "class_linker.h" 22#include "common_compiler_test.h" 23#include "dex_file.h" 24#include "gtest/gtest.h" 25#include "indirect_reference_table.h" 26#include "jni_internal.h" 27#include "mem_map.h" 28#include "mirror/art_method-inl.h" 29#include "mirror/class-inl.h" 30#include "mirror/class_loader.h" 31#include "mirror/object_array-inl.h" 32#include "mirror/object-inl.h" 33#include "mirror/stack_trace_element.h" 34#include "runtime.h" 35#include "ScopedLocalRef.h" 36#include "scoped_thread_state_change.h" 37#include "thread.h" 38 39extern "C" JNIEXPORT jint JNICALL Java_MyClassNatives_bar(JNIEnv*, jobject, jint count) { 40 return count + 1; 41} 42 43extern "C" JNIEXPORT jint JNICALL Java_MyClassNatives_sbar(JNIEnv*, jclass, jint count) { 44 return count + 1; 45} 46 47namespace art { 48 49class JniCompilerTest : public CommonCompilerTest { 50 protected: 51 void SetUp() OVERRIDE { 52 CommonCompilerTest::SetUp(); 53 check_generic_jni_ = false; 54 } 55 56 void SetCheckGenericJni(bool generic) { 57 check_generic_jni_ = generic; 58 } 59 60 void CompileForTest(jobject class_loader, bool direct, 61 const char* method_name, const char* method_sig) { 62 ScopedObjectAccess soa(Thread::Current()); 63 StackHandleScope<1> hs(soa.Self()); 64 Handle<mirror::ClassLoader> loader( 65 hs.NewHandle(soa.Decode<mirror::ClassLoader*>(class_loader))); 66 // Compile the native method before starting the runtime 67 mirror::Class* c = class_linker_->FindClass(soa.Self(), "LMyClassNatives;", loader); 68 mirror::ArtMethod* method; 69 if (direct) { 70 method = c->FindDirectMethod(method_name, method_sig); 71 } else { 72 method = c->FindVirtualMethod(method_name, method_sig); 73 } 74 ASSERT_TRUE(method != nullptr) << method_name << " " << method_sig; 75 if (check_generic_jni_) { 76 method->SetEntryPointFromQuickCompiledCode(class_linker_->GetQuickGenericJniTrampoline()); 77 } else { 78 if (method->GetEntryPointFromQuickCompiledCode() == nullptr || 79 method->GetEntryPointFromQuickCompiledCode() == class_linker_->GetQuickGenericJniTrampoline()) { 80 CompileMethod(method); 81 ASSERT_TRUE(method->GetEntryPointFromQuickCompiledCode() != nullptr) 82 << method_name << " " << method_sig; 83 ASSERT_TRUE(method->GetEntryPointFromPortableCompiledCode() != nullptr) 84 << method_name << " " << method_sig; 85 } 86 } 87 } 88 89 void SetUpForTest(bool direct, const char* method_name, const char* method_sig, 90 void* native_fnptr) { 91 // Initialize class loader and compile method when runtime not started. 92 if (!runtime_->IsStarted()) { 93 { 94 ScopedObjectAccess soa(Thread::Current()); 95 class_loader_ = LoadDex("MyClassNatives"); 96 } 97 CompileForTest(class_loader_, direct, method_name, method_sig); 98 // Start runtime. 99 Thread::Current()->TransitionFromSuspendedToRunnable(); 100 bool started = runtime_->Start(); 101 CHECK(started); 102 } 103 // JNI operations after runtime start. 104 env_ = Thread::Current()->GetJniEnv(); 105 jklass_ = env_->FindClass("MyClassNatives"); 106 ASSERT_TRUE(jklass_ != nullptr) << method_name << " " << method_sig; 107 108 if (direct) { 109 jmethod_ = env_->GetStaticMethodID(jklass_, method_name, method_sig); 110 } else { 111 jmethod_ = env_->GetMethodID(jklass_, method_name, method_sig); 112 } 113 ASSERT_TRUE(jmethod_ != nullptr) << method_name << " " << method_sig; 114 115 if (native_fnptr != nullptr) { 116 JNINativeMethod methods[] = { { method_name, method_sig, native_fnptr } }; 117 ASSERT_EQ(JNI_OK, env_->RegisterNatives(jklass_, methods, 1)) 118 << method_name << " " << method_sig; 119 } else { 120 env_->UnregisterNatives(jklass_); 121 } 122 123 jmethodID constructor = env_->GetMethodID(jklass_, "<init>", "()V"); 124 jobj_ = env_->NewObject(jklass_, constructor); 125 ASSERT_TRUE(jobj_ != nullptr) << method_name << " " << method_sig; 126 } 127 128 public: 129 static jclass jklass_; 130 static jobject jobj_; 131 static jobject class_loader_; 132 133 protected: 134 // We have to list the methods here so we can share them between default and generic JNI. 135 void CompileAndRunNoArgMethodImpl(); 136 void CompileAndRunIntMethodThroughStubImpl(); 137 void CompileAndRunStaticIntMethodThroughStubImpl(); 138 void CompileAndRunIntMethodImpl(); 139 void CompileAndRunIntIntMethodImpl(); 140 void CompileAndRunLongLongMethodImpl(); 141 void CompileAndRunDoubleDoubleMethodImpl(); 142 void CompileAndRun_fooJJ_synchronizedImpl(); 143 void CompileAndRunIntObjectObjectMethodImpl(); 144 void CompileAndRunStaticIntIntMethodImpl(); 145 void CompileAndRunStaticDoubleDoubleMethodImpl(); 146 void RunStaticLogDoubleMethodImpl(); 147 void RunStaticLogFloatMethodImpl(); 148 void RunStaticReturnTrueImpl(); 149 void RunStaticReturnFalseImpl(); 150 void RunGenericStaticReturnIntImpl(); 151 void CompileAndRunStaticIntObjectObjectMethodImpl(); 152 void CompileAndRunStaticSynchronizedIntObjectObjectMethodImpl(); 153 void ExceptionHandlingImpl(); 154 void NativeStackTraceElementImpl(); 155 void ReturnGlobalRefImpl(); 156 void LocalReferenceTableClearingTestImpl(); 157 void JavaLangSystemArrayCopyImpl(); 158 void CompareAndSwapIntImpl(); 159 void GetTextImpl(); 160 void GetSinkPropertiesNativeImpl(); 161 void UpcallReturnTypeChecking_InstanceImpl(); 162 void UpcallReturnTypeChecking_StaticImpl(); 163 void UpcallArgumentTypeChecking_InstanceImpl(); 164 void UpcallArgumentTypeChecking_StaticImpl(); 165 void CompileAndRunFloatFloatMethodImpl(); 166 void CheckParameterAlignImpl(); 167 void MaxParamNumberImpl(); 168 void WithoutImplementationImpl(); 169 void StackArgsIntsFirstImpl(); 170 void StackArgsFloatsFirstImpl(); 171 void StackArgsMixedImpl(); 172 173 JNIEnv* env_; 174 jmethodID jmethod_; 175 bool check_generic_jni_; 176}; 177 178jclass JniCompilerTest::jklass_; 179jobject JniCompilerTest::jobj_; 180jobject JniCompilerTest::class_loader_; 181 182#define JNI_TEST(TestName) \ 183 TEST_F(JniCompilerTest, TestName ## Default) { \ 184 TestName ## Impl(); \ 185 } \ 186 \ 187 TEST_F(JniCompilerTest, TestName ## Generic) { \ 188 TEST_DISABLED_FOR_MIPS(); \ 189 SetCheckGenericJni(true); \ 190 TestName ## Impl(); \ 191 } 192 193int gJava_MyClassNatives_foo_calls = 0; 194void Java_MyClassNatives_foo(JNIEnv* env, jobject thisObj) { 195 // 1 = thisObj 196 EXPECT_EQ(kNative, Thread::Current()->GetState()); 197 Locks::mutator_lock_->AssertNotHeld(Thread::Current()); 198 EXPECT_EQ(Thread::Current()->GetJniEnv(), env); 199 EXPECT_TRUE(thisObj != nullptr); 200 EXPECT_TRUE(env->IsInstanceOf(thisObj, JniCompilerTest::jklass_)); 201 gJava_MyClassNatives_foo_calls++; 202 ScopedObjectAccess soa(Thread::Current()); 203 EXPECT_EQ(1U, Thread::Current()->NumStackReferences()); 204} 205 206void JniCompilerTest::CompileAndRunNoArgMethodImpl() { 207 TEST_DISABLED_FOR_PORTABLE(); 208 SetUpForTest(false, "foo", "()V", reinterpret_cast<void*>(&Java_MyClassNatives_foo)); 209 210 EXPECT_EQ(0, gJava_MyClassNatives_foo_calls); 211 env_->CallNonvirtualVoidMethod(jobj_, jklass_, jmethod_); 212 EXPECT_EQ(1, gJava_MyClassNatives_foo_calls); 213 env_->CallNonvirtualVoidMethod(jobj_, jklass_, jmethod_); 214 EXPECT_EQ(2, gJava_MyClassNatives_foo_calls); 215 216 gJava_MyClassNatives_foo_calls = 0; 217} 218 219JNI_TEST(CompileAndRunNoArgMethod) 220 221void JniCompilerTest::CompileAndRunIntMethodThroughStubImpl() { 222 TEST_DISABLED_FOR_PORTABLE(); 223 SetUpForTest(false, "bar", "(I)I", nullptr); 224 // calling through stub will link with &Java_MyClassNatives_bar 225 226 ScopedObjectAccess soa(Thread::Current()); 227 std::string reason; 228 StackHandleScope<1> hs(soa.Self()); 229 Handle<mirror::ClassLoader> class_loader( 230 hs.NewHandle(soa.Decode<mirror::ClassLoader*>(class_loader_))); 231 ASSERT_TRUE( 232 Runtime::Current()->GetJavaVM()->LoadNativeLibrary("", class_loader, &reason)) << reason; 233 234 jint result = env_->CallNonvirtualIntMethod(jobj_, jklass_, jmethod_, 24); 235 EXPECT_EQ(25, result); 236} 237 238JNI_TEST(CompileAndRunIntMethodThroughStub) 239 240void JniCompilerTest::CompileAndRunStaticIntMethodThroughStubImpl() { 241 TEST_DISABLED_FOR_PORTABLE(); 242 SetUpForTest(true, "sbar", "(I)I", nullptr); 243 // calling through stub will link with &Java_MyClassNatives_sbar 244 245 ScopedObjectAccess soa(Thread::Current()); 246 std::string reason; 247 StackHandleScope<1> hs(soa.Self()); 248 Handle<mirror::ClassLoader> class_loader( 249 hs.NewHandle(soa.Decode<mirror::ClassLoader*>(class_loader_))); 250 ASSERT_TRUE( 251 Runtime::Current()->GetJavaVM()->LoadNativeLibrary("", class_loader, &reason)) << reason; 252 253 jint result = env_->CallStaticIntMethod(jklass_, jmethod_, 42); 254 EXPECT_EQ(43, result); 255} 256 257JNI_TEST(CompileAndRunStaticIntMethodThroughStub) 258 259int gJava_MyClassNatives_fooI_calls = 0; 260jint Java_MyClassNatives_fooI(JNIEnv* env, jobject thisObj, jint x) { 261 // 1 = thisObj 262 EXPECT_EQ(kNative, Thread::Current()->GetState()); 263 EXPECT_EQ(Thread::Current()->GetJniEnv(), env); 264 EXPECT_TRUE(thisObj != nullptr); 265 EXPECT_TRUE(env->IsInstanceOf(thisObj, JniCompilerTest::jklass_)); 266 gJava_MyClassNatives_fooI_calls++; 267 ScopedObjectAccess soa(Thread::Current()); 268 EXPECT_EQ(1U, Thread::Current()->NumStackReferences()); 269 return x; 270} 271 272void JniCompilerTest::CompileAndRunIntMethodImpl() { 273 TEST_DISABLED_FOR_PORTABLE(); 274 SetUpForTest(false, "fooI", "(I)I", 275 reinterpret_cast<void*>(&Java_MyClassNatives_fooI)); 276 277 EXPECT_EQ(0, gJava_MyClassNatives_fooI_calls); 278 jint result = env_->CallNonvirtualIntMethod(jobj_, jklass_, jmethod_, 42); 279 EXPECT_EQ(42, result); 280 EXPECT_EQ(1, gJava_MyClassNatives_fooI_calls); 281 result = env_->CallNonvirtualIntMethod(jobj_, jklass_, jmethod_, 0xCAFED00D); 282 EXPECT_EQ(static_cast<jint>(0xCAFED00D), result); 283 EXPECT_EQ(2, gJava_MyClassNatives_fooI_calls); 284 285 gJava_MyClassNatives_fooI_calls = 0; 286} 287 288JNI_TEST(CompileAndRunIntMethod) 289 290int gJava_MyClassNatives_fooII_calls = 0; 291jint Java_MyClassNatives_fooII(JNIEnv* env, jobject thisObj, jint x, jint y) { 292 // 1 = thisObj 293 EXPECT_EQ(kNative, Thread::Current()->GetState()); 294 EXPECT_EQ(Thread::Current()->GetJniEnv(), env); 295 EXPECT_TRUE(thisObj != nullptr); 296 EXPECT_TRUE(env->IsInstanceOf(thisObj, JniCompilerTest::jklass_)); 297 gJava_MyClassNatives_fooII_calls++; 298 ScopedObjectAccess soa(Thread::Current()); 299 EXPECT_EQ(1U, Thread::Current()->NumStackReferences()); 300 return x - y; // non-commutative operator 301} 302 303void JniCompilerTest::CompileAndRunIntIntMethodImpl() { 304 TEST_DISABLED_FOR_PORTABLE(); 305 SetUpForTest(false, "fooII", "(II)I", 306 reinterpret_cast<void*>(&Java_MyClassNatives_fooII)); 307 308 EXPECT_EQ(0, gJava_MyClassNatives_fooII_calls); 309 jint result = env_->CallNonvirtualIntMethod(jobj_, jklass_, jmethod_, 99, 10); 310 EXPECT_EQ(99 - 10, result); 311 EXPECT_EQ(1, gJava_MyClassNatives_fooII_calls); 312 result = env_->CallNonvirtualIntMethod(jobj_, jklass_, jmethod_, 0xCAFEBABE, 313 0xCAFED00D); 314 EXPECT_EQ(static_cast<jint>(0xCAFEBABE - 0xCAFED00D), result); 315 EXPECT_EQ(2, gJava_MyClassNatives_fooII_calls); 316 317 gJava_MyClassNatives_fooII_calls = 0; 318} 319 320JNI_TEST(CompileAndRunIntIntMethod) 321 322int gJava_MyClassNatives_fooJJ_calls = 0; 323jlong Java_MyClassNatives_fooJJ(JNIEnv* env, jobject thisObj, jlong x, jlong y) { 324 // 1 = thisObj 325 EXPECT_EQ(kNative, Thread::Current()->GetState()); 326 EXPECT_EQ(Thread::Current()->GetJniEnv(), env); 327 EXPECT_TRUE(thisObj != nullptr); 328 EXPECT_TRUE(env->IsInstanceOf(thisObj, JniCompilerTest::jklass_)); 329 gJava_MyClassNatives_fooJJ_calls++; 330 ScopedObjectAccess soa(Thread::Current()); 331 EXPECT_EQ(1U, Thread::Current()->NumStackReferences()); 332 return x - y; // non-commutative operator 333} 334 335void JniCompilerTest::CompileAndRunLongLongMethodImpl() { 336 TEST_DISABLED_FOR_PORTABLE(); 337 SetUpForTest(false, "fooJJ", "(JJ)J", 338 reinterpret_cast<void*>(&Java_MyClassNatives_fooJJ)); 339 340 EXPECT_EQ(0, gJava_MyClassNatives_fooJJ_calls); 341 jlong a = INT64_C(0x1234567890ABCDEF); 342 jlong b = INT64_C(0xFEDCBA0987654321); 343 jlong result = env_->CallNonvirtualLongMethod(jobj_, jklass_, jmethod_, a, b); 344 EXPECT_EQ(a - b, result); 345 EXPECT_EQ(1, gJava_MyClassNatives_fooJJ_calls); 346 result = env_->CallNonvirtualLongMethod(jobj_, jklass_, jmethod_, b, a); 347 EXPECT_EQ(b - a, result); 348 EXPECT_EQ(2, gJava_MyClassNatives_fooJJ_calls); 349 350 gJava_MyClassNatives_fooJJ_calls = 0; 351} 352 353JNI_TEST(CompileAndRunLongLongMethod) 354 355int gJava_MyClassNatives_fooDD_calls = 0; 356jdouble Java_MyClassNatives_fooDD(JNIEnv* env, jobject thisObj, jdouble x, jdouble y) { 357 // 1 = thisObj 358 EXPECT_EQ(kNative, Thread::Current()->GetState()); 359 EXPECT_EQ(Thread::Current()->GetJniEnv(), env); 360 EXPECT_TRUE(thisObj != nullptr); 361 EXPECT_TRUE(env->IsInstanceOf(thisObj, JniCompilerTest::jklass_)); 362 gJava_MyClassNatives_fooDD_calls++; 363 ScopedObjectAccess soa(Thread::Current()); 364 EXPECT_EQ(1U, Thread::Current()->NumStackReferences()); 365 return x - y; // non-commutative operator 366} 367 368void JniCompilerTest::CompileAndRunDoubleDoubleMethodImpl() { 369 TEST_DISABLED_FOR_PORTABLE(); 370 SetUpForTest(false, "fooDD", "(DD)D", 371 reinterpret_cast<void*>(&Java_MyClassNatives_fooDD)); 372 373 EXPECT_EQ(0, gJava_MyClassNatives_fooDD_calls); 374 jdouble result = env_->CallNonvirtualDoubleMethod(jobj_, jklass_, jmethod_, 375 99.0, 10.0); 376 EXPECT_EQ(99.0 - 10.0, result); 377 EXPECT_EQ(1, gJava_MyClassNatives_fooDD_calls); 378 jdouble a = 3.14159265358979323846; 379 jdouble b = 0.69314718055994530942; 380 result = env_->CallNonvirtualDoubleMethod(jobj_, jklass_, jmethod_, a, b); 381 EXPECT_EQ(a - b, result); 382 EXPECT_EQ(2, gJava_MyClassNatives_fooDD_calls); 383 384 gJava_MyClassNatives_fooDD_calls = 0; 385} 386 387int gJava_MyClassNatives_fooJJ_synchronized_calls = 0; 388jlong Java_MyClassNatives_fooJJ_synchronized(JNIEnv* env, jobject thisObj, jlong x, jlong y) { 389 // 1 = thisObj 390 EXPECT_EQ(kNative, Thread::Current()->GetState()); 391 EXPECT_EQ(Thread::Current()->GetJniEnv(), env); 392 EXPECT_TRUE(thisObj != nullptr); 393 EXPECT_TRUE(env->IsInstanceOf(thisObj, JniCompilerTest::jklass_)); 394 gJava_MyClassNatives_fooJJ_synchronized_calls++; 395 ScopedObjectAccess soa(Thread::Current()); 396 EXPECT_EQ(1U, Thread::Current()->NumStackReferences()); 397 return x | y; 398} 399 400void JniCompilerTest::CompileAndRun_fooJJ_synchronizedImpl() { 401 TEST_DISABLED_FOR_PORTABLE(); 402 SetUpForTest(false, "fooJJ_synchronized", "(JJ)J", 403 reinterpret_cast<void*>(&Java_MyClassNatives_fooJJ_synchronized)); 404 405 EXPECT_EQ(0, gJava_MyClassNatives_fooJJ_synchronized_calls); 406 jlong a = 0x1000000020000000ULL; 407 jlong b = 0x00ff000000aa0000ULL; 408 jlong result = env_->CallNonvirtualLongMethod(jobj_, jklass_, jmethod_, a, b); 409 EXPECT_EQ(a | b, result); 410 EXPECT_EQ(1, gJava_MyClassNatives_fooJJ_synchronized_calls); 411 412 gJava_MyClassNatives_fooJJ_synchronized_calls = 0; 413} 414 415JNI_TEST(CompileAndRun_fooJJ_synchronized) 416 417int gJava_MyClassNatives_fooIOO_calls = 0; 418jobject Java_MyClassNatives_fooIOO(JNIEnv* env, jobject thisObj, jint x, jobject y, 419 jobject z) { 420 // 3 = this + y + z 421 EXPECT_EQ(kNative, Thread::Current()->GetState()); 422 EXPECT_EQ(Thread::Current()->GetJniEnv(), env); 423 EXPECT_TRUE(thisObj != nullptr); 424 EXPECT_TRUE(env->IsInstanceOf(thisObj, JniCompilerTest::jklass_)); 425 gJava_MyClassNatives_fooIOO_calls++; 426 ScopedObjectAccess soa(Thread::Current()); 427 size_t null_args = (y == nullptr ? 1 : 0) + (z == nullptr ? 1 : 0); 428 EXPECT_TRUE(3U == Thread::Current()->NumStackReferences() || 429 (3U - null_args) == Thread::Current()->NumStackReferences()); 430 switch (x) { 431 case 1: 432 return y; 433 case 2: 434 return z; 435 default: 436 return thisObj; 437 } 438} 439 440void JniCompilerTest::CompileAndRunIntObjectObjectMethodImpl() { 441 TEST_DISABLED_FOR_PORTABLE(); 442 SetUpForTest(false, "fooIOO", 443 "(ILjava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;", 444 reinterpret_cast<void*>(&Java_MyClassNatives_fooIOO)); 445 446 EXPECT_EQ(0, gJava_MyClassNatives_fooIOO_calls); 447 jobject result = env_->CallNonvirtualObjectMethod(jobj_, jklass_, jmethod_, 0, nullptr, nullptr); 448 EXPECT_TRUE(env_->IsSameObject(jobj_, result)); 449 EXPECT_EQ(1, gJava_MyClassNatives_fooIOO_calls); 450 451 result = env_->CallNonvirtualObjectMethod(jobj_, jklass_, jmethod_, 0, nullptr, jklass_); 452 EXPECT_TRUE(env_->IsSameObject(jobj_, result)); 453 EXPECT_EQ(2, gJava_MyClassNatives_fooIOO_calls); 454 result = env_->CallNonvirtualObjectMethod(jobj_, jklass_, jmethod_, 1, nullptr, jklass_); 455 EXPECT_TRUE(env_->IsSameObject(nullptr, result)); 456 EXPECT_EQ(3, gJava_MyClassNatives_fooIOO_calls); 457 result = env_->CallNonvirtualObjectMethod(jobj_, jklass_, jmethod_, 2, nullptr, jklass_); 458 EXPECT_TRUE(env_->IsSameObject(jklass_, result)); 459 EXPECT_EQ(4, gJava_MyClassNatives_fooIOO_calls); 460 461 result = env_->CallNonvirtualObjectMethod(jobj_, jklass_, jmethod_, 0, jklass_, nullptr); 462 EXPECT_TRUE(env_->IsSameObject(jobj_, result)); 463 EXPECT_EQ(5, gJava_MyClassNatives_fooIOO_calls); 464 result = env_->CallNonvirtualObjectMethod(jobj_, jklass_, jmethod_, 1, jklass_, nullptr); 465 EXPECT_TRUE(env_->IsSameObject(jklass_, result)); 466 EXPECT_EQ(6, gJava_MyClassNatives_fooIOO_calls); 467 result = env_->CallNonvirtualObjectMethod(jobj_, jklass_, jmethod_, 2, jklass_, nullptr); 468 EXPECT_TRUE(env_->IsSameObject(nullptr, result)); 469 EXPECT_EQ(7, gJava_MyClassNatives_fooIOO_calls); 470 471 gJava_MyClassNatives_fooIOO_calls = 0; 472} 473 474JNI_TEST(CompileAndRunIntObjectObjectMethod) 475 476int gJava_MyClassNatives_fooSII_calls = 0; 477jint Java_MyClassNatives_fooSII(JNIEnv* env, jclass klass, jint x, jint y) { 478 // 1 = klass 479 EXPECT_EQ(kNative, Thread::Current()->GetState()); 480 EXPECT_EQ(Thread::Current()->GetJniEnv(), env); 481 EXPECT_TRUE(klass != nullptr); 482 EXPECT_TRUE(env->IsInstanceOf(JniCompilerTest::jobj_, klass)); 483 gJava_MyClassNatives_fooSII_calls++; 484 ScopedObjectAccess soa(Thread::Current()); 485 EXPECT_EQ(1U, Thread::Current()->NumStackReferences()); 486 return x + y; 487} 488 489void JniCompilerTest::CompileAndRunStaticIntIntMethodImpl() { 490 TEST_DISABLED_FOR_PORTABLE(); 491 SetUpForTest(true, "fooSII", "(II)I", 492 reinterpret_cast<void*>(&Java_MyClassNatives_fooSII)); 493 494 EXPECT_EQ(0, gJava_MyClassNatives_fooSII_calls); 495 jint result = env_->CallStaticIntMethod(jklass_, jmethod_, 20, 30); 496 EXPECT_EQ(50, result); 497 EXPECT_EQ(1, gJava_MyClassNatives_fooSII_calls); 498 499 gJava_MyClassNatives_fooSII_calls = 0; 500} 501 502JNI_TEST(CompileAndRunStaticIntIntMethod) 503 504int gJava_MyClassNatives_fooSDD_calls = 0; 505jdouble Java_MyClassNatives_fooSDD(JNIEnv* env, jclass klass, jdouble x, jdouble y) { 506 // 1 = klass 507 EXPECT_EQ(kNative, Thread::Current()->GetState()); 508 EXPECT_EQ(Thread::Current()->GetJniEnv(), env); 509 EXPECT_TRUE(klass != nullptr); 510 EXPECT_TRUE(env->IsInstanceOf(JniCompilerTest::jobj_, klass)); 511 gJava_MyClassNatives_fooSDD_calls++; 512 ScopedObjectAccess soa(Thread::Current()); 513 EXPECT_EQ(1U, Thread::Current()->NumStackReferences()); 514 return x - y; // non-commutative operator 515} 516 517void JniCompilerTest::CompileAndRunStaticDoubleDoubleMethodImpl() { 518 TEST_DISABLED_FOR_PORTABLE(); 519 SetUpForTest(true, "fooSDD", "(DD)D", 520 reinterpret_cast<void*>(&Java_MyClassNatives_fooSDD)); 521 522 EXPECT_EQ(0, gJava_MyClassNatives_fooSDD_calls); 523 jdouble result = env_->CallStaticDoubleMethod(jklass_, jmethod_, 99.0, 10.0); 524 EXPECT_EQ(99.0 - 10.0, result); 525 EXPECT_EQ(1, gJava_MyClassNatives_fooSDD_calls); 526 jdouble a = 3.14159265358979323846; 527 jdouble b = 0.69314718055994530942; 528 result = env_->CallStaticDoubleMethod(jklass_, jmethod_, a, b); 529 EXPECT_EQ(a - b, result); 530 EXPECT_EQ(2, gJava_MyClassNatives_fooSDD_calls); 531 532 gJava_MyClassNatives_fooSDD_calls = 0; 533} 534 535JNI_TEST(CompileAndRunStaticDoubleDoubleMethod) 536 537// The x86 generic JNI code had a bug where it assumed a floating 538// point return value would be in xmm0. We use log, to somehow ensure 539// the compiler will use the floating point stack. 540 541jdouble Java_MyClassNatives_logD(JNIEnv* env, jclass klass, jdouble x) { 542 return log(x); 543} 544 545void JniCompilerTest::RunStaticLogDoubleMethodImpl() { 546 TEST_DISABLED_FOR_PORTABLE(); 547 SetUpForTest(true, "logD", "(D)D", reinterpret_cast<void*>(&Java_MyClassNatives_logD)); 548 549 jdouble result = env_->CallStaticDoubleMethod(jklass_, jmethod_, 2.0); 550 EXPECT_EQ(log(2.0), result); 551} 552 553JNI_TEST(RunStaticLogDoubleMethod) 554 555jfloat Java_MyClassNatives_logF(JNIEnv* env, jclass klass, jfloat x) { 556 return logf(x); 557} 558 559void JniCompilerTest::RunStaticLogFloatMethodImpl() { 560 TEST_DISABLED_FOR_PORTABLE(); 561 SetUpForTest(true, "logF", "(F)F", reinterpret_cast<void*>(&Java_MyClassNatives_logF)); 562 563 jfloat result = env_->CallStaticFloatMethod(jklass_, jmethod_, 2.0); 564 EXPECT_EQ(logf(2.0), result); 565} 566 567JNI_TEST(RunStaticLogFloatMethod) 568 569jboolean Java_MyClassNatives_returnTrue(JNIEnv* env, jclass klass) { 570 return JNI_TRUE; 571} 572 573jboolean Java_MyClassNatives_returnFalse(JNIEnv* env, jclass klass) { 574 return JNI_FALSE; 575} 576 577jint Java_MyClassNatives_returnInt(JNIEnv* env, jclass klass) { 578 return 42; 579} 580 581void JniCompilerTest::RunStaticReturnTrueImpl() { 582 TEST_DISABLED_FOR_PORTABLE(); 583 SetUpForTest(true, "returnTrue", "()Z", reinterpret_cast<void*>(&Java_MyClassNatives_returnTrue)); 584 585 jboolean result = env_->CallStaticBooleanMethod(jklass_, jmethod_); 586 EXPECT_TRUE(result); 587} 588 589JNI_TEST(RunStaticReturnTrue) 590 591void JniCompilerTest::RunStaticReturnFalseImpl() { 592 TEST_DISABLED_FOR_PORTABLE(); 593 SetUpForTest(true, "returnFalse", "()Z", 594 reinterpret_cast<void*>(&Java_MyClassNatives_returnFalse)); 595 596 jboolean result = env_->CallStaticBooleanMethod(jklass_, jmethod_); 597 EXPECT_FALSE(result); 598} 599 600JNI_TEST(RunStaticReturnFalse) 601 602void JniCompilerTest::RunGenericStaticReturnIntImpl() { 603 TEST_DISABLED_FOR_PORTABLE(); 604 SetUpForTest(true, "returnInt", "()I", reinterpret_cast<void*>(&Java_MyClassNatives_returnInt)); 605 606 jint result = env_->CallStaticIntMethod(jklass_, jmethod_); 607 EXPECT_EQ(42, result); 608} 609 610JNI_TEST(RunGenericStaticReturnInt) 611 612int gJava_MyClassNatives_fooSIOO_calls = 0; 613jobject Java_MyClassNatives_fooSIOO(JNIEnv* env, jclass klass, jint x, jobject y, 614 jobject z) { 615 // 3 = klass + y + z 616 EXPECT_EQ(kNative, Thread::Current()->GetState()); 617 EXPECT_EQ(Thread::Current()->GetJniEnv(), env); 618 EXPECT_TRUE(klass != nullptr); 619 EXPECT_TRUE(env->IsInstanceOf(JniCompilerTest::jobj_, klass)); 620 gJava_MyClassNatives_fooSIOO_calls++; 621 ScopedObjectAccess soa(Thread::Current()); 622 size_t null_args = (y == nullptr ? 1 : 0) + (z == nullptr ? 1 : 0); 623 EXPECT_TRUE(3U == Thread::Current()->NumStackReferences() || 624 (3U - null_args) == Thread::Current()->NumStackReferences()); 625 switch (x) { 626 case 1: 627 return y; 628 case 2: 629 return z; 630 default: 631 return klass; 632 } 633} 634 635 636void JniCompilerTest::CompileAndRunStaticIntObjectObjectMethodImpl() { 637 TEST_DISABLED_FOR_PORTABLE(); 638 SetUpForTest(true, "fooSIOO", 639 "(ILjava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;", 640 reinterpret_cast<void*>(&Java_MyClassNatives_fooSIOO)); 641 642 EXPECT_EQ(0, gJava_MyClassNatives_fooSIOO_calls); 643 jobject result = env_->CallStaticObjectMethod(jklass_, jmethod_, 0, nullptr, nullptr); 644 EXPECT_TRUE(env_->IsSameObject(jklass_, result)); 645 EXPECT_EQ(1, gJava_MyClassNatives_fooSIOO_calls); 646 647 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 0, nullptr, jobj_); 648 EXPECT_TRUE(env_->IsSameObject(jklass_, result)); 649 EXPECT_EQ(2, gJava_MyClassNatives_fooSIOO_calls); 650 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 1, nullptr, jobj_); 651 EXPECT_TRUE(env_->IsSameObject(nullptr, result)); 652 EXPECT_EQ(3, gJava_MyClassNatives_fooSIOO_calls); 653 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 2, nullptr, jobj_); 654 EXPECT_TRUE(env_->IsSameObject(jobj_, result)); 655 EXPECT_EQ(4, gJava_MyClassNatives_fooSIOO_calls); 656 657 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 0, jobj_, nullptr); 658 EXPECT_TRUE(env_->IsSameObject(jklass_, result)); 659 EXPECT_EQ(5, gJava_MyClassNatives_fooSIOO_calls); 660 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 1, jobj_, nullptr); 661 EXPECT_TRUE(env_->IsSameObject(jobj_, result)); 662 EXPECT_EQ(6, gJava_MyClassNatives_fooSIOO_calls); 663 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 2, jobj_, nullptr); 664 EXPECT_TRUE(env_->IsSameObject(nullptr, result)); 665 EXPECT_EQ(7, gJava_MyClassNatives_fooSIOO_calls); 666 667 gJava_MyClassNatives_fooSIOO_calls = 0; 668} 669 670JNI_TEST(CompileAndRunStaticIntObjectObjectMethod) 671 672int gJava_MyClassNatives_fooSSIOO_calls = 0; 673jobject Java_MyClassNatives_fooSSIOO(JNIEnv* env, jclass klass, jint x, jobject y, jobject z) { 674 // 3 = klass + y + z 675 EXPECT_EQ(kNative, Thread::Current()->GetState()); 676 EXPECT_EQ(Thread::Current()->GetJniEnv(), env); 677 EXPECT_TRUE(klass != nullptr); 678 EXPECT_TRUE(env->IsInstanceOf(JniCompilerTest::jobj_, klass)); 679 gJava_MyClassNatives_fooSSIOO_calls++; 680 ScopedObjectAccess soa(Thread::Current()); 681 size_t null_args = (y == nullptr ? 1 : 0) + (z == nullptr ? 1 : 0); 682 EXPECT_TRUE(3U == Thread::Current()->NumStackReferences() || 683 (3U - null_args) == Thread::Current()->NumStackReferences()); 684 switch (x) { 685 case 1: 686 return y; 687 case 2: 688 return z; 689 default: 690 return klass; 691 } 692} 693 694void JniCompilerTest::CompileAndRunStaticSynchronizedIntObjectObjectMethodImpl() { 695 TEST_DISABLED_FOR_PORTABLE(); 696 SetUpForTest(true, "fooSSIOO", 697 "(ILjava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;", 698 reinterpret_cast<void*>(&Java_MyClassNatives_fooSSIOO)); 699 700 EXPECT_EQ(0, gJava_MyClassNatives_fooSSIOO_calls); 701 jobject result = env_->CallStaticObjectMethod(jklass_, jmethod_, 0, nullptr, nullptr); 702 EXPECT_TRUE(env_->IsSameObject(jklass_, result)); 703 EXPECT_EQ(1, gJava_MyClassNatives_fooSSIOO_calls); 704 705 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 0, nullptr, jobj_); 706 EXPECT_TRUE(env_->IsSameObject(jklass_, result)); 707 EXPECT_EQ(2, gJava_MyClassNatives_fooSSIOO_calls); 708 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 1, nullptr, jobj_); 709 EXPECT_TRUE(env_->IsSameObject(nullptr, result)); 710 EXPECT_EQ(3, gJava_MyClassNatives_fooSSIOO_calls); 711 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 2, nullptr, jobj_); 712 EXPECT_TRUE(env_->IsSameObject(jobj_, result)); 713 EXPECT_EQ(4, gJava_MyClassNatives_fooSSIOO_calls); 714 715 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 0, jobj_, nullptr); 716 EXPECT_TRUE(env_->IsSameObject(jklass_, result)); 717 EXPECT_EQ(5, gJava_MyClassNatives_fooSSIOO_calls); 718 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 1, jobj_, nullptr); 719 EXPECT_TRUE(env_->IsSameObject(jobj_, result)); 720 EXPECT_EQ(6, gJava_MyClassNatives_fooSSIOO_calls); 721 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 2, jobj_, nullptr); 722 EXPECT_TRUE(env_->IsSameObject(nullptr, result)); 723 EXPECT_EQ(7, gJava_MyClassNatives_fooSSIOO_calls); 724 725 gJava_MyClassNatives_fooSSIOO_calls = 0; 726} 727 728JNI_TEST(CompileAndRunStaticSynchronizedIntObjectObjectMethod) 729 730void Java_MyClassNatives_throwException(JNIEnv* env, jobject) { 731 jclass c = env->FindClass("java/lang/RuntimeException"); 732 env->ThrowNew(c, "hello"); 733} 734 735void JniCompilerTest::ExceptionHandlingImpl() { 736 TEST_DISABLED_FOR_PORTABLE(); 737 { 738 ASSERT_FALSE(runtime_->IsStarted()); 739 ScopedObjectAccess soa(Thread::Current()); 740 class_loader_ = LoadDex("MyClassNatives"); 741 742 // all compilation needs to happen before Runtime::Start 743 CompileForTest(class_loader_, false, "foo", "()V"); 744 CompileForTest(class_loader_, false, "throwException", "()V"); 745 CompileForTest(class_loader_, false, "foo", "()V"); 746 } 747 // Start runtime to avoid re-initialization in SetupForTest. 748 Thread::Current()->TransitionFromSuspendedToRunnable(); 749 bool started = runtime_->Start(); 750 CHECK(started); 751 752 gJava_MyClassNatives_foo_calls = 0; 753 754 // Check a single call of a JNI method is ok 755 SetUpForTest(false, "foo", "()V", reinterpret_cast<void*>(&Java_MyClassNatives_foo)); 756 env_->CallNonvirtualVoidMethod(jobj_, jklass_, jmethod_); 757 EXPECT_EQ(1, gJava_MyClassNatives_foo_calls); 758 EXPECT_FALSE(Thread::Current()->IsExceptionPending()); 759 760 // Get class for exception we expect to be thrown 761 ScopedLocalRef<jclass> jlre(env_, env_->FindClass("java/lang/RuntimeException")); 762 SetUpForTest(false, "throwException", "()V", 763 reinterpret_cast<void*>(&Java_MyClassNatives_throwException)); 764 // Call Java_MyClassNatives_throwException (JNI method that throws exception) 765 env_->CallNonvirtualVoidMethod(jobj_, jklass_, jmethod_); 766 EXPECT_EQ(1, gJava_MyClassNatives_foo_calls); 767 EXPECT_TRUE(env_->ExceptionCheck() == JNI_TRUE); 768 ScopedLocalRef<jthrowable> exception(env_, env_->ExceptionOccurred()); 769 env_->ExceptionClear(); 770 EXPECT_TRUE(env_->IsInstanceOf(exception.get(), jlre.get())); 771 772 // Check a single call of a JNI method is ok 773 SetUpForTest(false, "foo", "()V", reinterpret_cast<void*>(&Java_MyClassNatives_foo)); 774 env_->CallNonvirtualVoidMethod(jobj_, jklass_, jmethod_); 775 EXPECT_EQ(2, gJava_MyClassNatives_foo_calls); 776 777 gJava_MyClassNatives_foo_calls = 0; 778} 779 780JNI_TEST(ExceptionHandling) 781 782jint Java_MyClassNatives_nativeUpCall(JNIEnv* env, jobject thisObj, jint i) { 783 if (i <= 0) { 784 // We want to check raw Object* / Array* below 785 ScopedObjectAccess soa(env); 786 787 // Build stack trace 788 jobject internal = Thread::Current()->CreateInternalStackTrace<false>(soa); 789 jobjectArray ste_array = Thread::InternalStackTraceToStackTraceElementArray(soa, internal); 790 mirror::ObjectArray<mirror::StackTraceElement>* trace_array = 791 soa.Decode<mirror::ObjectArray<mirror::StackTraceElement>*>(ste_array); 792 EXPECT_TRUE(trace_array != nullptr); 793 EXPECT_EQ(11, trace_array->GetLength()); 794 795 // Check stack trace entries have expected values 796 for (int32_t i = 0; i < trace_array->GetLength(); ++i) { 797 EXPECT_EQ(-2, trace_array->Get(i)->GetLineNumber()); 798 mirror::StackTraceElement* ste = trace_array->Get(i); 799 EXPECT_STREQ("MyClassNatives.java", ste->GetFileName()->ToModifiedUtf8().c_str()); 800 EXPECT_STREQ("MyClassNatives", ste->GetDeclaringClass()->ToModifiedUtf8().c_str()); 801 EXPECT_STREQ("fooI", ste->GetMethodName()->ToModifiedUtf8().c_str()); 802 } 803 804 // end recursion 805 return 0; 806 } else { 807 jclass jklass = env->FindClass("MyClassNatives"); 808 EXPECT_TRUE(jklass != nullptr); 809 jmethodID jmethod = env->GetMethodID(jklass, "fooI", "(I)I"); 810 EXPECT_TRUE(jmethod != nullptr); 811 812 // Recurse with i - 1 813 jint result = env->CallNonvirtualIntMethod(thisObj, jklass, jmethod, i - 1); 814 815 // Return sum of all depths 816 return i + result; 817 } 818} 819 820void JniCompilerTest::NativeStackTraceElementImpl() { 821 TEST_DISABLED_FOR_PORTABLE(); 822 SetUpForTest(false, "fooI", "(I)I", 823 reinterpret_cast<void*>(&Java_MyClassNatives_nativeUpCall)); 824 jint result = env_->CallNonvirtualIntMethod(jobj_, jklass_, jmethod_, 10); 825 EXPECT_EQ(10+9+8+7+6+5+4+3+2+1, result); 826} 827 828JNI_TEST(NativeStackTraceElement) 829 830jobject Java_MyClassNatives_fooO(JNIEnv* env, jobject, jobject x) { 831 return env->NewGlobalRef(x); 832} 833 834void JniCompilerTest::ReturnGlobalRefImpl() { 835 TEST_DISABLED_FOR_PORTABLE(); 836 SetUpForTest(false, "fooO", "(Ljava/lang/Object;)Ljava/lang/Object;", 837 reinterpret_cast<void*>(&Java_MyClassNatives_fooO)); 838 jobject result = env_->CallNonvirtualObjectMethod(jobj_, jklass_, jmethod_, jobj_); 839 EXPECT_EQ(JNILocalRefType, env_->GetObjectRefType(result)); 840 EXPECT_TRUE(env_->IsSameObject(result, jobj_)); 841} 842 843JNI_TEST(ReturnGlobalRef) 844 845jint local_ref_test(JNIEnv* env, jobject thisObj, jint x) { 846 // Add 10 local references 847 ScopedObjectAccess soa(env); 848 for (int i = 0; i < 10; i++) { 849 soa.AddLocalReference<jobject>(soa.Decode<mirror::Object*>(thisObj)); 850 } 851 return x+1; 852} 853 854void JniCompilerTest::LocalReferenceTableClearingTestImpl() { 855 TEST_DISABLED_FOR_PORTABLE(); 856 SetUpForTest(false, "fooI", "(I)I", reinterpret_cast<void*>(&local_ref_test)); 857 // 1000 invocations of a method that adds 10 local references 858 for (int i = 0; i < 1000; i++) { 859 jint result = env_->CallIntMethod(jobj_, jmethod_, i); 860 EXPECT_TRUE(result == i + 1); 861 } 862} 863 864JNI_TEST(LocalReferenceTableClearingTest) 865 866void my_arraycopy(JNIEnv* env, jclass klass, jobject src, jint src_pos, jobject dst, jint dst_pos, jint length) { 867 EXPECT_TRUE(env->IsSameObject(JniCompilerTest::jklass_, klass)); 868 EXPECT_TRUE(env->IsSameObject(JniCompilerTest::jklass_, dst)); 869 EXPECT_TRUE(env->IsSameObject(JniCompilerTest::jobj_, src)); 870 EXPECT_EQ(1234, src_pos); 871 EXPECT_EQ(5678, dst_pos); 872 EXPECT_EQ(9876, length); 873} 874 875void JniCompilerTest::JavaLangSystemArrayCopyImpl() { 876 TEST_DISABLED_FOR_PORTABLE(); 877 SetUpForTest(true, "arraycopy", "(Ljava/lang/Object;ILjava/lang/Object;II)V", 878 reinterpret_cast<void*>(&my_arraycopy)); 879 env_->CallStaticVoidMethod(jklass_, jmethod_, jobj_, 1234, jklass_, 5678, 9876); 880} 881 882JNI_TEST(JavaLangSystemArrayCopy) 883 884jboolean my_casi(JNIEnv* env, jobject unsafe, jobject obj, jlong offset, jint expected, jint newval) { 885 EXPECT_TRUE(env->IsSameObject(JniCompilerTest::jobj_, unsafe)); 886 EXPECT_TRUE(env->IsSameObject(JniCompilerTest::jobj_, obj)); 887 EXPECT_EQ(INT64_C(0x12345678ABCDEF88), offset); 888 EXPECT_EQ(static_cast<jint>(0xCAFEF00D), expected); 889 EXPECT_EQ(static_cast<jint>(0xEBADF00D), newval); 890 return JNI_TRUE; 891} 892 893void JniCompilerTest::CompareAndSwapIntImpl() { 894 TEST_DISABLED_FOR_PORTABLE(); 895 SetUpForTest(false, "compareAndSwapInt", "(Ljava/lang/Object;JII)Z", 896 reinterpret_cast<void*>(&my_casi)); 897 jboolean result = env_->CallBooleanMethod(jobj_, jmethod_, jobj_, INT64_C(0x12345678ABCDEF88), 898 0xCAFEF00D, 0xEBADF00D); 899 EXPECT_EQ(result, JNI_TRUE); 900} 901 902JNI_TEST(CompareAndSwapInt) 903 904jint my_gettext(JNIEnv* env, jclass klass, jlong val1, jobject obj1, jlong val2, jobject obj2) { 905 EXPECT_TRUE(env->IsInstanceOf(JniCompilerTest::jobj_, klass)); 906 EXPECT_TRUE(env->IsSameObject(JniCompilerTest::jobj_, obj1)); 907 EXPECT_TRUE(env->IsSameObject(JniCompilerTest::jobj_, obj2)); 908 EXPECT_EQ(0x12345678ABCDEF88ll, val1); 909 EXPECT_EQ(0x7FEDCBA987654321ll, val2); 910 return 42; 911} 912 913void JniCompilerTest::GetTextImpl() { 914 TEST_DISABLED_FOR_PORTABLE(); 915 SetUpForTest(true, "getText", "(JLjava/lang/Object;JLjava/lang/Object;)I", 916 reinterpret_cast<void*>(&my_gettext)); 917 jint result = env_->CallStaticIntMethod(jklass_, jmethod_, 0x12345678ABCDEF88ll, jobj_, 918 INT64_C(0x7FEDCBA987654321), jobj_); 919 EXPECT_EQ(result, 42); 920} 921 922JNI_TEST(GetText) 923 924int gJava_MyClassNatives_GetSinkProperties_calls = 0; 925jarray Java_MyClassNatives_GetSinkProperties(JNIEnv* env, jobject thisObj, jstring s) { 926 // 1 = thisObj 927 Thread* self = Thread::Current(); 928 EXPECT_EQ(kNative, self->GetState()); 929 Locks::mutator_lock_->AssertNotHeld(self); 930 EXPECT_EQ(self->GetJniEnv(), env); 931 EXPECT_TRUE(thisObj != nullptr); 932 EXPECT_TRUE(env->IsInstanceOf(thisObj, JniCompilerTest::jklass_)); 933 EXPECT_EQ(s, nullptr); 934 gJava_MyClassNatives_GetSinkProperties_calls++; 935 ScopedObjectAccess soa(self); 936 EXPECT_EQ(2U, self->NumStackReferences()); 937 EXPECT_TRUE(self->HoldsLock(soa.Decode<mirror::Object*>(thisObj))); 938 return nullptr; 939} 940 941void JniCompilerTest::GetSinkPropertiesNativeImpl() { 942 TEST_DISABLED_FOR_PORTABLE(); 943 SetUpForTest(false, "getSinkPropertiesNative", "(Ljava/lang/String;)[Ljava/lang/Object;", 944 reinterpret_cast<void*>(&Java_MyClassNatives_GetSinkProperties)); 945 946 EXPECT_EQ(0, gJava_MyClassNatives_GetSinkProperties_calls); 947 jarray result = down_cast<jarray>( 948 env_->CallNonvirtualObjectMethod(jobj_, jklass_, jmethod_, nullptr)); 949 EXPECT_EQ(nullptr, result); 950 EXPECT_EQ(1, gJava_MyClassNatives_GetSinkProperties_calls); 951 952 gJava_MyClassNatives_GetSinkProperties_calls = 0; 953} 954 955JNI_TEST(GetSinkPropertiesNative) 956 957// This should return jclass, but we're imitating a bug pattern. 958jobject Java_MyClassNatives_instanceMethodThatShouldReturnClass(JNIEnv* env, jobject) { 959 return env->NewStringUTF("not a class!"); 960} 961 962// This should return jclass, but we're imitating a bug pattern. 963jobject Java_MyClassNatives_staticMethodThatShouldReturnClass(JNIEnv* env, jclass) { 964 return env->NewStringUTF("not a class!"); 965} 966 967void JniCompilerTest::UpcallReturnTypeChecking_InstanceImpl() { 968 TEST_DISABLED_FOR_PORTABLE(); 969 SetUpForTest(false, "instanceMethodThatShouldReturnClass", "()Ljava/lang/Class;", 970 reinterpret_cast<void*>(&Java_MyClassNatives_instanceMethodThatShouldReturnClass)); 971 972 CheckJniAbortCatcher check_jni_abort_catcher; 973 // TODO: check type of returns with portable JNI compiler. 974 // This native method is bad, and tries to return a jstring as a jclass. 975 env_->CallObjectMethod(jobj_, jmethod_); 976 check_jni_abort_catcher.Check("attempt to return an instance of java.lang.String from java.lang.Class MyClassNatives.instanceMethodThatShouldReturnClass()"); 977 978 // Here, we just call the method incorrectly; we should catch that too. 979 env_->CallVoidMethod(jobj_, jmethod_); 980 check_jni_abort_catcher.Check("attempt to return an instance of java.lang.String from java.lang.Class MyClassNatives.instanceMethodThatShouldReturnClass()"); 981 env_->CallStaticVoidMethod(jklass_, jmethod_); 982 check_jni_abort_catcher.Check("calling non-static method java.lang.Class MyClassNatives.instanceMethodThatShouldReturnClass() with CallStaticVoidMethodV"); 983} 984 985JNI_TEST(UpcallReturnTypeChecking_Instance) 986 987void JniCompilerTest::UpcallReturnTypeChecking_StaticImpl() { 988 TEST_DISABLED_FOR_PORTABLE(); 989 SetUpForTest(true, "staticMethodThatShouldReturnClass", "()Ljava/lang/Class;", 990 reinterpret_cast<void*>(&Java_MyClassNatives_staticMethodThatShouldReturnClass)); 991 992 CheckJniAbortCatcher check_jni_abort_catcher; 993 // TODO: check type of returns with portable JNI compiler. 994 // This native method is bad, and tries to return a jstring as a jclass. 995 env_->CallStaticObjectMethod(jklass_, jmethod_); 996 check_jni_abort_catcher.Check("attempt to return an instance of java.lang.String from java.lang.Class MyClassNatives.staticMethodThatShouldReturnClass()"); 997 998 // Here, we just call the method incorrectly; we should catch that too. 999 env_->CallStaticVoidMethod(jklass_, jmethod_); 1000 check_jni_abort_catcher.Check("attempt to return an instance of java.lang.String from java.lang.Class MyClassNatives.staticMethodThatShouldReturnClass()"); 1001 env_->CallVoidMethod(jobj_, jmethod_); 1002 check_jni_abort_catcher.Check("calling static method java.lang.Class MyClassNatives.staticMethodThatShouldReturnClass() with CallVoidMethodV"); 1003} 1004 1005JNI_TEST(UpcallReturnTypeChecking_Static) 1006 1007// This should take jclass, but we're imitating a bug pattern. 1008void Java_MyClassNatives_instanceMethodThatShouldTakeClass(JNIEnv*, jobject, jclass) { 1009} 1010 1011// This should take jclass, but we're imitating a bug pattern. 1012void Java_MyClassNatives_staticMethodThatShouldTakeClass(JNIEnv*, jclass, jclass) { 1013} 1014 1015void JniCompilerTest::UpcallArgumentTypeChecking_InstanceImpl() { 1016 TEST_DISABLED_FOR_PORTABLE(); 1017 SetUpForTest(false, "instanceMethodThatShouldTakeClass", "(ILjava/lang/Class;)V", 1018 reinterpret_cast<void*>(&Java_MyClassNatives_instanceMethodThatShouldTakeClass)); 1019 1020 CheckJniAbortCatcher check_jni_abort_catcher; 1021 // We deliberately pass a bad second argument here. 1022 env_->CallVoidMethod(jobj_, jmethod_, 123, env_->NewStringUTF("not a class!")); 1023 check_jni_abort_catcher.Check("bad arguments passed to void MyClassNatives.instanceMethodThatShouldTakeClass(int, java.lang.Class)"); 1024} 1025 1026JNI_TEST(UpcallArgumentTypeChecking_Instance) 1027 1028void JniCompilerTest::UpcallArgumentTypeChecking_StaticImpl() { 1029 TEST_DISABLED_FOR_PORTABLE(); 1030 SetUpForTest(true, "staticMethodThatShouldTakeClass", "(ILjava/lang/Class;)V", 1031 reinterpret_cast<void*>(&Java_MyClassNatives_staticMethodThatShouldTakeClass)); 1032 1033 CheckJniAbortCatcher check_jni_abort_catcher; 1034 // We deliberately pass a bad second argument here. 1035 env_->CallStaticVoidMethod(jklass_, jmethod_, 123, env_->NewStringUTF("not a class!")); 1036 check_jni_abort_catcher.Check("bad arguments passed to void MyClassNatives.staticMethodThatShouldTakeClass(int, java.lang.Class)"); 1037} 1038 1039JNI_TEST(UpcallArgumentTypeChecking_Static) 1040 1041jfloat Java_MyClassNatives_checkFloats(JNIEnv* env, jobject thisObj, jfloat f1, jfloat f2) { 1042 EXPECT_EQ(kNative, Thread::Current()->GetState()); 1043 EXPECT_EQ(Thread::Current()->GetJniEnv(), env); 1044 EXPECT_TRUE(thisObj != nullptr); 1045 EXPECT_TRUE(env->IsInstanceOf(thisObj, JniCompilerTest::jklass_)); 1046 ScopedObjectAccess soa(Thread::Current()); 1047 EXPECT_EQ(1U, Thread::Current()->NumStackReferences()); 1048 return f1 - f2; // non-commutative operator 1049} 1050 1051void JniCompilerTest::CompileAndRunFloatFloatMethodImpl() { 1052 TEST_DISABLED_FOR_PORTABLE(); 1053 SetUpForTest(false, "checkFloats", "(FF)F", 1054 reinterpret_cast<void*>(&Java_MyClassNatives_checkFloats)); 1055 1056 jfloat result = env_->CallNonvirtualFloatMethod(jobj_, jklass_, jmethod_, 1057 99.0F, 10.0F); 1058 EXPECT_EQ(99.0F - 10.0F, result); 1059 jfloat a = 3.14159F; 1060 jfloat b = 0.69314F; 1061 result = env_->CallNonvirtualFloatMethod(jobj_, jklass_, jmethod_, a, b); 1062 EXPECT_EQ(a - b, result); 1063} 1064 1065JNI_TEST(CompileAndRunFloatFloatMethod) 1066 1067void Java_MyClassNatives_checkParameterAlign(JNIEnv* env, jobject thisObj, jint i1, jlong l1) { 1068// EXPECT_EQ(kNative, Thread::Current()->GetState()); 1069// EXPECT_EQ(Thread::Current()->GetJniEnv(), env); 1070// EXPECT_TRUE(thisObj != nullptr); 1071// EXPECT_TRUE(env->IsInstanceOf(thisObj, JniCompilerTest::jklass_)); 1072// ScopedObjectAccess soa(Thread::Current()); 1073// EXPECT_EQ(1U, Thread::Current()->NumStackReferences()); 1074 EXPECT_EQ(i1, 1234); 1075 EXPECT_EQ(l1, INT64_C(0x12345678ABCDEF0)); 1076} 1077 1078void JniCompilerTest::CheckParameterAlignImpl() { 1079 TEST_DISABLED_FOR_PORTABLE(); 1080 SetUpForTest(false, "checkParameterAlign", "(IJ)V", 1081 reinterpret_cast<void*>(&Java_MyClassNatives_checkParameterAlign)); 1082 1083 env_->CallNonvirtualVoidMethod(jobj_, jklass_, jmethod_, 1234, INT64_C(0x12345678ABCDEF0)); 1084} 1085 1086JNI_TEST(CheckParameterAlign) 1087 1088void Java_MyClassNatives_maxParamNumber(JNIEnv* env, jobject thisObj, 1089 jobject o0, jobject o1, jobject o2, jobject o3, jobject o4, jobject o5, jobject o6, jobject o7, 1090 jobject o8, jobject o9, jobject o10, jobject o11, jobject o12, jobject o13, jobject o14, jobject o15, 1091 jobject o16, jobject o17, jobject o18, jobject o19, jobject o20, jobject o21, jobject o22, jobject o23, 1092 jobject o24, jobject o25, jobject o26, jobject o27, jobject o28, jobject o29, jobject o30, jobject o31, 1093 jobject o32, jobject o33, jobject o34, jobject o35, jobject o36, jobject o37, jobject o38, jobject o39, 1094 jobject o40, jobject o41, jobject o42, jobject o43, jobject o44, jobject o45, jobject o46, jobject o47, 1095 jobject o48, jobject o49, jobject o50, jobject o51, jobject o52, jobject o53, jobject o54, jobject o55, 1096 jobject o56, jobject o57, jobject o58, jobject o59, jobject o60, jobject o61, jobject o62, jobject o63, 1097 jobject o64, jobject o65, jobject o66, jobject o67, jobject o68, jobject o69, jobject o70, jobject o71, 1098 jobject o72, jobject o73, jobject o74, jobject o75, jobject o76, jobject o77, jobject o78, jobject o79, 1099 jobject o80, jobject o81, jobject o82, jobject o83, jobject o84, jobject o85, jobject o86, jobject o87, 1100 jobject o88, jobject o89, jobject o90, jobject o91, jobject o92, jobject o93, jobject o94, jobject o95, 1101 jobject o96, jobject o97, jobject o98, jobject o99, jobject o100, jobject o101, jobject o102, jobject o103, 1102 jobject o104, jobject o105, jobject o106, jobject o107, jobject o108, jobject o109, jobject o110, jobject o111, 1103 jobject o112, jobject o113, jobject o114, jobject o115, jobject o116, jobject o117, jobject o118, jobject o119, 1104 jobject o120, jobject o121, jobject o122, jobject o123, jobject o124, jobject o125, jobject o126, jobject o127, 1105 jobject o128, jobject o129, jobject o130, jobject o131, jobject o132, jobject o133, jobject o134, jobject o135, 1106 jobject o136, jobject o137, jobject o138, jobject o139, jobject o140, jobject o141, jobject o142, jobject o143, 1107 jobject o144, jobject o145, jobject o146, jobject o147, jobject o148, jobject o149, jobject o150, jobject o151, 1108 jobject o152, jobject o153, jobject o154, jobject o155, jobject o156, jobject o157, jobject o158, jobject o159, 1109 jobject o160, jobject o161, jobject o162, jobject o163, jobject o164, jobject o165, jobject o166, jobject o167, 1110 jobject o168, jobject o169, jobject o170, jobject o171, jobject o172, jobject o173, jobject o174, jobject o175, 1111 jobject o176, jobject o177, jobject o178, jobject o179, jobject o180, jobject o181, jobject o182, jobject o183, 1112 jobject o184, jobject o185, jobject o186, jobject o187, jobject o188, jobject o189, jobject o190, jobject o191, 1113 jobject o192, jobject o193, jobject o194, jobject o195, jobject o196, jobject o197, jobject o198, jobject o199, 1114 jobject o200, jobject o201, jobject o202, jobject o203, jobject o204, jobject o205, jobject o206, jobject o207, 1115 jobject o208, jobject o209, jobject o210, jobject o211, jobject o212, jobject o213, jobject o214, jobject o215, 1116 jobject o216, jobject o217, jobject o218, jobject o219, jobject o220, jobject o221, jobject o222, jobject o223, 1117 jobject o224, jobject o225, jobject o226, jobject o227, jobject o228, jobject o229, jobject o230, jobject o231, 1118 jobject o232, jobject o233, jobject o234, jobject o235, jobject o236, jobject o237, jobject o238, jobject o239, 1119 jobject o240, jobject o241, jobject o242, jobject o243, jobject o244, jobject o245, jobject o246, jobject o247, 1120 jobject o248, jobject o249, jobject o250, jobject o251, jobject o252, jobject o253) { 1121 EXPECT_EQ(kNative, Thread::Current()->GetState()); 1122 EXPECT_EQ(Thread::Current()->GetJniEnv(), env); 1123 EXPECT_TRUE(thisObj != nullptr); 1124 EXPECT_TRUE(env->IsInstanceOf(thisObj, JniCompilerTest::jklass_)); 1125 ScopedObjectAccess soa(Thread::Current()); 1126 EXPECT_GE(255U, Thread::Current()->NumStackReferences()); 1127 1128 // two tests possible 1129 if (o0 == nullptr) { 1130 // 1) everything is null 1131 EXPECT_TRUE(o0 == nullptr && o1 == nullptr && o2 == nullptr && o3 == nullptr && o4 == nullptr 1132 && o5 == nullptr && o6 == nullptr && o7 == nullptr && o8 == nullptr && o9 == nullptr 1133 && o10 == nullptr && o11 == nullptr && o12 == nullptr && o13 == nullptr && o14 == nullptr 1134 && o15 == nullptr && o16 == nullptr && o17 == nullptr && o18 == nullptr && o19 == nullptr 1135 && o20 == nullptr && o21 == nullptr && o22 == nullptr && o23 == nullptr && o24 == nullptr 1136 && o25 == nullptr && o26 == nullptr && o27 == nullptr && o28 == nullptr && o29 == nullptr 1137 && o30 == nullptr && o31 == nullptr && o32 == nullptr && o33 == nullptr && o34 == nullptr 1138 && o35 == nullptr && o36 == nullptr && o37 == nullptr && o38 == nullptr && o39 == nullptr 1139 && o40 == nullptr && o41 == nullptr && o42 == nullptr && o43 == nullptr && o44 == nullptr 1140 && o45 == nullptr && o46 == nullptr && o47 == nullptr && o48 == nullptr && o49 == nullptr 1141 && o50 == nullptr && o51 == nullptr && o52 == nullptr && o53 == nullptr && o54 == nullptr 1142 && o55 == nullptr && o56 == nullptr && o57 == nullptr && o58 == nullptr && o59 == nullptr 1143 && o60 == nullptr && o61 == nullptr && o62 == nullptr && o63 == nullptr && o64 == nullptr 1144 && o65 == nullptr && o66 == nullptr && o67 == nullptr && o68 == nullptr && o69 == nullptr 1145 && o70 == nullptr && o71 == nullptr && o72 == nullptr && o73 == nullptr && o74 == nullptr 1146 && o75 == nullptr && o76 == nullptr && o77 == nullptr && o78 == nullptr && o79 == nullptr 1147 && o80 == nullptr && o81 == nullptr && o82 == nullptr && o83 == nullptr && o84 == nullptr 1148 && o85 == nullptr && o86 == nullptr && o87 == nullptr && o88 == nullptr && o89 == nullptr 1149 && o90 == nullptr && o91 == nullptr && o92 == nullptr && o93 == nullptr && o94 == nullptr 1150 && o95 == nullptr && o96 == nullptr && o97 == nullptr && o98 == nullptr && o99 == nullptr 1151 && o100 == nullptr && o101 == nullptr && o102 == nullptr && o103 == nullptr && o104 == nullptr 1152 && o105 == nullptr && o106 == nullptr && o107 == nullptr && o108 == nullptr && o109 == nullptr 1153 && o110 == nullptr && o111 == nullptr && o112 == nullptr && o113 == nullptr && o114 == nullptr 1154 && o115 == nullptr && o116 == nullptr && o117 == nullptr && o118 == nullptr && o119 == nullptr 1155 && o120 == nullptr && o121 == nullptr && o122 == nullptr && o123 == nullptr && o124 == nullptr 1156 && o125 == nullptr && o126 == nullptr && o127 == nullptr && o128 == nullptr && o129 == nullptr 1157 && o130 == nullptr && o131 == nullptr && o132 == nullptr && o133 == nullptr && o134 == nullptr 1158 && o135 == nullptr && o136 == nullptr && o137 == nullptr && o138 == nullptr && o139 == nullptr 1159 && o140 == nullptr && o141 == nullptr && o142 == nullptr && o143 == nullptr && o144 == nullptr 1160 && o145 == nullptr && o146 == nullptr && o147 == nullptr && o148 == nullptr && o149 == nullptr 1161 && o150 == nullptr && o151 == nullptr && o152 == nullptr && o153 == nullptr && o154 == nullptr 1162 && o155 == nullptr && o156 == nullptr && o157 == nullptr && o158 == nullptr && o159 == nullptr 1163 && o160 == nullptr && o161 == nullptr && o162 == nullptr && o163 == nullptr && o164 == nullptr 1164 && o165 == nullptr && o166 == nullptr && o167 == nullptr && o168 == nullptr && o169 == nullptr 1165 && o170 == nullptr && o171 == nullptr && o172 == nullptr && o173 == nullptr && o174 == nullptr 1166 && o175 == nullptr && o176 == nullptr && o177 == nullptr && o178 == nullptr && o179 == nullptr 1167 && o180 == nullptr && o181 == nullptr && o182 == nullptr && o183 == nullptr && o184 == nullptr 1168 && o185 == nullptr && o186 == nullptr && o187 == nullptr && o188 == nullptr && o189 == nullptr 1169 && o190 == nullptr && o191 == nullptr && o192 == nullptr && o193 == nullptr && o194 == nullptr 1170 && o195 == nullptr && o196 == nullptr && o197 == nullptr && o198 == nullptr && o199 == nullptr 1171 && o200 == nullptr && o201 == nullptr && o202 == nullptr && o203 == nullptr && o204 == nullptr 1172 && o205 == nullptr && o206 == nullptr && o207 == nullptr && o208 == nullptr && o209 == nullptr 1173 && o210 == nullptr && o211 == nullptr && o212 == nullptr && o213 == nullptr && o214 == nullptr 1174 && o215 == nullptr && o216 == nullptr && o217 == nullptr && o218 == nullptr && o219 == nullptr 1175 && o220 == nullptr && o221 == nullptr && o222 == nullptr && o223 == nullptr && o224 == nullptr 1176 && o225 == nullptr && o226 == nullptr && o227 == nullptr && o228 == nullptr && o229 == nullptr 1177 && o230 == nullptr && o231 == nullptr && o232 == nullptr && o233 == nullptr && o234 == nullptr 1178 && o235 == nullptr && o236 == nullptr && o237 == nullptr && o238 == nullptr && o239 == nullptr 1179 && o240 == nullptr && o241 == nullptr && o242 == nullptr && o243 == nullptr && o244 == nullptr 1180 && o245 == nullptr && o246 == nullptr && o247 == nullptr && o248 == nullptr && o249 == nullptr 1181 && o250 == nullptr && o251 == nullptr && o252 == nullptr && o253 == nullptr); 1182 } else { 1183 EXPECT_EQ(0, env->GetArrayLength(reinterpret_cast<jarray>(o0))); 1184 EXPECT_EQ(1, env->GetArrayLength(reinterpret_cast<jarray>(o1))); 1185 EXPECT_EQ(2, env->GetArrayLength(reinterpret_cast<jarray>(o2))); 1186 EXPECT_EQ(3, env->GetArrayLength(reinterpret_cast<jarray>(o3))); 1187 EXPECT_EQ(4, env->GetArrayLength(reinterpret_cast<jarray>(o4))); 1188 EXPECT_EQ(5, env->GetArrayLength(reinterpret_cast<jarray>(o5))); 1189 EXPECT_EQ(6, env->GetArrayLength(reinterpret_cast<jarray>(o6))); 1190 EXPECT_EQ(7, env->GetArrayLength(reinterpret_cast<jarray>(o7))); 1191 EXPECT_EQ(8, env->GetArrayLength(reinterpret_cast<jarray>(o8))); 1192 EXPECT_EQ(9, env->GetArrayLength(reinterpret_cast<jarray>(o9))); 1193 EXPECT_EQ(10, env->GetArrayLength(reinterpret_cast<jarray>(o10))); 1194 EXPECT_EQ(11, env->GetArrayLength(reinterpret_cast<jarray>(o11))); 1195 EXPECT_EQ(12, env->GetArrayLength(reinterpret_cast<jarray>(o12))); 1196 EXPECT_EQ(13, env->GetArrayLength(reinterpret_cast<jarray>(o13))); 1197 EXPECT_EQ(14, env->GetArrayLength(reinterpret_cast<jarray>(o14))); 1198 EXPECT_EQ(15, env->GetArrayLength(reinterpret_cast<jarray>(o15))); 1199 EXPECT_EQ(16, env->GetArrayLength(reinterpret_cast<jarray>(o16))); 1200 EXPECT_EQ(17, env->GetArrayLength(reinterpret_cast<jarray>(o17))); 1201 EXPECT_EQ(18, env->GetArrayLength(reinterpret_cast<jarray>(o18))); 1202 EXPECT_EQ(19, env->GetArrayLength(reinterpret_cast<jarray>(o19))); 1203 EXPECT_EQ(20, env->GetArrayLength(reinterpret_cast<jarray>(o20))); 1204 EXPECT_EQ(21, env->GetArrayLength(reinterpret_cast<jarray>(o21))); 1205 EXPECT_EQ(22, env->GetArrayLength(reinterpret_cast<jarray>(o22))); 1206 EXPECT_EQ(23, env->GetArrayLength(reinterpret_cast<jarray>(o23))); 1207 EXPECT_EQ(24, env->GetArrayLength(reinterpret_cast<jarray>(o24))); 1208 EXPECT_EQ(25, env->GetArrayLength(reinterpret_cast<jarray>(o25))); 1209 EXPECT_EQ(26, env->GetArrayLength(reinterpret_cast<jarray>(o26))); 1210 EXPECT_EQ(27, env->GetArrayLength(reinterpret_cast<jarray>(o27))); 1211 EXPECT_EQ(28, env->GetArrayLength(reinterpret_cast<jarray>(o28))); 1212 EXPECT_EQ(29, env->GetArrayLength(reinterpret_cast<jarray>(o29))); 1213 EXPECT_EQ(30, env->GetArrayLength(reinterpret_cast<jarray>(o30))); 1214 EXPECT_EQ(31, env->GetArrayLength(reinterpret_cast<jarray>(o31))); 1215 EXPECT_EQ(32, env->GetArrayLength(reinterpret_cast<jarray>(o32))); 1216 EXPECT_EQ(33, env->GetArrayLength(reinterpret_cast<jarray>(o33))); 1217 EXPECT_EQ(34, env->GetArrayLength(reinterpret_cast<jarray>(o34))); 1218 EXPECT_EQ(35, env->GetArrayLength(reinterpret_cast<jarray>(o35))); 1219 EXPECT_EQ(36, env->GetArrayLength(reinterpret_cast<jarray>(o36))); 1220 EXPECT_EQ(37, env->GetArrayLength(reinterpret_cast<jarray>(o37))); 1221 EXPECT_EQ(38, env->GetArrayLength(reinterpret_cast<jarray>(o38))); 1222 EXPECT_EQ(39, env->GetArrayLength(reinterpret_cast<jarray>(o39))); 1223 EXPECT_EQ(40, env->GetArrayLength(reinterpret_cast<jarray>(o40))); 1224 EXPECT_EQ(41, env->GetArrayLength(reinterpret_cast<jarray>(o41))); 1225 EXPECT_EQ(42, env->GetArrayLength(reinterpret_cast<jarray>(o42))); 1226 EXPECT_EQ(43, env->GetArrayLength(reinterpret_cast<jarray>(o43))); 1227 EXPECT_EQ(44, env->GetArrayLength(reinterpret_cast<jarray>(o44))); 1228 EXPECT_EQ(45, env->GetArrayLength(reinterpret_cast<jarray>(o45))); 1229 EXPECT_EQ(46, env->GetArrayLength(reinterpret_cast<jarray>(o46))); 1230 EXPECT_EQ(47, env->GetArrayLength(reinterpret_cast<jarray>(o47))); 1231 EXPECT_EQ(48, env->GetArrayLength(reinterpret_cast<jarray>(o48))); 1232 EXPECT_EQ(49, env->GetArrayLength(reinterpret_cast<jarray>(o49))); 1233 EXPECT_EQ(50, env->GetArrayLength(reinterpret_cast<jarray>(o50))); 1234 EXPECT_EQ(51, env->GetArrayLength(reinterpret_cast<jarray>(o51))); 1235 EXPECT_EQ(52, env->GetArrayLength(reinterpret_cast<jarray>(o52))); 1236 EXPECT_EQ(53, env->GetArrayLength(reinterpret_cast<jarray>(o53))); 1237 EXPECT_EQ(54, env->GetArrayLength(reinterpret_cast<jarray>(o54))); 1238 EXPECT_EQ(55, env->GetArrayLength(reinterpret_cast<jarray>(o55))); 1239 EXPECT_EQ(56, env->GetArrayLength(reinterpret_cast<jarray>(o56))); 1240 EXPECT_EQ(57, env->GetArrayLength(reinterpret_cast<jarray>(o57))); 1241 EXPECT_EQ(58, env->GetArrayLength(reinterpret_cast<jarray>(o58))); 1242 EXPECT_EQ(59, env->GetArrayLength(reinterpret_cast<jarray>(o59))); 1243 EXPECT_EQ(60, env->GetArrayLength(reinterpret_cast<jarray>(o60))); 1244 EXPECT_EQ(61, env->GetArrayLength(reinterpret_cast<jarray>(o61))); 1245 EXPECT_EQ(62, env->GetArrayLength(reinterpret_cast<jarray>(o62))); 1246 EXPECT_EQ(63, env->GetArrayLength(reinterpret_cast<jarray>(o63))); 1247 EXPECT_EQ(64, env->GetArrayLength(reinterpret_cast<jarray>(o64))); 1248 EXPECT_EQ(65, env->GetArrayLength(reinterpret_cast<jarray>(o65))); 1249 EXPECT_EQ(66, env->GetArrayLength(reinterpret_cast<jarray>(o66))); 1250 EXPECT_EQ(67, env->GetArrayLength(reinterpret_cast<jarray>(o67))); 1251 EXPECT_EQ(68, env->GetArrayLength(reinterpret_cast<jarray>(o68))); 1252 EXPECT_EQ(69, env->GetArrayLength(reinterpret_cast<jarray>(o69))); 1253 EXPECT_EQ(70, env->GetArrayLength(reinterpret_cast<jarray>(o70))); 1254 EXPECT_EQ(71, env->GetArrayLength(reinterpret_cast<jarray>(o71))); 1255 EXPECT_EQ(72, env->GetArrayLength(reinterpret_cast<jarray>(o72))); 1256 EXPECT_EQ(73, env->GetArrayLength(reinterpret_cast<jarray>(o73))); 1257 EXPECT_EQ(74, env->GetArrayLength(reinterpret_cast<jarray>(o74))); 1258 EXPECT_EQ(75, env->GetArrayLength(reinterpret_cast<jarray>(o75))); 1259 EXPECT_EQ(76, env->GetArrayLength(reinterpret_cast<jarray>(o76))); 1260 EXPECT_EQ(77, env->GetArrayLength(reinterpret_cast<jarray>(o77))); 1261 EXPECT_EQ(78, env->GetArrayLength(reinterpret_cast<jarray>(o78))); 1262 EXPECT_EQ(79, env->GetArrayLength(reinterpret_cast<jarray>(o79))); 1263 EXPECT_EQ(80, env->GetArrayLength(reinterpret_cast<jarray>(o80))); 1264 EXPECT_EQ(81, env->GetArrayLength(reinterpret_cast<jarray>(o81))); 1265 EXPECT_EQ(82, env->GetArrayLength(reinterpret_cast<jarray>(o82))); 1266 EXPECT_EQ(83, env->GetArrayLength(reinterpret_cast<jarray>(o83))); 1267 EXPECT_EQ(84, env->GetArrayLength(reinterpret_cast<jarray>(o84))); 1268 EXPECT_EQ(85, env->GetArrayLength(reinterpret_cast<jarray>(o85))); 1269 EXPECT_EQ(86, env->GetArrayLength(reinterpret_cast<jarray>(o86))); 1270 EXPECT_EQ(87, env->GetArrayLength(reinterpret_cast<jarray>(o87))); 1271 EXPECT_EQ(88, env->GetArrayLength(reinterpret_cast<jarray>(o88))); 1272 EXPECT_EQ(89, env->GetArrayLength(reinterpret_cast<jarray>(o89))); 1273 EXPECT_EQ(90, env->GetArrayLength(reinterpret_cast<jarray>(o90))); 1274 EXPECT_EQ(91, env->GetArrayLength(reinterpret_cast<jarray>(o91))); 1275 EXPECT_EQ(92, env->GetArrayLength(reinterpret_cast<jarray>(o92))); 1276 EXPECT_EQ(93, env->GetArrayLength(reinterpret_cast<jarray>(o93))); 1277 EXPECT_EQ(94, env->GetArrayLength(reinterpret_cast<jarray>(o94))); 1278 EXPECT_EQ(95, env->GetArrayLength(reinterpret_cast<jarray>(o95))); 1279 EXPECT_EQ(96, env->GetArrayLength(reinterpret_cast<jarray>(o96))); 1280 EXPECT_EQ(97, env->GetArrayLength(reinterpret_cast<jarray>(o97))); 1281 EXPECT_EQ(98, env->GetArrayLength(reinterpret_cast<jarray>(o98))); 1282 EXPECT_EQ(99, env->GetArrayLength(reinterpret_cast<jarray>(o99))); 1283 EXPECT_EQ(100, env->GetArrayLength(reinterpret_cast<jarray>(o100))); 1284 EXPECT_EQ(101, env->GetArrayLength(reinterpret_cast<jarray>(o101))); 1285 EXPECT_EQ(102, env->GetArrayLength(reinterpret_cast<jarray>(o102))); 1286 EXPECT_EQ(103, env->GetArrayLength(reinterpret_cast<jarray>(o103))); 1287 EXPECT_EQ(104, env->GetArrayLength(reinterpret_cast<jarray>(o104))); 1288 EXPECT_EQ(105, env->GetArrayLength(reinterpret_cast<jarray>(o105))); 1289 EXPECT_EQ(106, env->GetArrayLength(reinterpret_cast<jarray>(o106))); 1290 EXPECT_EQ(107, env->GetArrayLength(reinterpret_cast<jarray>(o107))); 1291 EXPECT_EQ(108, env->GetArrayLength(reinterpret_cast<jarray>(o108))); 1292 EXPECT_EQ(109, env->GetArrayLength(reinterpret_cast<jarray>(o109))); 1293 EXPECT_EQ(110, env->GetArrayLength(reinterpret_cast<jarray>(o110))); 1294 EXPECT_EQ(111, env->GetArrayLength(reinterpret_cast<jarray>(o111))); 1295 EXPECT_EQ(112, env->GetArrayLength(reinterpret_cast<jarray>(o112))); 1296 EXPECT_EQ(113, env->GetArrayLength(reinterpret_cast<jarray>(o113))); 1297 EXPECT_EQ(114, env->GetArrayLength(reinterpret_cast<jarray>(o114))); 1298 EXPECT_EQ(115, env->GetArrayLength(reinterpret_cast<jarray>(o115))); 1299 EXPECT_EQ(116, env->GetArrayLength(reinterpret_cast<jarray>(o116))); 1300 EXPECT_EQ(117, env->GetArrayLength(reinterpret_cast<jarray>(o117))); 1301 EXPECT_EQ(118, env->GetArrayLength(reinterpret_cast<jarray>(o118))); 1302 EXPECT_EQ(119, env->GetArrayLength(reinterpret_cast<jarray>(o119))); 1303 EXPECT_EQ(120, env->GetArrayLength(reinterpret_cast<jarray>(o120))); 1304 EXPECT_EQ(121, env->GetArrayLength(reinterpret_cast<jarray>(o121))); 1305 EXPECT_EQ(122, env->GetArrayLength(reinterpret_cast<jarray>(o122))); 1306 EXPECT_EQ(123, env->GetArrayLength(reinterpret_cast<jarray>(o123))); 1307 EXPECT_EQ(124, env->GetArrayLength(reinterpret_cast<jarray>(o124))); 1308 EXPECT_EQ(125, env->GetArrayLength(reinterpret_cast<jarray>(o125))); 1309 EXPECT_EQ(126, env->GetArrayLength(reinterpret_cast<jarray>(o126))); 1310 EXPECT_EQ(127, env->GetArrayLength(reinterpret_cast<jarray>(o127))); 1311 EXPECT_EQ(128, env->GetArrayLength(reinterpret_cast<jarray>(o128))); 1312 EXPECT_EQ(129, env->GetArrayLength(reinterpret_cast<jarray>(o129))); 1313 EXPECT_EQ(130, env->GetArrayLength(reinterpret_cast<jarray>(o130))); 1314 EXPECT_EQ(131, env->GetArrayLength(reinterpret_cast<jarray>(o131))); 1315 EXPECT_EQ(132, env->GetArrayLength(reinterpret_cast<jarray>(o132))); 1316 EXPECT_EQ(133, env->GetArrayLength(reinterpret_cast<jarray>(o133))); 1317 EXPECT_EQ(134, env->GetArrayLength(reinterpret_cast<jarray>(o134))); 1318 EXPECT_EQ(135, env->GetArrayLength(reinterpret_cast<jarray>(o135))); 1319 EXPECT_EQ(136, env->GetArrayLength(reinterpret_cast<jarray>(o136))); 1320 EXPECT_EQ(137, env->GetArrayLength(reinterpret_cast<jarray>(o137))); 1321 EXPECT_EQ(138, env->GetArrayLength(reinterpret_cast<jarray>(o138))); 1322 EXPECT_EQ(139, env->GetArrayLength(reinterpret_cast<jarray>(o139))); 1323 EXPECT_EQ(140, env->GetArrayLength(reinterpret_cast<jarray>(o140))); 1324 EXPECT_EQ(141, env->GetArrayLength(reinterpret_cast<jarray>(o141))); 1325 EXPECT_EQ(142, env->GetArrayLength(reinterpret_cast<jarray>(o142))); 1326 EXPECT_EQ(143, env->GetArrayLength(reinterpret_cast<jarray>(o143))); 1327 EXPECT_EQ(144, env->GetArrayLength(reinterpret_cast<jarray>(o144))); 1328 EXPECT_EQ(145, env->GetArrayLength(reinterpret_cast<jarray>(o145))); 1329 EXPECT_EQ(146, env->GetArrayLength(reinterpret_cast<jarray>(o146))); 1330 EXPECT_EQ(147, env->GetArrayLength(reinterpret_cast<jarray>(o147))); 1331 EXPECT_EQ(148, env->GetArrayLength(reinterpret_cast<jarray>(o148))); 1332 EXPECT_EQ(149, env->GetArrayLength(reinterpret_cast<jarray>(o149))); 1333 EXPECT_EQ(150, env->GetArrayLength(reinterpret_cast<jarray>(o150))); 1334 EXPECT_EQ(151, env->GetArrayLength(reinterpret_cast<jarray>(o151))); 1335 EXPECT_EQ(152, env->GetArrayLength(reinterpret_cast<jarray>(o152))); 1336 EXPECT_EQ(153, env->GetArrayLength(reinterpret_cast<jarray>(o153))); 1337 EXPECT_EQ(154, env->GetArrayLength(reinterpret_cast<jarray>(o154))); 1338 EXPECT_EQ(155, env->GetArrayLength(reinterpret_cast<jarray>(o155))); 1339 EXPECT_EQ(156, env->GetArrayLength(reinterpret_cast<jarray>(o156))); 1340 EXPECT_EQ(157, env->GetArrayLength(reinterpret_cast<jarray>(o157))); 1341 EXPECT_EQ(158, env->GetArrayLength(reinterpret_cast<jarray>(o158))); 1342 EXPECT_EQ(159, env->GetArrayLength(reinterpret_cast<jarray>(o159))); 1343 EXPECT_EQ(160, env->GetArrayLength(reinterpret_cast<jarray>(o160))); 1344 EXPECT_EQ(161, env->GetArrayLength(reinterpret_cast<jarray>(o161))); 1345 EXPECT_EQ(162, env->GetArrayLength(reinterpret_cast<jarray>(o162))); 1346 EXPECT_EQ(163, env->GetArrayLength(reinterpret_cast<jarray>(o163))); 1347 EXPECT_EQ(164, env->GetArrayLength(reinterpret_cast<jarray>(o164))); 1348 EXPECT_EQ(165, env->GetArrayLength(reinterpret_cast<jarray>(o165))); 1349 EXPECT_EQ(166, env->GetArrayLength(reinterpret_cast<jarray>(o166))); 1350 EXPECT_EQ(167, env->GetArrayLength(reinterpret_cast<jarray>(o167))); 1351 EXPECT_EQ(168, env->GetArrayLength(reinterpret_cast<jarray>(o168))); 1352 EXPECT_EQ(169, env->GetArrayLength(reinterpret_cast<jarray>(o169))); 1353 EXPECT_EQ(170, env->GetArrayLength(reinterpret_cast<jarray>(o170))); 1354 EXPECT_EQ(171, env->GetArrayLength(reinterpret_cast<jarray>(o171))); 1355 EXPECT_EQ(172, env->GetArrayLength(reinterpret_cast<jarray>(o172))); 1356 EXPECT_EQ(173, env->GetArrayLength(reinterpret_cast<jarray>(o173))); 1357 EXPECT_EQ(174, env->GetArrayLength(reinterpret_cast<jarray>(o174))); 1358 EXPECT_EQ(175, env->GetArrayLength(reinterpret_cast<jarray>(o175))); 1359 EXPECT_EQ(176, env->GetArrayLength(reinterpret_cast<jarray>(o176))); 1360 EXPECT_EQ(177, env->GetArrayLength(reinterpret_cast<jarray>(o177))); 1361 EXPECT_EQ(178, env->GetArrayLength(reinterpret_cast<jarray>(o178))); 1362 EXPECT_EQ(179, env->GetArrayLength(reinterpret_cast<jarray>(o179))); 1363 EXPECT_EQ(180, env->GetArrayLength(reinterpret_cast<jarray>(o180))); 1364 EXPECT_EQ(181, env->GetArrayLength(reinterpret_cast<jarray>(o181))); 1365 EXPECT_EQ(182, env->GetArrayLength(reinterpret_cast<jarray>(o182))); 1366 EXPECT_EQ(183, env->GetArrayLength(reinterpret_cast<jarray>(o183))); 1367 EXPECT_EQ(184, env->GetArrayLength(reinterpret_cast<jarray>(o184))); 1368 EXPECT_EQ(185, env->GetArrayLength(reinterpret_cast<jarray>(o185))); 1369 EXPECT_EQ(186, env->GetArrayLength(reinterpret_cast<jarray>(o186))); 1370 EXPECT_EQ(187, env->GetArrayLength(reinterpret_cast<jarray>(o187))); 1371 EXPECT_EQ(188, env->GetArrayLength(reinterpret_cast<jarray>(o188))); 1372 EXPECT_EQ(189, env->GetArrayLength(reinterpret_cast<jarray>(o189))); 1373 EXPECT_EQ(190, env->GetArrayLength(reinterpret_cast<jarray>(o190))); 1374 EXPECT_EQ(191, env->GetArrayLength(reinterpret_cast<jarray>(o191))); 1375 EXPECT_EQ(192, env->GetArrayLength(reinterpret_cast<jarray>(o192))); 1376 EXPECT_EQ(193, env->GetArrayLength(reinterpret_cast<jarray>(o193))); 1377 EXPECT_EQ(194, env->GetArrayLength(reinterpret_cast<jarray>(o194))); 1378 EXPECT_EQ(195, env->GetArrayLength(reinterpret_cast<jarray>(o195))); 1379 EXPECT_EQ(196, env->GetArrayLength(reinterpret_cast<jarray>(o196))); 1380 EXPECT_EQ(197, env->GetArrayLength(reinterpret_cast<jarray>(o197))); 1381 EXPECT_EQ(198, env->GetArrayLength(reinterpret_cast<jarray>(o198))); 1382 EXPECT_EQ(199, env->GetArrayLength(reinterpret_cast<jarray>(o199))); 1383 EXPECT_EQ(200, env->GetArrayLength(reinterpret_cast<jarray>(o200))); 1384 EXPECT_EQ(201, env->GetArrayLength(reinterpret_cast<jarray>(o201))); 1385 EXPECT_EQ(202, env->GetArrayLength(reinterpret_cast<jarray>(o202))); 1386 EXPECT_EQ(203, env->GetArrayLength(reinterpret_cast<jarray>(o203))); 1387 EXPECT_EQ(204, env->GetArrayLength(reinterpret_cast<jarray>(o204))); 1388 EXPECT_EQ(205, env->GetArrayLength(reinterpret_cast<jarray>(o205))); 1389 EXPECT_EQ(206, env->GetArrayLength(reinterpret_cast<jarray>(o206))); 1390 EXPECT_EQ(207, env->GetArrayLength(reinterpret_cast<jarray>(o207))); 1391 EXPECT_EQ(208, env->GetArrayLength(reinterpret_cast<jarray>(o208))); 1392 EXPECT_EQ(209, env->GetArrayLength(reinterpret_cast<jarray>(o209))); 1393 EXPECT_EQ(210, env->GetArrayLength(reinterpret_cast<jarray>(o210))); 1394 EXPECT_EQ(211, env->GetArrayLength(reinterpret_cast<jarray>(o211))); 1395 EXPECT_EQ(212, env->GetArrayLength(reinterpret_cast<jarray>(o212))); 1396 EXPECT_EQ(213, env->GetArrayLength(reinterpret_cast<jarray>(o213))); 1397 EXPECT_EQ(214, env->GetArrayLength(reinterpret_cast<jarray>(o214))); 1398 EXPECT_EQ(215, env->GetArrayLength(reinterpret_cast<jarray>(o215))); 1399 EXPECT_EQ(216, env->GetArrayLength(reinterpret_cast<jarray>(o216))); 1400 EXPECT_EQ(217, env->GetArrayLength(reinterpret_cast<jarray>(o217))); 1401 EXPECT_EQ(218, env->GetArrayLength(reinterpret_cast<jarray>(o218))); 1402 EXPECT_EQ(219, env->GetArrayLength(reinterpret_cast<jarray>(o219))); 1403 EXPECT_EQ(220, env->GetArrayLength(reinterpret_cast<jarray>(o220))); 1404 EXPECT_EQ(221, env->GetArrayLength(reinterpret_cast<jarray>(o221))); 1405 EXPECT_EQ(222, env->GetArrayLength(reinterpret_cast<jarray>(o222))); 1406 EXPECT_EQ(223, env->GetArrayLength(reinterpret_cast<jarray>(o223))); 1407 EXPECT_EQ(224, env->GetArrayLength(reinterpret_cast<jarray>(o224))); 1408 EXPECT_EQ(225, env->GetArrayLength(reinterpret_cast<jarray>(o225))); 1409 EXPECT_EQ(226, env->GetArrayLength(reinterpret_cast<jarray>(o226))); 1410 EXPECT_EQ(227, env->GetArrayLength(reinterpret_cast<jarray>(o227))); 1411 EXPECT_EQ(228, env->GetArrayLength(reinterpret_cast<jarray>(o228))); 1412 EXPECT_EQ(229, env->GetArrayLength(reinterpret_cast<jarray>(o229))); 1413 EXPECT_EQ(230, env->GetArrayLength(reinterpret_cast<jarray>(o230))); 1414 EXPECT_EQ(231, env->GetArrayLength(reinterpret_cast<jarray>(o231))); 1415 EXPECT_EQ(232, env->GetArrayLength(reinterpret_cast<jarray>(o232))); 1416 EXPECT_EQ(233, env->GetArrayLength(reinterpret_cast<jarray>(o233))); 1417 EXPECT_EQ(234, env->GetArrayLength(reinterpret_cast<jarray>(o234))); 1418 EXPECT_EQ(235, env->GetArrayLength(reinterpret_cast<jarray>(o235))); 1419 EXPECT_EQ(236, env->GetArrayLength(reinterpret_cast<jarray>(o236))); 1420 EXPECT_EQ(237, env->GetArrayLength(reinterpret_cast<jarray>(o237))); 1421 EXPECT_EQ(238, env->GetArrayLength(reinterpret_cast<jarray>(o238))); 1422 EXPECT_EQ(239, env->GetArrayLength(reinterpret_cast<jarray>(o239))); 1423 EXPECT_EQ(240, env->GetArrayLength(reinterpret_cast<jarray>(o240))); 1424 EXPECT_EQ(241, env->GetArrayLength(reinterpret_cast<jarray>(o241))); 1425 EXPECT_EQ(242, env->GetArrayLength(reinterpret_cast<jarray>(o242))); 1426 EXPECT_EQ(243, env->GetArrayLength(reinterpret_cast<jarray>(o243))); 1427 EXPECT_EQ(244, env->GetArrayLength(reinterpret_cast<jarray>(o244))); 1428 EXPECT_EQ(245, env->GetArrayLength(reinterpret_cast<jarray>(o245))); 1429 EXPECT_EQ(246, env->GetArrayLength(reinterpret_cast<jarray>(o246))); 1430 EXPECT_EQ(247, env->GetArrayLength(reinterpret_cast<jarray>(o247))); 1431 EXPECT_EQ(248, env->GetArrayLength(reinterpret_cast<jarray>(o248))); 1432 EXPECT_EQ(249, env->GetArrayLength(reinterpret_cast<jarray>(o249))); 1433 EXPECT_EQ(250, env->GetArrayLength(reinterpret_cast<jarray>(o250))); 1434 EXPECT_EQ(251, env->GetArrayLength(reinterpret_cast<jarray>(o251))); 1435 EXPECT_EQ(252, env->GetArrayLength(reinterpret_cast<jarray>(o252))); 1436 EXPECT_EQ(253, env->GetArrayLength(reinterpret_cast<jarray>(o253))); 1437 } 1438} 1439 1440const char* longSig = 1441 "(Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1442 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1443 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1444 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1445 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1446 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1447 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1448 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1449 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1450 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1451 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1452 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1453 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1454 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1455 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1456 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1457 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1458 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1459 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1460 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1461 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1462 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1463 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1464 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1465 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1466 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1467 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1468 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1469 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1470 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1471 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1472 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1473 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1474 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1475 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1476 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1477 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1478 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1479 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1480 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1481 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1482 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1483 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1484 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1485 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1486 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1487 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1488 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1489 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1490 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;" 1491 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)V"; 1492 1493void JniCompilerTest::MaxParamNumberImpl() { 1494 TEST_DISABLED_FOR_PORTABLE(); 1495 SetUpForTest(false, "maxParamNumber", longSig, 1496 reinterpret_cast<void*>(&Java_MyClassNatives_maxParamNumber)); 1497 1498 jvalue args[254]; 1499 1500 // First test: test with all arguments null. 1501 for (int i = 0; i < 254; ++i) { 1502 args[i].l = nullptr; 1503 } 1504 1505 env_->CallNonvirtualVoidMethodA(jobj_, jklass_, jmethod_, args); 1506 1507 // Second test: test with int[] objects with increasing lengths 1508 for (int i = 0; i < 254; ++i) { 1509 jintArray tmp = env_->NewIntArray(i); 1510 args[i].l = tmp; 1511 EXPECT_NE(args[i].l, nullptr); 1512 } 1513 1514 env_->CallNonvirtualVoidMethodA(jobj_, jklass_, jmethod_, args); 1515} 1516 1517JNI_TEST(MaxParamNumber) 1518 1519void JniCompilerTest::WithoutImplementationImpl() { 1520 TEST_DISABLED_FOR_PORTABLE(); 1521 SetUpForTest(false, "withoutImplementation", "()V", nullptr); 1522 1523 env_->CallVoidMethod(jobj_, jmethod_); 1524 1525 EXPECT_TRUE(Thread::Current()->IsExceptionPending()); 1526 EXPECT_TRUE(env_->ExceptionCheck() == JNI_TRUE); 1527} 1528 1529JNI_TEST(WithoutImplementation) 1530 1531void Java_MyClassNatives_stackArgsIntsFirst(JNIEnv* env, jclass klass, jint i1, jint i2, jint i3, 1532 jint i4, jint i5, jint i6, jint i7, jint i8, jint i9, 1533 jint i10, jfloat f1, jfloat f2, jfloat f3, jfloat f4, 1534 jfloat f5, jfloat f6, jfloat f7, jfloat f8, jfloat f9, 1535 jfloat f10) { 1536 EXPECT_EQ(i1, 1); 1537 EXPECT_EQ(i2, 2); 1538 EXPECT_EQ(i3, 3); 1539 EXPECT_EQ(i4, 4); 1540 EXPECT_EQ(i5, 5); 1541 EXPECT_EQ(i6, 6); 1542 EXPECT_EQ(i7, 7); 1543 EXPECT_EQ(i8, 8); 1544 EXPECT_EQ(i9, 9); 1545 EXPECT_EQ(i10, 10); 1546 1547 jint i11 = bit_cast<jfloat, jint>(f1); 1548 EXPECT_EQ(i11, 11); 1549 jint i12 = bit_cast<jfloat, jint>(f2); 1550 EXPECT_EQ(i12, 12); 1551 jint i13 = bit_cast<jfloat, jint>(f3); 1552 EXPECT_EQ(i13, 13); 1553 jint i14 = bit_cast<jfloat, jint>(f4); 1554 EXPECT_EQ(i14, 14); 1555 jint i15 = bit_cast<jfloat, jint>(f5); 1556 EXPECT_EQ(i15, 15); 1557 jint i16 = bit_cast<jfloat, jint>(f6); 1558 EXPECT_EQ(i16, 16); 1559 jint i17 = bit_cast<jfloat, jint>(f7); 1560 EXPECT_EQ(i17, 17); 1561 jint i18 = bit_cast<jfloat, jint>(f8); 1562 EXPECT_EQ(i18, 18); 1563 jint i19 = bit_cast<jfloat, jint>(f9); 1564 EXPECT_EQ(i19, 19); 1565 jint i20 = bit_cast<jfloat, jint>(f10); 1566 EXPECT_EQ(i20, 20); 1567} 1568 1569void JniCompilerTest::StackArgsIntsFirstImpl() { 1570 TEST_DISABLED_FOR_PORTABLE(); 1571 SetUpForTest(true, "stackArgsIntsFirst", "(IIIIIIIIIIFFFFFFFFFF)V", 1572 reinterpret_cast<void*>(&Java_MyClassNatives_stackArgsIntsFirst)); 1573 1574 jint i1 = 1; 1575 jint i2 = 2; 1576 jint i3 = 3; 1577 jint i4 = 4; 1578 jint i5 = 5; 1579 jint i6 = 6; 1580 jint i7 = 7; 1581 jint i8 = 8; 1582 jint i9 = 9; 1583 jint i10 = 10; 1584 1585 jfloat f1 = bit_cast<jint, jfloat>(11); 1586 jfloat f2 = bit_cast<jint, jfloat>(12); 1587 jfloat f3 = bit_cast<jint, jfloat>(13); 1588 jfloat f4 = bit_cast<jint, jfloat>(14); 1589 jfloat f5 = bit_cast<jint, jfloat>(15); 1590 jfloat f6 = bit_cast<jint, jfloat>(16); 1591 jfloat f7 = bit_cast<jint, jfloat>(17); 1592 jfloat f8 = bit_cast<jint, jfloat>(18); 1593 jfloat f9 = bit_cast<jint, jfloat>(19); 1594 jfloat f10 = bit_cast<jint, jfloat>(20); 1595 1596 env_->CallStaticVoidMethod(jklass_, jmethod_, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, f1, f2, 1597 f3, f4, f5, f6, f7, f8, f9, f10); 1598} 1599 1600JNI_TEST(StackArgsIntsFirst) 1601 1602void Java_MyClassNatives_stackArgsFloatsFirst(JNIEnv* env, jclass klass, jfloat f1, jfloat f2, 1603 jfloat f3, jfloat f4, jfloat f5, jfloat f6, jfloat f7, 1604 jfloat f8, jfloat f9, jfloat f10, jint i1, jint i2, 1605 jint i3, jint i4, jint i5, jint i6, jint i7, jint i8, 1606 jint i9, jint i10) { 1607 EXPECT_EQ(i1, 1); 1608 EXPECT_EQ(i2, 2); 1609 EXPECT_EQ(i3, 3); 1610 EXPECT_EQ(i4, 4); 1611 EXPECT_EQ(i5, 5); 1612 EXPECT_EQ(i6, 6); 1613 EXPECT_EQ(i7, 7); 1614 EXPECT_EQ(i8, 8); 1615 EXPECT_EQ(i9, 9); 1616 EXPECT_EQ(i10, 10); 1617 1618 jint i11 = bit_cast<jfloat, jint>(f1); 1619 EXPECT_EQ(i11, 11); 1620 jint i12 = bit_cast<jfloat, jint>(f2); 1621 EXPECT_EQ(i12, 12); 1622 jint i13 = bit_cast<jfloat, jint>(f3); 1623 EXPECT_EQ(i13, 13); 1624 jint i14 = bit_cast<jfloat, jint>(f4); 1625 EXPECT_EQ(i14, 14); 1626 jint i15 = bit_cast<jfloat, jint>(f5); 1627 EXPECT_EQ(i15, 15); 1628 jint i16 = bit_cast<jfloat, jint>(f6); 1629 EXPECT_EQ(i16, 16); 1630 jint i17 = bit_cast<jfloat, jint>(f7); 1631 EXPECT_EQ(i17, 17); 1632 jint i18 = bit_cast<jfloat, jint>(f8); 1633 EXPECT_EQ(i18, 18); 1634 jint i19 = bit_cast<jfloat, jint>(f9); 1635 EXPECT_EQ(i19, 19); 1636 jint i20 = bit_cast<jfloat, jint>(f10); 1637 EXPECT_EQ(i20, 20); 1638} 1639 1640void JniCompilerTest::StackArgsFloatsFirstImpl() { 1641 TEST_DISABLED_FOR_PORTABLE(); 1642 SetUpForTest(true, "stackArgsFloatsFirst", "(FFFFFFFFFFIIIIIIIIII)V", 1643 reinterpret_cast<void*>(&Java_MyClassNatives_stackArgsFloatsFirst)); 1644 1645 jint i1 = 1; 1646 jint i2 = 2; 1647 jint i3 = 3; 1648 jint i4 = 4; 1649 jint i5 = 5; 1650 jint i6 = 6; 1651 jint i7 = 7; 1652 jint i8 = 8; 1653 jint i9 = 9; 1654 jint i10 = 10; 1655 1656 jfloat f1 = bit_cast<jint, jfloat>(11); 1657 jfloat f2 = bit_cast<jint, jfloat>(12); 1658 jfloat f3 = bit_cast<jint, jfloat>(13); 1659 jfloat f4 = bit_cast<jint, jfloat>(14); 1660 jfloat f5 = bit_cast<jint, jfloat>(15); 1661 jfloat f6 = bit_cast<jint, jfloat>(16); 1662 jfloat f7 = bit_cast<jint, jfloat>(17); 1663 jfloat f8 = bit_cast<jint, jfloat>(18); 1664 jfloat f9 = bit_cast<jint, jfloat>(19); 1665 jfloat f10 = bit_cast<jint, jfloat>(20); 1666 1667 env_->CallStaticVoidMethod(jklass_, jmethod_, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, i1, i2, i3, 1668 i4, i5, i6, i7, i8, i9, i10); 1669} 1670 1671JNI_TEST(StackArgsFloatsFirst) 1672 1673void Java_MyClassNatives_stackArgsMixed(JNIEnv* env, jclass klass, jint i1, jfloat f1, jint i2, 1674 jfloat f2, jint i3, jfloat f3, jint i4, jfloat f4, jint i5, 1675 jfloat f5, jint i6, jfloat f6, jint i7, jfloat f7, jint i8, 1676 jfloat f8, jint i9, jfloat f9, jint i10, jfloat f10) { 1677 EXPECT_EQ(i1, 1); 1678 EXPECT_EQ(i2, 2); 1679 EXPECT_EQ(i3, 3); 1680 EXPECT_EQ(i4, 4); 1681 EXPECT_EQ(i5, 5); 1682 EXPECT_EQ(i6, 6); 1683 EXPECT_EQ(i7, 7); 1684 EXPECT_EQ(i8, 8); 1685 EXPECT_EQ(i9, 9); 1686 EXPECT_EQ(i10, 10); 1687 1688 jint i11 = bit_cast<jfloat, jint>(f1); 1689 EXPECT_EQ(i11, 11); 1690 jint i12 = bit_cast<jfloat, jint>(f2); 1691 EXPECT_EQ(i12, 12); 1692 jint i13 = bit_cast<jfloat, jint>(f3); 1693 EXPECT_EQ(i13, 13); 1694 jint i14 = bit_cast<jfloat, jint>(f4); 1695 EXPECT_EQ(i14, 14); 1696 jint i15 = bit_cast<jfloat, jint>(f5); 1697 EXPECT_EQ(i15, 15); 1698 jint i16 = bit_cast<jfloat, jint>(f6); 1699 EXPECT_EQ(i16, 16); 1700 jint i17 = bit_cast<jfloat, jint>(f7); 1701 EXPECT_EQ(i17, 17); 1702 jint i18 = bit_cast<jfloat, jint>(f8); 1703 EXPECT_EQ(i18, 18); 1704 jint i19 = bit_cast<jfloat, jint>(f9); 1705 EXPECT_EQ(i19, 19); 1706 jint i20 = bit_cast<jfloat, jint>(f10); 1707 EXPECT_EQ(i20, 20); 1708} 1709 1710void JniCompilerTest::StackArgsMixedImpl() { 1711 TEST_DISABLED_FOR_PORTABLE(); 1712 SetUpForTest(true, "stackArgsMixed", "(IFIFIFIFIFIFIFIFIFIF)V", 1713 reinterpret_cast<void*>(&Java_MyClassNatives_stackArgsMixed)); 1714 1715 jint i1 = 1; 1716 jint i2 = 2; 1717 jint i3 = 3; 1718 jint i4 = 4; 1719 jint i5 = 5; 1720 jint i6 = 6; 1721 jint i7 = 7; 1722 jint i8 = 8; 1723 jint i9 = 9; 1724 jint i10 = 10; 1725 1726 jfloat f1 = bit_cast<jint, jfloat>(11); 1727 jfloat f2 = bit_cast<jint, jfloat>(12); 1728 jfloat f3 = bit_cast<jint, jfloat>(13); 1729 jfloat f4 = bit_cast<jint, jfloat>(14); 1730 jfloat f5 = bit_cast<jint, jfloat>(15); 1731 jfloat f6 = bit_cast<jint, jfloat>(16); 1732 jfloat f7 = bit_cast<jint, jfloat>(17); 1733 jfloat f8 = bit_cast<jint, jfloat>(18); 1734 jfloat f9 = bit_cast<jint, jfloat>(19); 1735 jfloat f10 = bit_cast<jint, jfloat>(20); 1736 1737 env_->CallStaticVoidMethod(jklass_, jmethod_, i1, f1, i2, f2, i3, f3, i4, f4, i5, f5, i6, f6, i7, 1738 f7, i8, f8, i9, f9, i10, f10); 1739} 1740 1741JNI_TEST(StackArgsMixed) 1742 1743} // namespace art 1744