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