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