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 <math.h>
18
19 #include <memory>
20 #include <type_traits>
21
22 #include "art_method-inl.h"
23 #include "base/bit_utils.h"
24 #include "base/casts.h"
25 #include "base/macros.h"
26 #include "base/mem_map.h"
27 #include "class_linker.h"
28 #include "common_compiler_test.h"
29 #include "compiler.h"
30 #include "dex/dex_file.h"
31 #include "driver/compiler_options.h"
32 #include "entrypoints/entrypoint_utils-inl.h"
33 #include "gtest/gtest.h"
34 #include "indirect_reference_table.h"
35 #include "java_frame_root_info.h"
36 #include "jni/java_vm_ext.h"
37 #include "jni/jni_internal.h"
38 #include "mirror/class-inl.h"
39 #include "mirror/class_loader.h"
40 #include "mirror/object-inl.h"
41 #include "mirror/object_array-inl.h"
42 #include "mirror/stack_trace_element-inl.h"
43 #include "nativehelper/scoped_local_ref.h"
44 #include "nativeloader/native_loader.h"
45 #include "oat/oat_quick_method_header.h"
46 #include "runtime.h"
47 #include "scoped_thread_state_change-inl.h"
48 #include "thread-inl.h"
49
Java_MyClassNatives_bar(JNIEnv *,jobject,jint count)50 extern "C" JNIEXPORT jint JNICALL Java_MyClassNatives_bar(JNIEnv*, jobject, jint count) {
51 return count + 1;
52 }
53
54 // Note: JNI name mangling "_" -> "_1".
Java_MyClassNatives_bar_1Fast(JNIEnv *,jobject,jint count)55 extern "C" JNIEXPORT jint JNICALL Java_MyClassNatives_bar_1Fast(JNIEnv*, jobject, jint count) {
56 return count + 1;
57 }
58
Java_MyClassNatives_sbar(JNIEnv *,jclass,jint count)59 extern "C" JNIEXPORT jint JNICALL Java_MyClassNatives_sbar(JNIEnv*, jclass, jint count) {
60 return count + 1;
61 }
62
63 // Note: JNI name mangling "_" -> "_1".
Java_MyClassNatives_sbar_1Fast(JNIEnv *,jclass,jint count)64 extern "C" JNIEXPORT jint JNICALL Java_MyClassNatives_sbar_1Fast(JNIEnv*, jclass, jint count) {
65 return count + 1;
66 }
67
68 // Note: JNI name mangling "_" -> "_1".
Java_MyClassNatives_sbar_1Critical(jint count)69 extern "C" JNIEXPORT jint JNICALL Java_MyClassNatives_sbar_1Critical(jint count) {
70 return count + 1;
71 }
72
73 // TODO: In the Baker read barrier configuration, add checks to ensure
74 // the Marking Register's value is correct.
75
76 namespace art HIDDEN {
77
78 enum class JniKind {
79 kNormal, // Regular kind of un-annotated natives.
80 kFast, // Native method annotated with @FastNative.
81 kCritical, // Native method annotated with @CriticalNative.
82 kCount // How many different types of JNIs we can have.
83 };
84
85 // Used to initialize array sizes that want to have different state per current jni.
86 static constexpr size_t kJniKindCount = static_cast<size_t>(JniKind::kCount);
87 // Do not use directly, use the helpers instead.
88 uint32_t gCurrentJni = static_cast<uint32_t>(JniKind::kNormal);
89
90 // Is the current native method under test @CriticalNative?
IsCurrentJniCritical()91 static bool IsCurrentJniCritical() {
92 return gCurrentJni == static_cast<uint32_t>(JniKind::kCritical);
93 }
94
95 // Is the current native method under test @FastNative?
IsCurrentJniFast()96 static bool IsCurrentJniFast() {
97 return gCurrentJni == static_cast<uint32_t>(JniKind::kFast);
98 }
99
100 // Is the current native method a plain-old non-annotated native?
IsCurrentJniNormal()101 static bool IsCurrentJniNormal() {
102 return gCurrentJni == static_cast<uint32_t>(JniKind::kNormal);
103 }
104
105 // Signify that a different kind of JNI is about to be tested.
UpdateCurrentJni(JniKind kind)106 static void UpdateCurrentJni(JniKind kind) {
107 gCurrentJni = static_cast<uint32_t>(kind);
108 }
109
110 // (Match the name suffixes of native methods in MyClassNatives.java)
CurrentJniStringSuffix()111 static std::string CurrentJniStringSuffix() {
112 switch (gCurrentJni) {
113 case static_cast<uint32_t>(JniKind::kNormal): {
114 return "";
115 }
116 case static_cast<uint32_t>(JniKind::kFast): {
117 return "_Fast";
118 }
119 case static_cast<uint32_t>(JniKind::kCritical): {
120 return "_Critical";
121 }
122 default:
123 LOG(FATAL) << "Invalid current JNI value: " << gCurrentJni;
124 UNREACHABLE();
125 }
126 }
127
128 // Fake values passed to our JNI handlers when we enter @CriticalNative.
129 // Normally @CriticalNative calling convention strips out the "JNIEnv*, jclass" parameters.
130 // However to avoid duplicating every single test method we have a templated handler
131 // that inserts fake parameters (0,1) to make it compatible with a regular JNI handler.
132 static JNIEnv* const kCriticalFakeJniEnv = reinterpret_cast<JNIEnv*>(0xDEADFEAD);
133 static jclass const kCriticalFakeJniClass = reinterpret_cast<jclass>(0xBEAFBEEF);
134
135 // Type trait. Returns true if "T" is the same type as one of the types in Args...
136 //
137 // Logically equal to OR(std::same_type<T, U> for all U in Args).
138 template <typename T, typename ... Args>
139 struct is_any_of;
140
141 template <typename T, typename U, typename ... Args>
142 struct is_any_of<T, U, Args ...> {
143 using value_type = bool;
144 static constexpr const bool value = std::is_same<T, U>::value || is_any_of<T, Args ...>::value;
145 };
146
147 template <typename T, typename U>
148 struct is_any_of<T, U> {
149 using value_type = bool;
150 static constexpr const bool value = std::is_same<T, U>::value;
151 };
152
153 // Type traits for JNI types.
154 template <typename T>
155 struct jni_type_traits {
156 // True if type T ends up holding an object reference. False otherwise.
157 // (Non-JNI types will also be false).
158 static constexpr const bool is_ref =
159 is_any_of<T, jclass, jobject, jstring, jobjectArray, jintArray,
160 jcharArray, jfloatArray, jshortArray, jdoubleArray, jlongArray>::value;
161 };
162
163 // Base case: No parameters = 0 refs.
count_nonnull_refs_helper()164 size_t count_nonnull_refs_helper() {
165 return 0;
166 }
167
168 // SFINAE for ref types. 1 if non-null, 0 otherwise.
169 template <typename T>
count_nonnull_refs_single_helper(T arg,typename std::enable_if<jni_type_traits<T>::is_ref>::type * =nullptr)170 size_t count_nonnull_refs_single_helper(T arg,
171 typename std::enable_if<jni_type_traits<T>::is_ref>::type*
172 = nullptr) {
173 return ((arg == NULL) ? 0 : 1);
174 }
175
176 // SFINAE for non-ref-types. Always 0.
177 template <typename T>
count_nonnull_refs_single_helper(T arg,typename std::enable_if<!jni_type_traits<T>::is_ref>::type * =nullptr)178 size_t count_nonnull_refs_single_helper(
179 [[maybe_unused]] T arg, typename std::enable_if<!jni_type_traits<T>::is_ref>::type* = nullptr) {
180 return 0;
181 }
182
183 // Recursive case.
184 template <typename T, typename ... Args>
count_nonnull_refs_helper(T arg,Args...args)185 size_t count_nonnull_refs_helper(T arg, Args ... args) {
186 return count_nonnull_refs_single_helper(arg) + count_nonnull_refs_helper(args...);
187 }
188
189 // Given any list of parameters, check how many object refs there are and only count
190 // them if their runtime value is non-null.
191 //
192 // For example given (jobject, jint, jclass) we can get (2) if both #0/#2 are non-null,
193 // (1) if either #0/#2 are null but not both, and (0) if all parameters are null.
194 // Primitive parameters (including JNIEnv*, if present) are ignored.
195 template <typename ... Args>
count_nonnull_refs(Args...args)196 size_t count_nonnull_refs(Args ... args) {
197 return count_nonnull_refs_helper(args...);
198 }
199
200 template <typename T, T* fn>
201 struct remove_extra_parameters_helper;
202
203 template <typename R, typename Arg1, typename Arg2, typename ... Args, R (*fn)(Arg1, Arg2, Args...)>
204 struct remove_extra_parameters_helper<R(Arg1, Arg2, Args...), fn> {
205 // Note: Do not use Args&& here to maintain C-style parameter types.
applyart::remove_extra_parameters_helper206 static R apply(Args... args) {
207 JNIEnv* env = kCriticalFakeJniEnv;
208 jclass kls = kCriticalFakeJniClass;
209 return fn(env, kls, args...);
210 }
211 };
212
213 // Given a function 'fn' create a function 'apply' which will omit the JNIEnv/jklass parameters
214 //
215 // i.e. if fn(JNIEnv*,jklass,a,b,c,d,e...) then apply(a,b,c,d,e,...)
216 template <typename T, T* fn>
217 struct jni_remove_extra_parameters : public remove_extra_parameters_helper<T, fn> {};
218
219 class JniCompilerTest : public CommonCompilerTest {
220 protected:
SetUp()221 void SetUp() override {
222 CommonCompilerTest::SetUp();
223 check_generic_jni_ = false;
224 }
225
TearDown()226 void TearDown() override {
227 android::ResetNativeLoader();
228 CommonCompilerTest::TearDown();
229 }
230
SetCheckGenericJni(bool generic)231 void SetCheckGenericJni(bool generic) {
232 check_generic_jni_ = generic;
233 }
234
235 private:
CompileForTest(jobject class_loader,bool direct,const char * method_name,const char * method_sig)236 void CompileForTest(jobject class_loader,
237 bool direct,
238 const char* method_name,
239 const char* method_sig) {
240 Thread* self = Thread::Current();
241 ScopedObjectAccess soa(self);
242 StackHandleScope<2> hs(self);
243 Handle<mirror::ClassLoader> loader(
244 hs.NewHandle(soa.Decode<mirror::ClassLoader>(class_loader)));
245 // Compile the native method before starting the runtime
246 Handle<mirror::Class> c = hs.NewHandle(FindClass("LMyClassNatives;", loader));
247 const auto pointer_size = class_linker_->GetImagePointerSize();
248 ArtMethod* method = c->FindClassMethod(method_name, method_sig, pointer_size);
249 ASSERT_TRUE(method != nullptr) << method_name << " " << method_sig;
250 ASSERT_EQ(direct, method->IsDirect()) << method_name << " " << method_sig;
251 if (direct) {
252 // Class initialization could replace the entrypoint, so force
253 // the initialization before we set up the entrypoint below.
254 class_linker_->EnsureInitialized(
255 self, c, /*can_init_fields=*/ true, /*can_init_parents=*/ true);
256 {
257 ScopedThreadSuspension sts(self, ThreadState::kNative);
258 class_linker_->MakeInitializedClassesVisiblyInitialized(self, /*wait=*/ true);
259 }
260 }
261 if (check_generic_jni_) {
262 method->SetEntryPointFromQuickCompiledCode(class_linker_->GetRuntimeQuickGenericJniStub());
263 } else {
264 const void* code = method->GetEntryPointFromQuickCompiledCode();
265 if (code == nullptr || class_linker_->IsQuickGenericJniStub(code)) {
266 CompileMethod(method);
267 ASSERT_TRUE(method->GetEntryPointFromQuickCompiledCode() != nullptr)
268 << method_name << " " << method_sig;
269 }
270 }
271 }
272
273 protected:
CompileForTestWithCurrentJni(jobject class_loader,bool direct,const char * method_name_orig,const char * method_sig)274 void CompileForTestWithCurrentJni(jobject class_loader,
275 bool direct,
276 const char* method_name_orig,
277 const char* method_sig) {
278 // Append the JNI kind to the method name, so that we automatically get the
279 // fast or critical versions of the same method.
280 std::string method_name_str = std::string(method_name_orig) + CurrentJniStringSuffix();
281 const char* method_name = method_name_str.c_str();
282
283 CompileForTest(class_loader, direct, method_name, method_sig);
284 }
285
SetUpForTest(bool direct,const char * method_name_orig,const char * method_sig,void * native_fnptr)286 void SetUpForTest(bool direct,
287 const char* method_name_orig,
288 const char* method_sig,
289 void* native_fnptr) {
290 // Append the JNI kind to the method name, so that we automatically get the
291 // fast or critical versions of the same method.
292 std::string method_name_str = std::string(method_name_orig) + CurrentJniStringSuffix();
293 const char* method_name = method_name_str.c_str();
294
295 // Initialize class loader and compile method when runtime not started.
296 if (!runtime_->IsStarted()) {
297 {
298 ScopedObjectAccess soa(Thread::Current());
299 class_loader_ = LoadDex("MyClassNatives");
300 }
301 CompileForTest(class_loader_, direct, method_name, method_sig);
302 // Start runtime.
303 Thread::Current()->TransitionFromSuspendedToRunnable();
304 android::InitializeNativeLoader();
305 bool started = runtime_->Start();
306 CHECK(started);
307 }
308 // JNI operations after runtime start.
309 env_ = Thread::Current()->GetJniEnv();
310 jklass_ = env_->FindClass("MyClassNatives");
311 ASSERT_TRUE(jklass_ != nullptr) << method_name << " " << method_sig;
312
313 if (direct) {
314 jmethod_ = env_->GetStaticMethodID(jklass_, method_name, method_sig);
315 } else {
316 jmethod_ = env_->GetMethodID(jklass_, method_name, method_sig);
317 }
318 ASSERT_TRUE(jmethod_ != nullptr) << method_name << " " << method_sig;
319
320 // Make sure the test class is visibly initialized so that the RegisterNatives() below
321 // sets the JNI entrypoint rather than leaving it as null (this test pretends to be an
322 // AOT compiler and therefore the ClassLinker skips entrypoint initialization). Even
323 // if the ClassLinker initialized it with a stub, we would not want to test that here.
324 class_linker_->MakeInitializedClassesVisiblyInitialized(Thread::Current(), /*wait=*/ true);
325
326 if (native_fnptr != nullptr) {
327 JNINativeMethod methods[] = { { method_name, method_sig, native_fnptr } };
328 ASSERT_EQ(JNI_OK, env_->RegisterNatives(jklass_, methods, 1))
329 << method_name << " " << method_sig;
330 } else {
331 env_->UnregisterNatives(jklass_);
332 }
333
334 jmethodID constructor = env_->GetMethodID(jklass_, "<init>", "()V");
335 jobj_ = env_->NewObject(jklass_, constructor);
336 ASSERT_TRUE(jobj_ != nullptr) << method_name << " " << method_sig;
337 }
338
339 public:
340 // Available as statics so our JNI handlers can access these.
341 static jclass jklass_;
342 static jobject jobj_;
343 static jobject class_loader_;
344
345 static void AssertCallerObjectLocked(JNIEnv* env);
346
347 static LockWord GetLockWord(jobject obj);
348
349 protected:
350 // We have to list the methods here so we can share them between default and generic JNI.
351 void CompileAndRunNoArgMethodImpl();
352 void CompileAndRunIntMethodThroughStubImpl();
353 void CompileAndRunStaticIntMethodThroughStubImpl();
354 void CompileAndRunIntMethodImpl();
355 void CompileAndRunIntIntMethodImpl();
356 void CompileAndRunLongLongMethodImpl();
357 void CompileAndRunDoubleDoubleMethodImpl();
358 void CompileAndRun_fooJJ_synchronizedImpl();
359 void CompileAndRunIntObjectObjectMethodImpl();
360 void CompileAndRunStaticIntIntMethodImpl();
361 void CompileAndRunStaticDoubleDoubleMethodImpl();
362 void RunStaticLogDoubleMethodImpl();
363 void RunStaticLogFloatMethodImpl();
364 void RunStaticReturnTrueImpl();
365 void RunStaticReturnFalseImpl();
366 void RunGenericStaticReturnIntImpl();
367 void RunGenericStaticReturnDoubleImpl();
368 void RunGenericStaticReturnLongImpl();
369 void CompileAndRunStaticIntObjectObjectMethodImpl();
370 void CompileAndRunStaticSynchronizedIntObjectObjectMethodImpl();
371 void ExceptionHandlingImpl();
372 void NativeStackTraceElementImpl();
373 void ReturnGlobalRefImpl();
374 void LocalReferenceTableClearingTestImpl();
375 void JavaLangSystemArrayCopyImpl();
376 void CompareAndSwapIntImpl();
377 void GetTextImpl();
378 void GetSinkPropertiesNativeImpl();
379 void UpcallReturnTypeChecking_InstanceImpl();
380 void UpcallReturnTypeChecking_StaticImpl();
381 void UpcallArgumentTypeChecking_InstanceImpl();
382 void UpcallArgumentTypeChecking_StaticImpl();
383 void CompileAndRunFloatFloatMethodImpl();
384 void CheckParameterAlignImpl();
385 void MaxParamNumberImpl();
386 void WithoutImplementationImpl();
387 void WithoutImplementationRefReturnImpl();
388 void StaticWithoutImplementationImpl();
389 void StackArgsIntsFirstImpl();
390 void StackArgsFloatsFirstImpl();
391 void StackArgsMixedImpl();
392
393 void NormalNativeImpl();
394 void FastNativeImpl();
395 void CriticalNativeImpl();
396
397 JNIEnv* env_;
398 jmethodID jmethod_;
399
400 private:
401 bool check_generic_jni_;
402 };
403
404 jclass JniCompilerTest::jklass_;
405 jobject JniCompilerTest::jobj_;
406 jobject JniCompilerTest::class_loader_;
407
AssertCallerObjectLocked(JNIEnv * env)408 void JniCompilerTest::AssertCallerObjectLocked(JNIEnv* env) {
409 Thread* self = Thread::ForEnv(env);
410 CHECK_EQ(self, Thread::Current());
411 ScopedObjectAccess soa(self);
412 ArtMethod** caller_frame = self->GetManagedStack()->GetTopQuickFrame();
413 CHECK(caller_frame != nullptr);
414 ArtMethod* caller = *caller_frame;
415 CHECK(caller != nullptr);
416 CHECK(caller->IsNative());
417 CHECK(!caller->IsFastNative());
418 CHECK(!caller->IsCriticalNative());
419 CHECK(caller->IsSynchronized());
420 ObjPtr<mirror::Object> lock;
421 if (self->GetManagedStack()->GetTopQuickFrameGenericJniTag()) {
422 // Generic JNI.
423 lock = GetGenericJniSynchronizationObject(self, caller);
424 } else if (caller->IsStatic()) {
425 lock = caller->GetDeclaringClass();
426 } else {
427 uint8_t* sp = reinterpret_cast<uint8_t*>(caller_frame);
428 const void* code_ptr = EntryPointToCodePointer(caller->GetEntryPointFromQuickCompiledCode());
429 OatQuickMethodHeader* method_header = OatQuickMethodHeader::FromCodePointer(code_ptr);
430 size_t frame_size = method_header->GetFrameSizeInBytes();
431 StackReference<mirror::Object>* this_ref = reinterpret_cast<StackReference<mirror::Object>*>(
432 sp + frame_size + static_cast<size_t>(kRuntimePointerSize));
433 lock = this_ref->AsMirrorPtr();
434 }
435 CHECK_EQ(Monitor::GetLockOwnerThreadId(lock), self->GetThreadId());
436 }
437
GetLockWord(jobject obj)438 LockWord JniCompilerTest::GetLockWord(jobject obj) {
439 ScopedObjectAccess soa(Thread::Current());
440 return soa.Decode<mirror::Object>(obj)->GetLockWord(/*as_volatile=*/ false);
441 }
442
443 // Test the normal compiler and normal generic JNI only.
444 // The following features are unsupported in @FastNative:
445 // 1) synchronized keyword
446 # define JNI_TEST_NORMAL_ONLY(TestName) \
447 TEST_F(JniCompilerTest, TestName ## NormalCompiler) { \
448 ScopedCheckHandleScope top_handle_scope_check; \
449 SCOPED_TRACE("Normal JNI with compiler"); \
450 gCurrentJni = static_cast<uint32_t>(JniKind::kNormal); \
451 TestName ## Impl(); \
452 } \
453 TEST_F(JniCompilerTest, TestName ## NormalGeneric) { \
454 ScopedCheckHandleScope top_handle_scope_check; \
455 SCOPED_TRACE("Normal JNI with generic"); \
456 gCurrentJni = static_cast<uint32_t>(JniKind::kNormal); \
457 SetCheckGenericJni(true); \
458 TestName ## Impl(); \
459 }
460
461 // Test (normal, @FastNative) x (compiler, generic).
462 #define JNI_TEST(TestName) \
463 JNI_TEST_NORMAL_ONLY(TestName) \
464 TEST_F(JniCompilerTest, TestName ## FastCompiler) { \
465 ScopedCheckHandleScope top_handle_scope_check; \
466 SCOPED_TRACE("@FastNative JNI with compiler"); \
467 gCurrentJni = static_cast<uint32_t>(JniKind::kFast); \
468 TestName ## Impl(); \
469 } \
470 \
471 TEST_F(JniCompilerTest, TestName ## FastGeneric) { \
472 ScopedCheckHandleScope top_handle_scope_check; \
473 SCOPED_TRACE("@FastNative JNI with generic"); \
474 gCurrentJni = static_cast<uint32_t>(JniKind::kFast); \
475 SetCheckGenericJni(true); \
476 TestName ## Impl(); \
477 }
478
479 // Test (@CriticalNative) x (compiler, generic) only.
480 #define JNI_TEST_CRITICAL_ONLY(TestName) \
481 TEST_F(JniCompilerTest, TestName ## CriticalCompiler) { \
482 ScopedCheckHandleScope top_handle_scope_check; \
483 SCOPED_TRACE("@CriticalNative JNI with compiler"); \
484 gCurrentJni = static_cast<uint32_t>(JniKind::kCritical); \
485 TestName ## Impl(); \
486 } \
487 TEST_F(JniCompilerTest, TestName ## CriticalGeneric) { \
488 ScopedCheckHandleScope top_handle_scope_check; \
489 SCOPED_TRACE("@CriticalNative JNI with generic"); \
490 gCurrentJni = static_cast<uint32_t>(JniKind::kCritical); \
491 SetCheckGenericJni(true); \
492 TestName ## Impl(); \
493 }
494
495 // Test everything: (normal, @FastNative, @CriticalNative) x (compiler, generic).
496 #define JNI_TEST_CRITICAL(TestName) \
497 JNI_TEST(TestName) \
498 JNI_TEST_CRITICAL_ONLY(TestName) \
499
expectValidThreadState()500 static void expectValidThreadState() {
501 // Normal JNI always transitions to "Native". Other JNIs stay in the "Runnable" state.
502 if (IsCurrentJniNormal()) {
503 EXPECT_EQ(ThreadState::kNative, Thread::Current()->GetState());
504 } else {
505 EXPECT_EQ(ThreadState::kRunnable, Thread::Current()->GetState());
506 }
507 }
508
509 #define EXPECT_THREAD_STATE_FOR_CURRENT_JNI() expectValidThreadState()
510
expectValidMutatorLockHeld()511 static void expectValidMutatorLockHeld() {
512 if (IsCurrentJniNormal()) {
513 Locks::mutator_lock_->AssertNotHeld(Thread::Current());
514 } else {
515 Locks::mutator_lock_->AssertSharedHeld(Thread::Current());
516 }
517 }
518
519 #define EXPECT_MUTATOR_LOCK_FOR_CURRENT_JNI() expectValidMutatorLockHeld()
520
expectValidJniEnvAndObject(JNIEnv * env,jobject thisObj)521 static void expectValidJniEnvAndObject(JNIEnv* env, jobject thisObj) {
522 if (!IsCurrentJniCritical()) {
523 EXPECT_EQ(Thread::Current()->GetJniEnv(), env);
524 ASSERT_TRUE(thisObj != nullptr);
525 EXPECT_TRUE(env->IsInstanceOf(thisObj, JniCompilerTest::jklass_));
526 } else {
527 LOG(FATAL) << "Objects are not supported for @CriticalNative, why is this being tested?";
528 UNREACHABLE();
529 }
530 }
531
532 // Validates the JNIEnv to be the same as the current thread's JNIEnv, and makes sure
533 // that the object here is an instance of the class we registered the method with.
534 //
535 // Hard-fails if this somehow gets invoked for @CriticalNative since objects are unsupported.
536 #define EXPECT_JNI_ENV_AND_OBJECT_FOR_CURRENT_JNI(env, thisObj) \
537 expectValidJniEnvAndObject(env, thisObj)
538
expectValidJniEnvAndClass(JNIEnv * env,jclass kls)539 static void expectValidJniEnvAndClass(JNIEnv* env, jclass kls) {
540 if (!IsCurrentJniCritical()) {
541 EXPECT_EQ(Thread::Current()->GetJniEnv(), env);
542 ASSERT_TRUE(kls != nullptr);
543 EXPECT_TRUE(env->IsSameObject(static_cast<jobject>(JniCompilerTest::jklass_),
544 static_cast<jobject>(kls)));
545 } else {
546 // This is pretty much vacuously true but catch any testing setup mistakes.
547 EXPECT_EQ(env, kCriticalFakeJniEnv);
548 EXPECT_EQ(kls, kCriticalFakeJniClass);
549 }
550 }
551
552 // Validates the JNIEnv is the same as the current thread's JNIenv, and makes sure
553 // that the jclass we got in the JNI handler is the same one as the class the method was looked
554 // up for.
555 //
556 // (Checks are skipped for @CriticalNative since the two values are fake).
557 #define EXPECT_JNI_ENV_AND_CLASS_FOR_CURRENT_JNI(env, kls) expectValidJniEnvAndClass(env, kls)
558
559 // Temporarily disable the EXPECT_NUM_STACK_REFERENCES check (for a single test).
560 struct ScopedDisableCheckNumStackReferences {
ScopedDisableCheckNumStackReferencesart::ScopedDisableCheckNumStackReferences561 ScopedDisableCheckNumStackReferences() {
562 CHECK(sCheckNumStackReferences); // No nested support.
563 sCheckNumStackReferences = false;
564 }
565
~ScopedDisableCheckNumStackReferencesart::ScopedDisableCheckNumStackReferences566 ~ScopedDisableCheckNumStackReferences() {
567 sCheckNumStackReferences = true;
568 }
569
570 static bool sCheckNumStackReferences;
571 };
572
573 bool ScopedDisableCheckNumStackReferences::sCheckNumStackReferences = true;
574
575 // Check that the handle scope at the start of this block is the same
576 // as the handle scope at the end of the block.
577 struct ScopedCheckHandleScope {
ScopedCheckHandleScopeart::ScopedCheckHandleScope578 ScopedCheckHandleScope() : handle_scope_(Thread::Current()->GetTopHandleScope()) {
579 }
580
~ScopedCheckHandleScopeart::ScopedCheckHandleScope581 ~ScopedCheckHandleScope() {
582 EXPECT_EQ(handle_scope_, Thread::Current()->GetTopHandleScope())
583 << "Top-most handle scope must be the same after all the JNI "
584 << "invocations have finished (as before they were invoked).";
585 }
586
587 BaseHandleScope* const handle_scope_;
588 };
589
590 class CountReferencesVisitor : public RootVisitor {
591 public:
VisitRoots(mirror::Object *** roots,size_t count,const RootInfo & info)592 void VisitRoots([[maybe_unused]] mirror::Object*** roots,
593 size_t count,
594 const RootInfo& info) override REQUIRES_SHARED(Locks::mutator_lock_) {
595 if (info.GetType() == art::RootType::kRootJavaFrame) {
596 const JavaFrameRootInfo& jrfi = static_cast<const JavaFrameRootInfo&>(info);
597 if (jrfi.GetVReg() == JavaFrameRootInfo::kNativeReferenceArgument) {
598 DCHECK_EQ(count, 1u);
599 num_references_ += count;
600 }
601 }
602 }
603
VisitRoots(mirror::CompressedReference<mirror::Object> ** roots,size_t count,const RootInfo & info)604 void VisitRoots([[maybe_unused]] mirror::CompressedReference<mirror::Object>** roots,
605 [[maybe_unused]] size_t count,
606 const RootInfo& info) override REQUIRES_SHARED(Locks::mutator_lock_) {
607 CHECK_NE(info.GetType(), art::RootType::kRootJavaFrame);
608 }
609
NumReferences() const610 size_t NumReferences() const {
611 return num_references_;
612 }
613
614 private:
615 size_t num_references_ = 0u;
616 };
617
618 // Number of references allocated in handle scopes & JNI shadow frames on this thread.
NumStackReferences(Thread * self)619 static size_t NumStackReferences(Thread* self) REQUIRES_SHARED(Locks::mutator_lock_) {
620 CountReferencesVisitor visitor;
621 self->VisitRoots(&visitor, kVisitRootFlagAllRoots);
622 return visitor.NumReferences();
623 }
624
expectNumStackReferences(size_t expected)625 static void expectNumStackReferences(size_t expected) {
626 // In rare cases when JNI functions call themselves recursively,
627 // disable this test because it will have a false negative.
628 if (!IsCurrentJniCritical() && ScopedDisableCheckNumStackReferences::sCheckNumStackReferences) {
629 /* @CriticalNative doesn't build a HandleScope, so this test is meaningless then. */
630 ScopedObjectAccess soa(Thread::Current());
631
632 size_t num_references = NumStackReferences(Thread::Current());
633 EXPECT_EQ(expected, num_references);
634 }
635 }
636
637 #define EXPECT_NUM_STACK_REFERENCES(expected) expectNumStackReferences(expected)
638
639 template <typename T, T* fn>
640 struct make_jni_test_decorator;
641
642 // Decorator for "static" JNI callbacks.
643 template <typename R, typename ... Args, R (*fn)(JNIEnv*, jclass, Args...)>
644 struct make_jni_test_decorator<R(JNIEnv*, jclass kls, Args...), fn> {
applyart::make_jni_test_decorator645 static R apply(JNIEnv* env, jclass kls, Args ... args) {
646 EXPECT_THREAD_STATE_FOR_CURRENT_JNI();
647 EXPECT_MUTATOR_LOCK_FOR_CURRENT_JNI();
648 EXPECT_JNI_ENV_AND_CLASS_FOR_CURRENT_JNI(env, kls);
649 // All incoming parameters get spilled into the JNI transition frame.
650 // The `jclass` is just a reference to the method's declaring class field.
651 EXPECT_NUM_STACK_REFERENCES(count_nonnull_refs(args...));
652
653 return fn(env, kls, args...);
654 }
655 };
656
657 // Decorator for instance JNI callbacks.
658 template <typename R, typename ... Args, R (*fn)(JNIEnv*, jobject, Args...)>
659 struct make_jni_test_decorator<R(JNIEnv*, jobject, Args...), fn> {
applyart::make_jni_test_decorator660 static R apply(JNIEnv* env, jobject thisObj, Args ... args) {
661 EXPECT_THREAD_STATE_FOR_CURRENT_JNI();
662 EXPECT_MUTATOR_LOCK_FOR_CURRENT_JNI();
663 EXPECT_JNI_ENV_AND_OBJECT_FOR_CURRENT_JNI(env, thisObj);
664 // All incoming parameters + the implicit 'this' get spilled into the JNI transition frame.
665 EXPECT_NUM_STACK_REFERENCES(count_nonnull_refs(thisObj, args...));
666
667 return fn(env, thisObj, args...);
668 }
669 };
670
671 // Decorate the regular JNI callee with the extra gtest checks.
672 // This way we can have common test logic for everything generic like checking if a lock is held,
673 // checking handle scope state, etc.
674 #define MAKE_JNI_TEST_DECORATOR(fn) make_jni_test_decorator<decltype(fn), (fn)>::apply
675
676 // Convert function f(JNIEnv*,jclass,a,b,c,d...) into f2(a,b,c,d...)
677 // -- This way we don't have to write out each implementation twice for @CriticalNative.
678 #define JNI_CRITICAL_WRAPPER(func) jni_remove_extra_parameters<decltype(func), (func)>::apply
679 // Get a function pointer whose calling convention either matches a regular native
680 // or a critical native depending on which kind of jni is currently under test.
681 // -- This also has the benefit of genering a compile time error if the 'func' doesn't properly
682 // have JNIEnv and jclass parameters first.
683 #define CURRENT_JNI_WRAPPER(func) \
684 (IsCurrentJniCritical() \
685 ? reinterpret_cast<void*>(&JNI_CRITICAL_WRAPPER(MAKE_JNI_TEST_DECORATOR(func))) \
686 : reinterpret_cast<void*>(&MAKE_JNI_TEST_DECORATOR(func)))
687
688 // Do the opposite of the above. Do *not* wrap the function, instead just cast it to a void*.
689 // Only for "TEST_JNI_NORMAL_ONLY" configs, and it inserts a test assert to ensure this is the case.
690 #define NORMAL_JNI_ONLY_NOWRAP(func) \
691 ({ ASSERT_TRUE(IsCurrentJniNormal()); reinterpret_cast<void*>(&(func)); })
692 // Same as above, but with nullptr. When we want to test the stub functionality.
693 #define NORMAL_OR_FAST_JNI_ONLY_NULLPTR \
694 ({ ASSERT_TRUE(IsCurrentJniNormal() || IsCurrentJniFast()); nullptr; })
695
696
697 int gJava_MyClassNatives_foo_calls[kJniKindCount] = {};
Java_MyClassNatives_foo(JNIEnv *,jobject)698 void Java_MyClassNatives_foo(JNIEnv*, jobject) {
699 gJava_MyClassNatives_foo_calls[gCurrentJni]++;
700 }
701
CompileAndRunNoArgMethodImpl()702 void JniCompilerTest::CompileAndRunNoArgMethodImpl() {
703 SetUpForTest(false, "foo", "()V", CURRENT_JNI_WRAPPER(Java_MyClassNatives_foo));
704
705 EXPECT_EQ(0, gJava_MyClassNatives_foo_calls[gCurrentJni]);
706 env_->CallNonvirtualVoidMethod(jobj_, jklass_, jmethod_);
707 EXPECT_EQ(1, gJava_MyClassNatives_foo_calls[gCurrentJni]);
708 env_->CallNonvirtualVoidMethod(jobj_, jklass_, jmethod_);
709 EXPECT_EQ(2, gJava_MyClassNatives_foo_calls[gCurrentJni]);
710
711 gJava_MyClassNatives_foo_calls[gCurrentJni] = 0;
712 }
713
JNI_TEST(CompileAndRunNoArgMethod)714 JNI_TEST(CompileAndRunNoArgMethod)
715
716 void JniCompilerTest::CompileAndRunIntMethodThroughStubImpl() {
717 SetUpForTest(false, "bar", "(I)I", NORMAL_OR_FAST_JNI_ONLY_NULLPTR);
718 // calling through stub will link with &Java_MyClassNatives_bar{,_1Fast}
719
720 std::string reason;
721 ASSERT_TRUE(Runtime::Current()->GetJavaVM()->
722 LoadNativeLibrary(env_, "", class_loader_, nullptr, &reason))
723 << reason;
724
725 jint result = env_->CallNonvirtualIntMethod(jobj_, jklass_, jmethod_, 24);
726 EXPECT_EQ(25, result);
727 }
728
729 // Note: @CriticalNative is only for static methods.
JNI_TEST(CompileAndRunIntMethodThroughStub)730 JNI_TEST(CompileAndRunIntMethodThroughStub)
731
732 void JniCompilerTest::CompileAndRunStaticIntMethodThroughStubImpl() {
733 SetUpForTest(true, "sbar", "(I)I", nullptr);
734 // calling through stub will link with &Java_MyClassNatives_sbar{,_1Fast,_1Critical}
735
736 std::string reason;
737 ASSERT_TRUE(Runtime::Current()->GetJavaVM()->
738 LoadNativeLibrary(env_, "", class_loader_, nullptr, &reason))
739 << reason;
740
741 jint result = env_->CallStaticIntMethod(jklass_, jmethod_, 42);
742 EXPECT_EQ(43, result);
743 }
744
745 JNI_TEST_CRITICAL(CompileAndRunStaticIntMethodThroughStub)
746
747 int gJava_MyClassNatives_fooI_calls[kJniKindCount] = {};
Java_MyClassNatives_fooI(JNIEnv *,jobject,jint x)748 jint Java_MyClassNatives_fooI(JNIEnv*, jobject, jint x) {
749 gJava_MyClassNatives_fooI_calls[gCurrentJni]++;
750 return x;
751 }
752
CompileAndRunIntMethodImpl()753 void JniCompilerTest::CompileAndRunIntMethodImpl() {
754 SetUpForTest(false, "fooI", "(I)I",
755 CURRENT_JNI_WRAPPER(Java_MyClassNatives_fooI));
756
757 EXPECT_EQ(0, gJava_MyClassNatives_fooI_calls[gCurrentJni]);
758 jint result = env_->CallNonvirtualIntMethod(jobj_, jklass_, jmethod_, 42);
759 EXPECT_EQ(42, result);
760 EXPECT_EQ(1, gJava_MyClassNatives_fooI_calls[gCurrentJni]);
761 result = env_->CallNonvirtualIntMethod(jobj_, jklass_, jmethod_, 0xCAFED00D);
762 EXPECT_EQ(static_cast<jint>(0xCAFED00D), result);
763 EXPECT_EQ(2, gJava_MyClassNatives_fooI_calls[gCurrentJni]);
764
765 gJava_MyClassNatives_fooI_calls[gCurrentJni] = 0;
766 }
767
768 JNI_TEST(CompileAndRunIntMethod)
769
770 int gJava_MyClassNatives_fooII_calls[kJniKindCount] = {};
Java_MyClassNatives_fooII(JNIEnv *,jobject,jint x,jint y)771 jint Java_MyClassNatives_fooII(JNIEnv*, jobject, jint x, jint y) {
772 gJava_MyClassNatives_fooII_calls[gCurrentJni]++;
773 return x - y; // non-commutative operator
774 }
775
CompileAndRunIntIntMethodImpl()776 void JniCompilerTest::CompileAndRunIntIntMethodImpl() {
777 SetUpForTest(false, "fooII", "(II)I",
778 CURRENT_JNI_WRAPPER(Java_MyClassNatives_fooII));
779
780 EXPECT_EQ(0, gJava_MyClassNatives_fooII_calls[gCurrentJni]);
781 jint result = env_->CallNonvirtualIntMethod(jobj_, jklass_, jmethod_, 99, 10);
782 EXPECT_EQ(99 - 10, result);
783 EXPECT_EQ(1, gJava_MyClassNatives_fooII_calls[gCurrentJni]);
784 result = env_->CallNonvirtualIntMethod(jobj_, jklass_, jmethod_, 0xCAFEBABE,
785 0xCAFED00D);
786 EXPECT_EQ(static_cast<jint>(0xCAFEBABE - 0xCAFED00D), result);
787 EXPECT_EQ(2, gJava_MyClassNatives_fooII_calls[gCurrentJni]);
788
789 gJava_MyClassNatives_fooII_calls[gCurrentJni] = 0;
790 }
791
792 JNI_TEST(CompileAndRunIntIntMethod)
793
794 int gJava_MyClassNatives_fooJJ_calls[kJniKindCount] = {};
Java_MyClassNatives_fooJJ(JNIEnv *,jobject,jlong x,jlong y)795 jlong Java_MyClassNatives_fooJJ(JNIEnv*, jobject, jlong x, jlong y) {
796 gJava_MyClassNatives_fooJJ_calls[gCurrentJni]++;
797 return x - y; // non-commutative operator
798 }
799
CompileAndRunLongLongMethodImpl()800 void JniCompilerTest::CompileAndRunLongLongMethodImpl() {
801 SetUpForTest(false, "fooJJ", "(JJ)J",
802 CURRENT_JNI_WRAPPER(Java_MyClassNatives_fooJJ));
803
804 EXPECT_EQ(0, gJava_MyClassNatives_fooJJ_calls[gCurrentJni]);
805 jlong a = INT64_C(0x1234567890ABCDEF);
806 jlong b = INT64_C(0xFEDCBA0987654321);
807 jlong result = env_->CallNonvirtualLongMethod(jobj_, jklass_, jmethod_, a, b);
808 EXPECT_EQ(a - b, result);
809 EXPECT_EQ(1, gJava_MyClassNatives_fooJJ_calls[gCurrentJni]);
810 result = env_->CallNonvirtualLongMethod(jobj_, jklass_, jmethod_, b, a);
811 EXPECT_EQ(b - a, result);
812 EXPECT_EQ(2, gJava_MyClassNatives_fooJJ_calls[gCurrentJni]);
813
814 gJava_MyClassNatives_fooJJ_calls[gCurrentJni] = 0;
815 }
816
817 JNI_TEST(CompileAndRunLongLongMethod)
818
819 int gJava_MyClassNatives_fooDD_calls[kJniKindCount] = {};
Java_MyClassNatives_fooDD(JNIEnv *,jobject,jdouble x,jdouble y)820 jdouble Java_MyClassNatives_fooDD(JNIEnv*, jobject, jdouble x, jdouble y) {
821 gJava_MyClassNatives_fooDD_calls[gCurrentJni]++;
822 return x - y; // non-commutative operator
823 }
824
CompileAndRunDoubleDoubleMethodImpl()825 void JniCompilerTest::CompileAndRunDoubleDoubleMethodImpl() {
826 SetUpForTest(false, "fooDD", "(DD)D",
827 CURRENT_JNI_WRAPPER(Java_MyClassNatives_fooDD));
828
829 EXPECT_EQ(0, gJava_MyClassNatives_fooDD_calls[gCurrentJni]);
830 jdouble result = env_->CallNonvirtualDoubleMethod(jobj_, jklass_, jmethod_,
831 99.0, 10.0);
832 EXPECT_DOUBLE_EQ(99.0 - 10.0, result);
833 EXPECT_EQ(1, gJava_MyClassNatives_fooDD_calls[gCurrentJni]);
834 jdouble a = 3.14159265358979323846;
835 jdouble b = 0.69314718055994530942;
836 result = env_->CallNonvirtualDoubleMethod(jobj_, jklass_, jmethod_, a, b);
837 EXPECT_DOUBLE_EQ(a - b, result);
838 EXPECT_EQ(2, gJava_MyClassNatives_fooDD_calls[gCurrentJni]);
839
840 gJava_MyClassNatives_fooDD_calls[gCurrentJni] = 0;
841 }
842
843 int gJava_MyClassNatives_fooJJ_synchronized_calls[kJniKindCount] = {};
Java_MyClassNatives_fooJJ_synchronized(JNIEnv * env,jobject,jlong x,jlong y)844 jlong Java_MyClassNatives_fooJJ_synchronized(JNIEnv* env, jobject, jlong x, jlong y) {
845 JniCompilerTest::AssertCallerObjectLocked(env);
846 gJava_MyClassNatives_fooJJ_synchronized_calls[gCurrentJni]++;
847 return x | y;
848 }
849
850 EXPORT // Defined in `libart.so`.
851 void InitEntryPoints(JniEntryPoints* jpoints,
852 QuickEntryPoints* qpoints,
853 bool monitor_jni_entry_exit);
854
CompileAndRun_fooJJ_synchronizedImpl()855 void JniCompilerTest::CompileAndRun_fooJJ_synchronizedImpl() {
856 SetUpForTest(false, "fooJJ_synchronized", "(JJ)J",
857 CURRENT_JNI_WRAPPER(Java_MyClassNatives_fooJJ_synchronized));
858
859 EXPECT_EQ(0, gJava_MyClassNatives_fooJJ_synchronized_calls[gCurrentJni]);
860 jlong a = 0x1000000020000000ULL;
861 jlong b = 0x00ff000000aa0000ULL;
862 jlong result = env_->CallNonvirtualLongMethod(jobj_, jklass_, jmethod_, a, b);
863 EXPECT_EQ(a | b, result);
864 EXPECT_EQ(1, gJava_MyClassNatives_fooJJ_synchronized_calls[gCurrentJni]);
865
866 // Exercise recursive thin locking/unlocking.
867 // Note: Thin lock count 0 means locked once.
868 env_->MonitorEnter(jobj_);
869 LockWord lock_word = GetLockWord(jobj_);
870 ASSERT_EQ(lock_word.GetState(), LockWord::kThinLocked);
871 ASSERT_EQ(lock_word.ThinLockCount(), 0u);
872 result = env_->CallNonvirtualLongMethod(jobj_, jklass_, jmethod_, a, b);
873 EXPECT_EQ(a | b, result);
874 EXPECT_EQ(2, gJava_MyClassNatives_fooJJ_synchronized_calls[gCurrentJni]);
875 lock_word = GetLockWord(jobj_);
876 ASSERT_EQ(lock_word.GetState(), LockWord::kThinLocked);
877 ASSERT_EQ(lock_word.ThinLockCount(), 0u);
878 env_->MonitorExit(jobj_);
879 lock_word = GetLockWord(jobj_);
880 ASSERT_EQ(lock_word.GetState(), LockWord::kUnlocked);
881
882 // Exercise lock inflation due to thin lock count overflow.
883 constexpr uint32_t kMaxThinLockRecursiveLocks = 1u << LockWord::kThinLockCountSize;
884 for (uint32_t i = 0; i != kMaxThinLockRecursiveLocks; ++i) {
885 env_->MonitorEnter(jobj_);
886 lock_word = GetLockWord(jobj_);
887 ASSERT_EQ(lock_word.GetState(), LockWord::kThinLocked);
888 ASSERT_EQ(lock_word.ThinLockCount(), i);
889 }
890 result = env_->CallNonvirtualLongMethod(jobj_, jklass_, jmethod_, a, b);
891 EXPECT_EQ(a | b, result);
892 EXPECT_EQ(3, gJava_MyClassNatives_fooJJ_synchronized_calls[gCurrentJni]);
893 lock_word = GetLockWord(jobj_);
894 ASSERT_EQ(lock_word.GetState(), LockWord::kFatLocked);
895 for (uint32_t i = 0; i != kMaxThinLockRecursiveLocks; ++i) {
896 env_->MonitorExit(jobj_); // Remains "fat-locked" even if actually unlocked.
897 }
898
899 // Exercise locking for "fat-locked".
900 lock_word = GetLockWord(jobj_);
901 ASSERT_EQ(lock_word.GetState(), LockWord::kFatLocked);
902 result = env_->CallNonvirtualLongMethod(jobj_, jklass_, jmethod_, a, b);
903 EXPECT_EQ(a | b, result);
904 EXPECT_EQ(4, gJava_MyClassNatives_fooJJ_synchronized_calls[gCurrentJni]);
905 lock_word = GetLockWord(jobj_);
906 ASSERT_EQ(lock_word.GetState(), LockWord::kFatLocked);
907
908 // Exercise locking/unocking for "fat-locked" through the "no_inline" path.
909 // These entrypoints are selected with verbose "systrace_lock_logging".
910 Thread* self = Thread::Current();
911 ASSERT_FALSE(gLogVerbosity.systrace_lock_logging);
912 gLogVerbosity.systrace_lock_logging = true;
913 InitEntryPoints(&self->tlsPtr_.jni_entrypoints,
914 &self->tlsPtr_.quick_entrypoints,
915 self->ReadFlag(ThreadFlag::kMonitorJniEntryExit));
916 result = env_->CallNonvirtualLongMethod(jobj_, jklass_, jmethod_, a, b);
917 EXPECT_EQ(a | b, result);
918 EXPECT_EQ(5, gJava_MyClassNatives_fooJJ_synchronized_calls[gCurrentJni]);
919 gLogVerbosity.systrace_lock_logging = false;
920 InitEntryPoints(&self->tlsPtr_.jni_entrypoints,
921 &self->tlsPtr_.quick_entrypoints,
922 self->ReadFlag(ThreadFlag::kMonitorJniEntryExit));
923
924 gJava_MyClassNatives_fooJJ_synchronized_calls[gCurrentJni] = 0;
925 }
926
927 JNI_TEST_NORMAL_ONLY(CompileAndRun_fooJJ_synchronized)
928
929 int gJava_MyClassNatives_fooIOO_calls[kJniKindCount] = {};
Java_MyClassNatives_fooIOO(JNIEnv *,jobject thisObj,jint x,jobject y,jobject z)930 jobject Java_MyClassNatives_fooIOO(JNIEnv*, jobject thisObj, jint x, jobject y,
931 jobject z) {
932 gJava_MyClassNatives_fooIOO_calls[gCurrentJni]++;
933 switch (x) {
934 case 1:
935 return y;
936 case 2:
937 return z;
938 default:
939 return thisObj;
940 }
941 }
942
CompileAndRunIntObjectObjectMethodImpl()943 void JniCompilerTest::CompileAndRunIntObjectObjectMethodImpl() {
944 SetUpForTest(false, "fooIOO",
945 "(ILjava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
946 CURRENT_JNI_WRAPPER(Java_MyClassNatives_fooIOO));
947
948 EXPECT_EQ(0, gJava_MyClassNatives_fooIOO_calls[gCurrentJni]);
949 jobject result = env_->CallNonvirtualObjectMethod(jobj_, jklass_, jmethod_, 0, nullptr, nullptr);
950 EXPECT_TRUE(env_->IsSameObject(jobj_, result));
951 EXPECT_EQ(1, gJava_MyClassNatives_fooIOO_calls[gCurrentJni]);
952
953 result = env_->CallNonvirtualObjectMethod(jobj_, jklass_, jmethod_, 0, nullptr, jklass_);
954 EXPECT_TRUE(env_->IsSameObject(jobj_, result));
955 EXPECT_EQ(2, gJava_MyClassNatives_fooIOO_calls[gCurrentJni]);
956 result = env_->CallNonvirtualObjectMethod(jobj_, jklass_, jmethod_, 1, nullptr, jklass_);
957 EXPECT_TRUE(env_->IsSameObject(nullptr, result));
958 EXPECT_EQ(3, gJava_MyClassNatives_fooIOO_calls[gCurrentJni]);
959 result = env_->CallNonvirtualObjectMethod(jobj_, jklass_, jmethod_, 2, nullptr, jklass_);
960 EXPECT_TRUE(env_->IsSameObject(jklass_, result));
961 EXPECT_EQ(4, gJava_MyClassNatives_fooIOO_calls[gCurrentJni]);
962
963 result = env_->CallNonvirtualObjectMethod(jobj_, jklass_, jmethod_, 0, jklass_, nullptr);
964 EXPECT_TRUE(env_->IsSameObject(jobj_, result));
965 EXPECT_EQ(5, gJava_MyClassNatives_fooIOO_calls[gCurrentJni]);
966 result = env_->CallNonvirtualObjectMethod(jobj_, jklass_, jmethod_, 1, jklass_, nullptr);
967 EXPECT_TRUE(env_->IsSameObject(jklass_, result));
968 EXPECT_EQ(6, gJava_MyClassNatives_fooIOO_calls[gCurrentJni]);
969 result = env_->CallNonvirtualObjectMethod(jobj_, jklass_, jmethod_, 2, jklass_, nullptr);
970 EXPECT_TRUE(env_->IsSameObject(nullptr, result));
971 EXPECT_EQ(7, gJava_MyClassNatives_fooIOO_calls[gCurrentJni]);
972
973 gJava_MyClassNatives_fooIOO_calls[gCurrentJni] = 0;
974 }
975
976 JNI_TEST(CompileAndRunIntObjectObjectMethod)
977
978 int gJava_MyClassNatives_fooSII_calls[kJniKindCount] = {};
Java_MyClassNatives_fooSII(JNIEnv * env,jclass klass,jint x,jint y)979 jint Java_MyClassNatives_fooSII([[maybe_unused]] JNIEnv* env,
980 [[maybe_unused]] jclass klass,
981 jint x,
982 jint y) {
983 gJava_MyClassNatives_fooSII_calls[gCurrentJni]++;
984 return x + y;
985 }
986
CompileAndRunStaticIntIntMethodImpl()987 void JniCompilerTest::CompileAndRunStaticIntIntMethodImpl() {
988 SetUpForTest(true, "fooSII", "(II)I",
989 CURRENT_JNI_WRAPPER(Java_MyClassNatives_fooSII));
990
991 EXPECT_EQ(0, gJava_MyClassNatives_fooSII_calls[gCurrentJni]);
992 jint result = env_->CallStaticIntMethod(jklass_, jmethod_, 20, 30);
993 EXPECT_EQ(50, result);
994 EXPECT_EQ(1, gJava_MyClassNatives_fooSII_calls[gCurrentJni]);
995
996 gJava_MyClassNatives_fooSII_calls[gCurrentJni] = 0;
997 }
998
999 JNI_TEST_CRITICAL(CompileAndRunStaticIntIntMethod)
1000
1001 int gJava_MyClassNatives_fooSDD_calls[kJniKindCount] = {};
Java_MyClassNatives_fooSDD(JNIEnv * env,jclass klass,jdouble x,jdouble y)1002 jdouble Java_MyClassNatives_fooSDD([[maybe_unused]] JNIEnv* env,
1003 [[maybe_unused]] jclass klass,
1004 jdouble x,
1005 jdouble y) {
1006 gJava_MyClassNatives_fooSDD_calls[gCurrentJni]++;
1007 return x - y; // non-commutative operator
1008 }
1009
CompileAndRunStaticDoubleDoubleMethodImpl()1010 void JniCompilerTest::CompileAndRunStaticDoubleDoubleMethodImpl() {
1011 SetUpForTest(true, "fooSDD", "(DD)D",
1012 CURRENT_JNI_WRAPPER(Java_MyClassNatives_fooSDD));
1013
1014 EXPECT_EQ(0, gJava_MyClassNatives_fooSDD_calls[gCurrentJni]);
1015 jdouble result = env_->CallStaticDoubleMethod(jklass_, jmethod_, 99.0, 10.0);
1016 EXPECT_DOUBLE_EQ(99.0 - 10.0, result);
1017 EXPECT_EQ(1, gJava_MyClassNatives_fooSDD_calls[gCurrentJni]);
1018 jdouble a = 3.14159265358979323846;
1019 jdouble b = 0.69314718055994530942;
1020 result = env_->CallStaticDoubleMethod(jklass_, jmethod_, a, b);
1021 EXPECT_DOUBLE_EQ(a - b, result);
1022 EXPECT_DOUBLE_EQ(2, gJava_MyClassNatives_fooSDD_calls[gCurrentJni]);
1023
1024 gJava_MyClassNatives_fooSDD_calls[gCurrentJni] = 0;
1025 }
1026
JNI_TEST_CRITICAL(CompileAndRunStaticDoubleDoubleMethod)1027 JNI_TEST_CRITICAL(CompileAndRunStaticDoubleDoubleMethod)
1028
1029 // The x86 generic JNI code had a bug where it assumed a floating
1030 // point return value would be in xmm0. We use log, to somehow ensure
1031 // the compiler will use the floating point stack.
1032
1033 jdouble Java_MyClassNatives_logD(JNIEnv*, jclass, jdouble x) {
1034 return log(x);
1035 }
1036
Java_MyClassNatives_logD_notNormal(JNIEnv *,jclass,jdouble x)1037 jdouble Java_MyClassNatives_logD_notNormal(JNIEnv*, jclass, jdouble x) {
1038 EXPECT_DOUBLE_EQ(2.0, x);
1039 return log(x);
1040 }
1041
RunStaticLogDoubleMethodImpl()1042 void JniCompilerTest::RunStaticLogDoubleMethodImpl() {
1043 void* jni_handler;
1044 if (IsCurrentJniNormal()) {
1045 // This test seems a bit special, don't use a JNI wrapper here.
1046 jni_handler = NORMAL_JNI_ONLY_NOWRAP(Java_MyClassNatives_logD);
1047 } else {
1048 jni_handler = CURRENT_JNI_WRAPPER(Java_MyClassNatives_logD_notNormal);
1049 }
1050 SetUpForTest(true, "logD", "(D)D", jni_handler);
1051
1052 jdouble result = env_->CallStaticDoubleMethod(jklass_, jmethod_, 2.0);
1053 EXPECT_DOUBLE_EQ(log(2.0), result);
1054 }
1055
JNI_TEST_CRITICAL(RunStaticLogDoubleMethod)1056 JNI_TEST_CRITICAL(RunStaticLogDoubleMethod)
1057
1058 jfloat Java_MyClassNatives_logF(JNIEnv*, jclass, jfloat x) {
1059 return logf(x);
1060 }
1061
RunStaticLogFloatMethodImpl()1062 void JniCompilerTest::RunStaticLogFloatMethodImpl() {
1063 void* jni_handler;
1064 if (IsCurrentJniNormal()) {
1065 // This test seems a bit special, don't use a JNI wrapper here.
1066 jni_handler = NORMAL_JNI_ONLY_NOWRAP(Java_MyClassNatives_logF);
1067 } else {
1068 jni_handler = CURRENT_JNI_WRAPPER(Java_MyClassNatives_logF);
1069 }
1070
1071 SetUpForTest(true, "logF", "(F)F", jni_handler);
1072
1073 jfloat result = env_->CallStaticFloatMethod(jklass_, jmethod_, 2.0);
1074 EXPECT_FLOAT_EQ(logf(2.0), result);
1075 }
1076
JNI_TEST_CRITICAL(RunStaticLogFloatMethod)1077 JNI_TEST_CRITICAL(RunStaticLogFloatMethod)
1078
1079 jboolean Java_MyClassNatives_returnTrue(JNIEnv*, jclass) {
1080 return JNI_TRUE;
1081 }
1082
Java_MyClassNatives_returnFalse(JNIEnv *,jclass)1083 jboolean Java_MyClassNatives_returnFalse(JNIEnv*, jclass) {
1084 return JNI_FALSE;
1085 }
1086
Java_MyClassNatives_returnInt(JNIEnv *,jclass)1087 jint Java_MyClassNatives_returnInt(JNIEnv*, jclass) {
1088 return 42;
1089 }
1090
RunStaticReturnTrueImpl()1091 void JniCompilerTest::RunStaticReturnTrueImpl() {
1092 SetUpForTest(true, "returnTrue", "()Z", CURRENT_JNI_WRAPPER(Java_MyClassNatives_returnTrue));
1093
1094 jboolean result = env_->CallStaticBooleanMethod(jklass_, jmethod_);
1095 EXPECT_TRUE(result);
1096 }
1097
JNI_TEST_CRITICAL(RunStaticReturnTrue)1098 JNI_TEST_CRITICAL(RunStaticReturnTrue)
1099
1100 void JniCompilerTest::RunStaticReturnFalseImpl() {
1101 SetUpForTest(true, "returnFalse", "()Z",
1102 CURRENT_JNI_WRAPPER(Java_MyClassNatives_returnFalse));
1103
1104 jboolean result = env_->CallStaticBooleanMethod(jklass_, jmethod_);
1105 EXPECT_FALSE(result);
1106 }
1107
JNI_TEST_CRITICAL(RunStaticReturnFalse)1108 JNI_TEST_CRITICAL(RunStaticReturnFalse)
1109
1110 void JniCompilerTest::RunGenericStaticReturnIntImpl() {
1111 SetUpForTest(true, "returnInt", "()I", CURRENT_JNI_WRAPPER(Java_MyClassNatives_returnInt));
1112
1113 jint result = env_->CallStaticIntMethod(jklass_, jmethod_);
1114 EXPECT_EQ(42, result);
1115 }
1116
1117 JNI_TEST_CRITICAL(RunGenericStaticReturnInt)
1118
1119 int gJava_MyClassNatives_returnDouble_calls[kJniKindCount] = {};
Java_MyClassNatives_returnDouble(JNIEnv *,jclass)1120 jdouble Java_MyClassNatives_returnDouble(JNIEnv*, jclass) {
1121 gJava_MyClassNatives_returnDouble_calls[gCurrentJni]++;
1122 return 4.0;
1123 }
1124
RunGenericStaticReturnDoubleImpl()1125 void JniCompilerTest::RunGenericStaticReturnDoubleImpl() {
1126 SetUpForTest(true, "returnDouble", "()D", CURRENT_JNI_WRAPPER(Java_MyClassNatives_returnDouble));
1127
1128 jdouble result = env_->CallStaticDoubleMethod(jklass_, jmethod_);
1129 EXPECT_DOUBLE_EQ(4.0, result);
1130 EXPECT_EQ(1, gJava_MyClassNatives_returnDouble_calls[gCurrentJni]);
1131
1132 gJava_MyClassNatives_returnDouble_calls[gCurrentJni] = 0;
1133 }
1134
JNI_TEST_CRITICAL(RunGenericStaticReturnDouble)1135 JNI_TEST_CRITICAL(RunGenericStaticReturnDouble)
1136
1137 jlong Java_MyClassNatives_returnLong(JNIEnv*, jclass) {
1138 return 0xFEEDDEADFEEDL;
1139 }
1140
RunGenericStaticReturnLongImpl()1141 void JniCompilerTest::RunGenericStaticReturnLongImpl() {
1142 SetUpForTest(true, "returnLong", "()J", CURRENT_JNI_WRAPPER(Java_MyClassNatives_returnLong));
1143
1144 jlong result = env_->CallStaticLongMethod(jklass_, jmethod_);
1145 EXPECT_EQ(0xFEEDDEADFEEDL, result);
1146 }
1147
1148 JNI_TEST_CRITICAL(RunGenericStaticReturnLong)
1149
1150 int gJava_MyClassNatives_fooSIOO_calls[kJniKindCount] = {};
Java_MyClassNatives_fooSIOO(JNIEnv *,jclass klass,jint x,jobject y,jobject z)1151 jobject Java_MyClassNatives_fooSIOO(JNIEnv*, jclass klass, jint x, jobject y, jobject z) {
1152 gJava_MyClassNatives_fooSIOO_calls[gCurrentJni]++;
1153 switch (x) {
1154 case 1:
1155 return y;
1156 case 2:
1157 return z;
1158 default:
1159 return klass;
1160 }
1161 }
1162
CompileAndRunStaticIntObjectObjectMethodImpl()1163 void JniCompilerTest::CompileAndRunStaticIntObjectObjectMethodImpl() {
1164 SetUpForTest(true, "fooSIOO",
1165 "(ILjava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
1166 CURRENT_JNI_WRAPPER(Java_MyClassNatives_fooSIOO));
1167
1168 EXPECT_EQ(0, gJava_MyClassNatives_fooSIOO_calls[gCurrentJni]);
1169 jobject result = env_->CallStaticObjectMethod(jklass_, jmethod_, 0, nullptr, nullptr);
1170 EXPECT_TRUE(env_->IsSameObject(jklass_, result));
1171 EXPECT_EQ(1, gJava_MyClassNatives_fooSIOO_calls[gCurrentJni]);
1172
1173 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 0, nullptr, jobj_);
1174 EXPECT_TRUE(env_->IsSameObject(jklass_, result));
1175 EXPECT_EQ(2, gJava_MyClassNatives_fooSIOO_calls[gCurrentJni]);
1176 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 1, nullptr, jobj_);
1177 EXPECT_TRUE(env_->IsSameObject(nullptr, result));
1178 EXPECT_EQ(3, gJava_MyClassNatives_fooSIOO_calls[gCurrentJni]);
1179 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 2, nullptr, jobj_);
1180 EXPECT_TRUE(env_->IsSameObject(jobj_, result));
1181 EXPECT_EQ(4, gJava_MyClassNatives_fooSIOO_calls[gCurrentJni]);
1182
1183 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 0, jobj_, nullptr);
1184 EXPECT_TRUE(env_->IsSameObject(jklass_, result));
1185 EXPECT_EQ(5, gJava_MyClassNatives_fooSIOO_calls[gCurrentJni]);
1186 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 1, jobj_, nullptr);
1187 EXPECT_TRUE(env_->IsSameObject(jobj_, result));
1188 EXPECT_EQ(6, gJava_MyClassNatives_fooSIOO_calls[gCurrentJni]);
1189 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 2, jobj_, nullptr);
1190 EXPECT_TRUE(env_->IsSameObject(nullptr, result));
1191 EXPECT_EQ(7, gJava_MyClassNatives_fooSIOO_calls[gCurrentJni]);
1192
1193 gJava_MyClassNatives_fooSIOO_calls[gCurrentJni] = 0;
1194 }
1195
1196 JNI_TEST(CompileAndRunStaticIntObjectObjectMethod)
1197
1198 int gJava_MyClassNatives_fooSSIOO_calls[kJniKindCount] = {};
Java_MyClassNatives_fooSSIOO(JNIEnv * env,jclass klass,jint x,jobject y,jobject z)1199 jobject Java_MyClassNatives_fooSSIOO(JNIEnv* env, jclass klass, jint x, jobject y, jobject z) {
1200 JniCompilerTest::AssertCallerObjectLocked(env);
1201 gJava_MyClassNatives_fooSSIOO_calls[gCurrentJni]++;
1202 switch (x) {
1203 case 1:
1204 return y;
1205 case 2:
1206 return z;
1207 default:
1208 return klass;
1209 }
1210 }
1211
CompileAndRunStaticSynchronizedIntObjectObjectMethodImpl()1212 void JniCompilerTest::CompileAndRunStaticSynchronizedIntObjectObjectMethodImpl() {
1213 SetUpForTest(true, "fooSSIOO",
1214 "(ILjava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
1215 CURRENT_JNI_WRAPPER(Java_MyClassNatives_fooSSIOO));
1216
1217 EXPECT_EQ(0, gJava_MyClassNatives_fooSSIOO_calls[gCurrentJni]);
1218 jobject result = env_->CallStaticObjectMethod(jklass_, jmethod_, 0, nullptr, nullptr);
1219 EXPECT_TRUE(env_->IsSameObject(jklass_, result));
1220 EXPECT_EQ(1, gJava_MyClassNatives_fooSSIOO_calls[gCurrentJni]);
1221
1222 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 0, nullptr, jobj_);
1223 EXPECT_TRUE(env_->IsSameObject(jklass_, result));
1224 EXPECT_EQ(2, gJava_MyClassNatives_fooSSIOO_calls[gCurrentJni]);
1225 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 1, nullptr, jobj_);
1226 EXPECT_TRUE(env_->IsSameObject(nullptr, result));
1227 EXPECT_EQ(3, gJava_MyClassNatives_fooSSIOO_calls[gCurrentJni]);
1228 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 2, nullptr, jobj_);
1229 EXPECT_TRUE(env_->IsSameObject(jobj_, result));
1230 EXPECT_EQ(4, gJava_MyClassNatives_fooSSIOO_calls[gCurrentJni]);
1231
1232 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 0, jobj_, nullptr);
1233 EXPECT_TRUE(env_->IsSameObject(jklass_, result));
1234 EXPECT_EQ(5, gJava_MyClassNatives_fooSSIOO_calls[gCurrentJni]);
1235 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 1, jobj_, nullptr);
1236 EXPECT_TRUE(env_->IsSameObject(jobj_, result));
1237 EXPECT_EQ(6, gJava_MyClassNatives_fooSSIOO_calls[gCurrentJni]);
1238 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 2, jobj_, nullptr);
1239 EXPECT_TRUE(env_->IsSameObject(nullptr, result));
1240 EXPECT_EQ(7, gJava_MyClassNatives_fooSSIOO_calls[gCurrentJni]);
1241
1242 // Exercise recursive thin locking/unlocking.
1243 // Note: Thin lock count 0 means locked once.
1244 env_->MonitorEnter(jklass_);
1245 LockWord lock_word = GetLockWord(jklass_);
1246 ASSERT_EQ(lock_word.GetState(), LockWord::kThinLocked);
1247 ASSERT_EQ(lock_word.ThinLockCount(), 0u);
1248 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 2, jobj_, nullptr);
1249 EXPECT_TRUE(env_->IsSameObject(nullptr, result));
1250 EXPECT_EQ(8, gJava_MyClassNatives_fooSSIOO_calls[gCurrentJni]);
1251 lock_word = GetLockWord(jklass_);
1252 ASSERT_EQ(lock_word.GetState(), LockWord::kThinLocked);
1253 ASSERT_EQ(lock_word.ThinLockCount(), 0u);
1254 env_->MonitorExit(jklass_);
1255 lock_word = GetLockWord(jklass_);
1256 ASSERT_EQ(lock_word.GetState(), LockWord::kUnlocked);
1257
1258 // Exercise lock inflation due to thin lock count overflow.
1259 constexpr uint32_t kMaxThinLockRecursiveLocks = 1u << LockWord::kThinLockCountSize;
1260 for (uint32_t i = 0; i != kMaxThinLockRecursiveLocks; ++i) {
1261 env_->MonitorEnter(jklass_);
1262 lock_word = GetLockWord(jklass_);
1263 ASSERT_EQ(lock_word.GetState(), LockWord::kThinLocked);
1264 ASSERT_EQ(lock_word.ThinLockCount(), i);
1265 }
1266 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 2, jobj_, nullptr);
1267 EXPECT_TRUE(env_->IsSameObject(nullptr, result));
1268 EXPECT_EQ(9, gJava_MyClassNatives_fooSSIOO_calls[gCurrentJni]);
1269 lock_word = GetLockWord(jklass_);
1270 ASSERT_EQ(lock_word.GetState(), LockWord::kFatLocked);
1271 for (uint32_t i = 0; i != kMaxThinLockRecursiveLocks; ++i) {
1272 env_->MonitorExit(jklass_); // Remains "fat-locked" even if actually unlocked.
1273 }
1274
1275 // Exercise locking for "fat-locked".
1276 lock_word = GetLockWord(jklass_);
1277 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 2, jobj_, nullptr);
1278 EXPECT_TRUE(env_->IsSameObject(nullptr, result));
1279 EXPECT_EQ(10, gJava_MyClassNatives_fooSSIOO_calls[gCurrentJni]);
1280 lock_word = GetLockWord(jklass_);
1281 ASSERT_EQ(lock_word.GetState(), LockWord::kFatLocked);
1282
1283 gJava_MyClassNatives_fooSSIOO_calls[gCurrentJni] = 0;
1284 }
1285
1286 // TODO: Maybe. @FastNative support for returning Objects?
JNI_TEST_NORMAL_ONLY(CompileAndRunStaticSynchronizedIntObjectObjectMethod)1287 JNI_TEST_NORMAL_ONLY(CompileAndRunStaticSynchronizedIntObjectObjectMethod)
1288
1289 void Java_MyClassNatives_throwException(JNIEnv* env, jobject) {
1290 jclass c = env->FindClass("java/lang/RuntimeException");
1291 env->ThrowNew(c, "hello");
1292 }
1293
Java_MyClassNatives_synchronizedThrowException(JNIEnv * env,jobject)1294 void Java_MyClassNatives_synchronizedThrowException(JNIEnv* env, jobject) {
1295 JniCompilerTest::AssertCallerObjectLocked(env);
1296 jclass c = env->FindClass("java/lang/RuntimeException");
1297 env->ThrowNew(c, "hello");
1298 }
1299
ExceptionHandlingImpl()1300 void JniCompilerTest::ExceptionHandlingImpl() {
1301 {
1302 ASSERT_FALSE(runtime_->IsStarted());
1303 ScopedObjectAccess soa(Thread::Current());
1304 class_loader_ = LoadDex("MyClassNatives");
1305
1306 // all compilation needs to happen before Runtime::Start
1307 CompileForTestWithCurrentJni(class_loader_, false, "foo", "()V");
1308 CompileForTestWithCurrentJni(class_loader_, false, "throwException", "()V");
1309 if (gCurrentJni == enum_cast<uint32_t>(JniKind::kNormal)) {
1310 CompileForTestWithCurrentJni(class_loader_, false, "synchronizedThrowException", "()V");
1311 }
1312 }
1313 // Start runtime to avoid re-initialization in SetUpForTest.
1314 Thread::Current()->TransitionFromSuspendedToRunnable();
1315 bool started = runtime_->Start();
1316 CHECK(started);
1317
1318 gJava_MyClassNatives_foo_calls[gCurrentJni] = 0;
1319
1320 // Check a single call of a JNI method is ok
1321 SetUpForTest(false, "foo", "()V", CURRENT_JNI_WRAPPER(Java_MyClassNatives_foo));
1322 env_->CallNonvirtualVoidMethod(jobj_, jklass_, jmethod_);
1323 EXPECT_EQ(1, gJava_MyClassNatives_foo_calls[gCurrentJni]);
1324 EXPECT_FALSE(Thread::Current()->IsExceptionPending());
1325
1326 // Get class for exception we expect to be thrown
1327 ScopedLocalRef<jclass> jlre(env_, env_->FindClass("java/lang/RuntimeException"));
1328 SetUpForTest(false, "throwException", "()V",
1329 CURRENT_JNI_WRAPPER(Java_MyClassNatives_throwException));
1330 // Call Java_MyClassNatives_throwException (JNI method that throws exception)
1331 env_->CallNonvirtualVoidMethod(jobj_, jklass_, jmethod_);
1332 EXPECT_TRUE(env_->ExceptionCheck() == JNI_TRUE);
1333 ScopedLocalRef<jthrowable> exception(env_, env_->ExceptionOccurred());
1334 env_->ExceptionClear();
1335 EXPECT_TRUE(env_->IsInstanceOf(exception.get(), jlre.get()));
1336
1337 // Check a single call of a JNI method is ok
1338 EXPECT_EQ(1, gJava_MyClassNatives_foo_calls[gCurrentJni]);
1339 SetUpForTest(false, "foo", "()V", reinterpret_cast<void*>(&Java_MyClassNatives_foo));
1340 env_->CallNonvirtualVoidMethod(jobj_, jklass_, jmethod_);
1341 EXPECT_EQ(2, gJava_MyClassNatives_foo_calls[gCurrentJni]);
1342
1343 if (gCurrentJni == enum_cast<uint32_t>(JniKind::kNormal)) {
1344 SetUpForTest(false, "synchronizedThrowException", "()V",
1345 CURRENT_JNI_WRAPPER(Java_MyClassNatives_synchronizedThrowException));
1346 LockWord lock_word = GetLockWord(jobj_);
1347 ASSERT_EQ(lock_word.GetState(), LockWord::kUnlocked);
1348 // Call Java_MyClassNatives_synchronizedThrowException (synchronized JNI method
1349 // that throws exception) to check that we correctly unlock the object.
1350 env_->CallNonvirtualVoidMethod(jobj_, jklass_, jmethod_);
1351 EXPECT_TRUE(env_->ExceptionCheck() == JNI_TRUE);
1352 ScopedLocalRef<jthrowable> exception2(env_, env_->ExceptionOccurred());
1353 env_->ExceptionClear();
1354 EXPECT_TRUE(env_->IsInstanceOf(exception2.get(), jlre.get()));
1355 lock_word = GetLockWord(jobj_);
1356 EXPECT_EQ(lock_word.GetState(), LockWord::kUnlocked);
1357
1358 // Check a single call of a JNI method is ok
1359 EXPECT_EQ(2, gJava_MyClassNatives_foo_calls[gCurrentJni]);
1360 SetUpForTest(false, "foo", "()V", reinterpret_cast<void*>(&Java_MyClassNatives_foo));
1361 env_->CallNonvirtualVoidMethod(jobj_, jklass_, jmethod_);
1362 EXPECT_EQ(3, gJava_MyClassNatives_foo_calls[gCurrentJni]);
1363 }
1364
1365 gJava_MyClassNatives_foo_calls[gCurrentJni] = 0;
1366 }
1367
JNI_TEST(ExceptionHandling)1368 JNI_TEST(ExceptionHandling)
1369
1370 jint Java_MyClassNatives_nativeUpCall(JNIEnv* env, jobject thisObj, jint i) {
1371 if (i <= 0) {
1372 // We want to check raw Object* / Array* below
1373 ScopedObjectAccess soa(env);
1374
1375 // Build stack trace
1376 jobject internal =
1377 soa.AddLocalReference<jobject>(Thread::Current()->CreateInternalStackTrace(soa));
1378 jobjectArray ste_array = Thread::InternalStackTraceToStackTraceElementArray(soa, internal);
1379 ObjPtr<mirror::ObjectArray<mirror::StackTraceElement>> trace_array =
1380 soa.Decode<mirror::ObjectArray<mirror::StackTraceElement>>(ste_array);
1381 EXPECT_TRUE(trace_array != nullptr);
1382 EXPECT_EQ(11, trace_array->GetLength());
1383
1384 // Check stack trace entries have expected values
1385 for (int32_t j = 0; j < trace_array->GetLength(); ++j) {
1386 EXPECT_EQ(-2, trace_array->Get(j)->GetLineNumber());
1387 ObjPtr<mirror::StackTraceElement> ste = trace_array->Get(j);
1388 EXPECT_STREQ("MyClassNatives.java", ste->GetFileName()->ToModifiedUtf8().c_str());
1389 EXPECT_STREQ("MyClassNatives", ste->GetDeclaringClass()->ToModifiedUtf8().c_str());
1390 EXPECT_EQ(("fooI" + CurrentJniStringSuffix()), ste->GetMethodName()->ToModifiedUtf8());
1391 }
1392
1393 // end recursion
1394 return 0;
1395 } else {
1396 jclass jklass = env->FindClass("MyClassNatives");
1397 EXPECT_TRUE(jklass != nullptr);
1398 jmethodID jmethod = env->GetMethodID(jklass,
1399 ("fooI" + CurrentJniStringSuffix()).c_str(),
1400 "(I)I");
1401 EXPECT_TRUE(jmethod != nullptr);
1402
1403 // Recurse with i - 1
1404 jint result = env->CallNonvirtualIntMethod(thisObj, jklass, jmethod, i - 1);
1405
1406 // Return sum of all depths
1407 return i + result;
1408 }
1409 }
1410
NativeStackTraceElementImpl()1411 void JniCompilerTest::NativeStackTraceElementImpl() {
1412 SetUpForTest(false, "fooI", "(I)I",
1413 CURRENT_JNI_WRAPPER(Java_MyClassNatives_nativeUpCall));
1414
1415 // Usual # local references on stack check fails because nativeUpCall calls itself recursively,
1416 // each time the # of local references will therefore go up.
1417 ScopedDisableCheckNumStackReferences disable_num_stack_check;
1418 jint result = env_->CallNonvirtualIntMethod(jobj_, jklass_, jmethod_, 10);
1419
1420 EXPECT_EQ(10+9+8+7+6+5+4+3+2+1, result);
1421 }
1422
JNI_TEST(NativeStackTraceElement)1423 JNI_TEST(NativeStackTraceElement)
1424
1425 jobject Java_MyClassNatives_fooO(JNIEnv* env, jobject, jobject x) {
1426 return env->NewGlobalRef(x);
1427 }
1428
ReturnGlobalRefImpl()1429 void JniCompilerTest::ReturnGlobalRefImpl() {
1430 SetUpForTest(false, "fooO", "(Ljava/lang/Object;)Ljava/lang/Object;",
1431 CURRENT_JNI_WRAPPER(Java_MyClassNatives_fooO));
1432 jobject result = env_->CallNonvirtualObjectMethod(jobj_, jklass_, jmethod_, jobj_);
1433 EXPECT_EQ(JNILocalRefType, env_->GetObjectRefType(result));
1434 EXPECT_TRUE(env_->IsSameObject(result, jobj_));
1435 }
1436
JNI_TEST(ReturnGlobalRef)1437 JNI_TEST(ReturnGlobalRef)
1438
1439 jint local_ref_test(JNIEnv* env, jobject thisObj, jint x) {
1440 // Add 10 local references
1441 ScopedObjectAccess soa(env);
1442 for (int i = 0; i < 10; i++) {
1443 soa.AddLocalReference<jobject>(soa.Decode<mirror::Object>(thisObj));
1444 }
1445 return x+1;
1446 }
1447
LocalReferenceTableClearingTestImpl()1448 void JniCompilerTest::LocalReferenceTableClearingTestImpl() {
1449 SetUpForTest(false, "fooI", "(I)I", CURRENT_JNI_WRAPPER(local_ref_test));
1450 // 1000 invocations of a method that adds 10 local references
1451 for (int i = 0; i < 1000; i++) {
1452 jint result = env_->CallIntMethod(jobj_, jmethod_, i);
1453 EXPECT_TRUE(result == i + 1);
1454 }
1455 }
1456
JNI_TEST(LocalReferenceTableClearingTest)1457 JNI_TEST(LocalReferenceTableClearingTest)
1458
1459 void my_arraycopy(JNIEnv* env, jclass klass, jobject src, jint src_pos, jobject dst, jint dst_pos, jint length) {
1460 EXPECT_TRUE(env->IsSameObject(JniCompilerTest::jklass_, klass));
1461 EXPECT_TRUE(env->IsSameObject(JniCompilerTest::jklass_, dst));
1462 EXPECT_TRUE(env->IsSameObject(JniCompilerTest::jobj_, src));
1463 EXPECT_EQ(1234, src_pos);
1464 EXPECT_EQ(5678, dst_pos);
1465 EXPECT_EQ(9876, length);
1466 }
1467
JavaLangSystemArrayCopyImpl()1468 void JniCompilerTest::JavaLangSystemArrayCopyImpl() {
1469 SetUpForTest(true, "arraycopy", "(Ljava/lang/Object;ILjava/lang/Object;II)V",
1470 CURRENT_JNI_WRAPPER(my_arraycopy));
1471 env_->CallStaticVoidMethod(jklass_, jmethod_, jobj_, 1234, jklass_, 5678, 9876);
1472 }
1473
JNI_TEST(JavaLangSystemArrayCopy)1474 JNI_TEST(JavaLangSystemArrayCopy)
1475
1476 jboolean my_casi(JNIEnv* env, jobject unsafe, jobject obj, jlong offset, jint expected, jint newval) {
1477 EXPECT_TRUE(env->IsSameObject(JniCompilerTest::jobj_, unsafe));
1478 EXPECT_TRUE(env->IsSameObject(JniCompilerTest::jobj_, obj));
1479 EXPECT_EQ(INT64_C(0x12345678ABCDEF88), offset);
1480 EXPECT_EQ(static_cast<jint>(0xCAFEF00D), expected);
1481 EXPECT_EQ(static_cast<jint>(0xEBADF00D), newval);
1482 return JNI_TRUE;
1483 }
1484
CompareAndSwapIntImpl()1485 void JniCompilerTest::CompareAndSwapIntImpl() {
1486 SetUpForTest(false, "compareAndSwapInt", "(Ljava/lang/Object;JII)Z",
1487 CURRENT_JNI_WRAPPER(my_casi));
1488 jboolean result = env_->CallBooleanMethod(jobj_, jmethod_, jobj_, INT64_C(0x12345678ABCDEF88),
1489 0xCAFEF00D, 0xEBADF00D);
1490 EXPECT_EQ(result, JNI_TRUE);
1491 }
1492
JNI_TEST(CompareAndSwapInt)1493 JNI_TEST(CompareAndSwapInt)
1494
1495 jint my_gettext(JNIEnv* env, jclass klass, jlong val1, jobject obj1, jlong val2, jobject obj2) {
1496 EXPECT_TRUE(env->IsInstanceOf(JniCompilerTest::jobj_, klass));
1497 EXPECT_TRUE(env->IsSameObject(JniCompilerTest::jobj_, obj1));
1498 EXPECT_TRUE(env->IsSameObject(JniCompilerTest::jobj_, obj2));
1499 EXPECT_EQ(0x12345678ABCDEF88LL, val1);
1500 EXPECT_EQ(0x7FEDCBA987654321LL, val2);
1501 return 42;
1502 }
1503
GetTextImpl()1504 void JniCompilerTest::GetTextImpl() {
1505 SetUpForTest(true, "getText", "(JLjava/lang/Object;JLjava/lang/Object;)I",
1506 CURRENT_JNI_WRAPPER(my_gettext));
1507 jint result = env_->CallStaticIntMethod(jklass_, jmethod_, 0x12345678ABCDEF88LL, jobj_,
1508 INT64_C(0x7FEDCBA987654321), jobj_);
1509 EXPECT_EQ(result, 42);
1510 }
1511
1512 JNI_TEST(GetText)
1513
1514 int gJava_MyClassNatives_GetSinkProperties_calls[kJniKindCount] = {};
Java_MyClassNatives_GetSinkProperties(JNIEnv * env,jobject thisObj,jstring s)1515 jarray Java_MyClassNatives_GetSinkProperties(JNIEnv* env, jobject thisObj, jstring s) {
1516 JniCompilerTest::AssertCallerObjectLocked(env);
1517 EXPECT_EQ(s, nullptr);
1518 gJava_MyClassNatives_GetSinkProperties_calls[gCurrentJni]++;
1519
1520 Thread* self = Thread::Current();
1521 ScopedObjectAccess soa(self);
1522 EXPECT_TRUE(self->HoldsLock(soa.Decode<mirror::Object>(thisObj)));
1523 return nullptr;
1524 }
1525
GetSinkPropertiesNativeImpl()1526 void JniCompilerTest::GetSinkPropertiesNativeImpl() {
1527 SetUpForTest(false, "getSinkPropertiesNative", "(Ljava/lang/String;)[Ljava/lang/Object;",
1528 CURRENT_JNI_WRAPPER(Java_MyClassNatives_GetSinkProperties));
1529
1530 EXPECT_EQ(0, gJava_MyClassNatives_GetSinkProperties_calls[gCurrentJni]);
1531 jarray result = down_cast<jarray>(
1532 env_->CallNonvirtualObjectMethod(jobj_, jklass_, jmethod_, nullptr));
1533 EXPECT_EQ(nullptr, result);
1534 EXPECT_EQ(1, gJava_MyClassNatives_GetSinkProperties_calls[gCurrentJni]);
1535
1536 gJava_MyClassNatives_GetSinkProperties_calls[gCurrentJni] = 0;
1537 }
1538
1539 // @FastNative doesn't support 'synchronized' keyword and
1540 // never will -- locking functions aren't fast.
JNI_TEST_NORMAL_ONLY(GetSinkPropertiesNative)1541 JNI_TEST_NORMAL_ONLY(GetSinkPropertiesNative)
1542
1543 // This should return jclass, but we're imitating a bug pattern.
1544 jobject Java_MyClassNatives_instanceMethodThatShouldReturnClass(JNIEnv* env, jobject) {
1545 return env->NewStringUTF("not a class!");
1546 }
1547
1548 // This should return jclass, but we're imitating a bug pattern.
Java_MyClassNatives_staticMethodThatShouldReturnClass(JNIEnv * env,jclass)1549 jobject Java_MyClassNatives_staticMethodThatShouldReturnClass(JNIEnv* env, jclass) {
1550 return env->NewStringUTF("not a class!");
1551 }
1552
UpcallReturnTypeChecking_InstanceImpl()1553 void JniCompilerTest::UpcallReturnTypeChecking_InstanceImpl() {
1554 // Set debuggable so that the JNI compiler does not emit a fast-path that would skip the
1555 // runtime call where we do these checks. Note that while normal gtests use the debug build
1556 // which disables the fast path, `art_standalone_compiler_tests` run in the release build.
1557 compiler_options_->SetDebuggable(true);
1558 SetUpForTest(false, "instanceMethodThatShouldReturnClass", "()Ljava/lang/Class;",
1559 CURRENT_JNI_WRAPPER(Java_MyClassNatives_instanceMethodThatShouldReturnClass));
1560
1561 CheckJniAbortCatcher check_jni_abort_catcher;
1562 // This native method is bad, and tries to return a jstring as a jclass.
1563 env_->CallObjectMethod(jobj_, jmethod_);
1564 check_jni_abort_catcher.Check(std::string() + "attempt to return an instance " +
1565 "of java.lang.String from java.lang.Class " +
1566 "MyClassNatives.instanceMethodThatShouldReturnClass" +
1567 CurrentJniStringSuffix() + "()");
1568
1569 // Here, we just call the method incorrectly; we should catch that too.
1570 env_->CallObjectMethod(jobj_, jmethod_);
1571 check_jni_abort_catcher.Check(std::string() + "attempt to return an instance " +
1572 "of java.lang.String from java.lang.Class " +
1573 "MyClassNatives.instanceMethodThatShouldReturnClass" +
1574 CurrentJniStringSuffix() + "()");
1575 env_->CallStaticObjectMethod(jklass_, jmethod_);
1576 check_jni_abort_catcher.Check(std::string() + "calling non-static method " +
1577 "java.lang.Class " +
1578 "MyClassNatives.instanceMethodThatShouldReturnClass" +
1579 CurrentJniStringSuffix() + "() with CallStaticObjectMethodV");
1580 }
1581
JNI_TEST(UpcallReturnTypeChecking_Instance)1582 JNI_TEST(UpcallReturnTypeChecking_Instance)
1583
1584 void JniCompilerTest::UpcallReturnTypeChecking_StaticImpl() {
1585 // Set debuggable so that the JNI compiler does not emit a fast-path that would skip the
1586 // runtime call where we do these checks. Note that while normal gtests use the debug build
1587 // which disables the fast path, `art_standalone_compiler_tests` run in the release build.
1588 compiler_options_->SetDebuggable(true);
1589 SetUpForTest(true, "staticMethodThatShouldReturnClass", "()Ljava/lang/Class;",
1590 CURRENT_JNI_WRAPPER(Java_MyClassNatives_staticMethodThatShouldReturnClass));
1591
1592 CheckJniAbortCatcher check_jni_abort_catcher;
1593 // This native method is bad, and tries to return a jstring as a jclass.
1594 env_->CallStaticObjectMethod(jklass_, jmethod_);
1595 check_jni_abort_catcher.Check(std::string() + "attempt to return an instance " +
1596 "of java.lang.String from java.lang.Class " +
1597 "MyClassNatives.staticMethodThatShouldReturnClass" +
1598 CurrentJniStringSuffix() + "()");
1599
1600 // Here, we just call the method incorrectly; we should catch that too.
1601 env_->CallStaticObjectMethod(jklass_, jmethod_);
1602 check_jni_abort_catcher.Check(std::string() + "attempt to return an instance " +
1603 "of java.lang.String from java.lang.Class " +
1604 "MyClassNatives.staticMethodThatShouldReturnClass" +
1605 CurrentJniStringSuffix() + "()");
1606 env_->CallObjectMethod(jobj_, jmethod_);
1607 check_jni_abort_catcher.Check(std::string() + "calling static method " +
1608 "java.lang.Class " +
1609 "MyClassNatives.staticMethodThatShouldReturnClass" +
1610 CurrentJniStringSuffix() + "() with CallObjectMethodV");
1611 }
1612
JNI_TEST(UpcallReturnTypeChecking_Static)1613 JNI_TEST(UpcallReturnTypeChecking_Static)
1614
1615 // This should take jclass, but we're imitating a bug pattern.
1616 void Java_MyClassNatives_instanceMethodThatShouldTakeClass(JNIEnv*, jobject, jclass) {
1617 }
1618
1619 // This should take jclass, but we're imitating a bug pattern.
Java_MyClassNatives_staticMethodThatShouldTakeClass(JNIEnv *,jclass,jclass)1620 void Java_MyClassNatives_staticMethodThatShouldTakeClass(JNIEnv*, jclass, jclass) {
1621 }
1622
UpcallArgumentTypeChecking_InstanceImpl()1623 void JniCompilerTest::UpcallArgumentTypeChecking_InstanceImpl() {
1624 // This will lead to error messages in the log.
1625 ScopedLogSeverity sls(LogSeverity::FATAL);
1626
1627 SetUpForTest(false, "instanceMethodThatShouldTakeClass", "(ILjava/lang/Class;)V",
1628 CURRENT_JNI_WRAPPER(Java_MyClassNatives_instanceMethodThatShouldTakeClass));
1629
1630 CheckJniAbortCatcher check_jni_abort_catcher;
1631 // We deliberately pass a bad second argument here.
1632 env_->CallVoidMethod(jobj_, jmethod_, 123, env_->NewStringUTF("not a class!"));
1633 check_jni_abort_catcher.Check(std::string() + "bad arguments passed to void " +
1634 "MyClassNatives.instanceMethodThatShouldTakeClass" +
1635 CurrentJniStringSuffix() + "(int, java.lang.Class)");
1636 }
1637
JNI_TEST(UpcallArgumentTypeChecking_Instance)1638 JNI_TEST(UpcallArgumentTypeChecking_Instance)
1639
1640 void JniCompilerTest::UpcallArgumentTypeChecking_StaticImpl() {
1641 // This will lead to error messages in the log.
1642 ScopedLogSeverity sls(LogSeverity::FATAL);
1643
1644 SetUpForTest(true, "staticMethodThatShouldTakeClass", "(ILjava/lang/Class;)V",
1645 CURRENT_JNI_WRAPPER(Java_MyClassNatives_staticMethodThatShouldTakeClass));
1646
1647 CheckJniAbortCatcher check_jni_abort_catcher;
1648 // We deliberately pass a bad second argument here.
1649 env_->CallStaticVoidMethod(jklass_, jmethod_, 123, env_->NewStringUTF("not a class!"));
1650 check_jni_abort_catcher.Check(std::string() + "bad arguments passed to void " +
1651 "MyClassNatives.staticMethodThatShouldTakeClass" +
1652 CurrentJniStringSuffix() + "(int, java.lang.Class)");
1653 }
1654
JNI_TEST(UpcallArgumentTypeChecking_Static)1655 JNI_TEST(UpcallArgumentTypeChecking_Static)
1656
1657 jfloat Java_MyClassNatives_checkFloats(JNIEnv*, jobject, jfloat f1, jfloat f2) {
1658 return f1 - f2; // non-commutative operator
1659 }
1660
CompileAndRunFloatFloatMethodImpl()1661 void JniCompilerTest::CompileAndRunFloatFloatMethodImpl() {
1662 SetUpForTest(false, "checkFloats", "(FF)F",
1663 CURRENT_JNI_WRAPPER(Java_MyClassNatives_checkFloats));
1664
1665 jfloat result = env_->CallNonvirtualFloatMethod(jobj_, jklass_, jmethod_,
1666 99.0F, 10.0F);
1667 EXPECT_FLOAT_EQ(99.0F - 10.0F, result);
1668 jfloat a = 3.14159F;
1669 jfloat b = 0.69314F;
1670 result = env_->CallNonvirtualFloatMethod(jobj_, jklass_, jmethod_, a, b);
1671 EXPECT_FLOAT_EQ(a - b, result);
1672 }
1673
JNI_TEST(CompileAndRunFloatFloatMethod)1674 JNI_TEST(CompileAndRunFloatFloatMethod)
1675
1676 void Java_MyClassNatives_checkParameterAlign([[maybe_unused]] JNIEnv* env,
1677 [[maybe_unused]] jobject thisObj,
1678 jint i1,
1679 jlong l1) {
1680 EXPECT_EQ(i1, 1234);
1681 EXPECT_EQ(l1, INT64_C(0x12345678ABCDEF0));
1682 }
1683
CheckParameterAlignImpl()1684 void JniCompilerTest::CheckParameterAlignImpl() {
1685 SetUpForTest(false, "checkParameterAlign", "(IJ)V",
1686 CURRENT_JNI_WRAPPER(Java_MyClassNatives_checkParameterAlign));
1687
1688 env_->CallNonvirtualVoidMethod(jobj_, jklass_, jmethod_, 1234, INT64_C(0x12345678ABCDEF0));
1689 }
1690
JNI_TEST(CheckParameterAlign)1691 JNI_TEST(CheckParameterAlign)
1692
1693 void Java_MyClassNatives_maxParamNumber(JNIEnv* env, jobject,
1694 jobject o0, jobject o1, jobject o2, jobject o3, jobject o4, jobject o5, jobject o6, jobject o7,
1695 jobject o8, jobject o9, jobject o10, jobject o11, jobject o12, jobject o13, jobject o14, jobject o15,
1696 jobject o16, jobject o17, jobject o18, jobject o19, jobject o20, jobject o21, jobject o22, jobject o23,
1697 jobject o24, jobject o25, jobject o26, jobject o27, jobject o28, jobject o29, jobject o30, jobject o31,
1698 jobject o32, jobject o33, jobject o34, jobject o35, jobject o36, jobject o37, jobject o38, jobject o39,
1699 jobject o40, jobject o41, jobject o42, jobject o43, jobject o44, jobject o45, jobject o46, jobject o47,
1700 jobject o48, jobject o49, jobject o50, jobject o51, jobject o52, jobject o53, jobject o54, jobject o55,
1701 jobject o56, jobject o57, jobject o58, jobject o59, jobject o60, jobject o61, jobject o62, jobject o63,
1702 jobject o64, jobject o65, jobject o66, jobject o67, jobject o68, jobject o69, jobject o70, jobject o71,
1703 jobject o72, jobject o73, jobject o74, jobject o75, jobject o76, jobject o77, jobject o78, jobject o79,
1704 jobject o80, jobject o81, jobject o82, jobject o83, jobject o84, jobject o85, jobject o86, jobject o87,
1705 jobject o88, jobject o89, jobject o90, jobject o91, jobject o92, jobject o93, jobject o94, jobject o95,
1706 jobject o96, jobject o97, jobject o98, jobject o99, jobject o100, jobject o101, jobject o102, jobject o103,
1707 jobject o104, jobject o105, jobject o106, jobject o107, jobject o108, jobject o109, jobject o110, jobject o111,
1708 jobject o112, jobject o113, jobject o114, jobject o115, jobject o116, jobject o117, jobject o118, jobject o119,
1709 jobject o120, jobject o121, jobject o122, jobject o123, jobject o124, jobject o125, jobject o126, jobject o127,
1710 jobject o128, jobject o129, jobject o130, jobject o131, jobject o132, jobject o133, jobject o134, jobject o135,
1711 jobject o136, jobject o137, jobject o138, jobject o139, jobject o140, jobject o141, jobject o142, jobject o143,
1712 jobject o144, jobject o145, jobject o146, jobject o147, jobject o148, jobject o149, jobject o150, jobject o151,
1713 jobject o152, jobject o153, jobject o154, jobject o155, jobject o156, jobject o157, jobject o158, jobject o159,
1714 jobject o160, jobject o161, jobject o162, jobject o163, jobject o164, jobject o165, jobject o166, jobject o167,
1715 jobject o168, jobject o169, jobject o170, jobject o171, jobject o172, jobject o173, jobject o174, jobject o175,
1716 jobject o176, jobject o177, jobject o178, jobject o179, jobject o180, jobject o181, jobject o182, jobject o183,
1717 jobject o184, jobject o185, jobject o186, jobject o187, jobject o188, jobject o189, jobject o190, jobject o191,
1718 jobject o192, jobject o193, jobject o194, jobject o195, jobject o196, jobject o197, jobject o198, jobject o199,
1719 jobject o200, jobject o201, jobject o202, jobject o203, jobject o204, jobject o205, jobject o206, jobject o207,
1720 jobject o208, jobject o209, jobject o210, jobject o211, jobject o212, jobject o213, jobject o214, jobject o215,
1721 jobject o216, jobject o217, jobject o218, jobject o219, jobject o220, jobject o221, jobject o222, jobject o223,
1722 jobject o224, jobject o225, jobject o226, jobject o227, jobject o228, jobject o229, jobject o230, jobject o231,
1723 jobject o232, jobject o233, jobject o234, jobject o235, jobject o236, jobject o237, jobject o238, jobject o239,
1724 jobject o240, jobject o241, jobject o242, jobject o243, jobject o244, jobject o245, jobject o246, jobject o247,
1725 jobject o248, jobject o249, jobject o250, jobject o251, jobject o252, jobject o253) {
1726 // two tests possible
1727 if (o0 == nullptr) {
1728 // 1) everything is null
1729 EXPECT_TRUE(o0 == nullptr && o1 == nullptr && o2 == nullptr && o3 == nullptr && o4 == nullptr
1730 && o5 == nullptr && o6 == nullptr && o7 == nullptr && o8 == nullptr && o9 == nullptr
1731 && o10 == nullptr && o11 == nullptr && o12 == nullptr && o13 == nullptr && o14 == nullptr
1732 && o15 == nullptr && o16 == nullptr && o17 == nullptr && o18 == nullptr && o19 == nullptr
1733 && o20 == nullptr && o21 == nullptr && o22 == nullptr && o23 == nullptr && o24 == nullptr
1734 && o25 == nullptr && o26 == nullptr && o27 == nullptr && o28 == nullptr && o29 == nullptr
1735 && o30 == nullptr && o31 == nullptr && o32 == nullptr && o33 == nullptr && o34 == nullptr
1736 && o35 == nullptr && o36 == nullptr && o37 == nullptr && o38 == nullptr && o39 == nullptr
1737 && o40 == nullptr && o41 == nullptr && o42 == nullptr && o43 == nullptr && o44 == nullptr
1738 && o45 == nullptr && o46 == nullptr && o47 == nullptr && o48 == nullptr && o49 == nullptr
1739 && o50 == nullptr && o51 == nullptr && o52 == nullptr && o53 == nullptr && o54 == nullptr
1740 && o55 == nullptr && o56 == nullptr && o57 == nullptr && o58 == nullptr && o59 == nullptr
1741 && o60 == nullptr && o61 == nullptr && o62 == nullptr && o63 == nullptr && o64 == nullptr
1742 && o65 == nullptr && o66 == nullptr && o67 == nullptr && o68 == nullptr && o69 == nullptr
1743 && o70 == nullptr && o71 == nullptr && o72 == nullptr && o73 == nullptr && o74 == nullptr
1744 && o75 == nullptr && o76 == nullptr && o77 == nullptr && o78 == nullptr && o79 == nullptr
1745 && o80 == nullptr && o81 == nullptr && o82 == nullptr && o83 == nullptr && o84 == nullptr
1746 && o85 == nullptr && o86 == nullptr && o87 == nullptr && o88 == nullptr && o89 == nullptr
1747 && o90 == nullptr && o91 == nullptr && o92 == nullptr && o93 == nullptr && o94 == nullptr
1748 && o95 == nullptr && o96 == nullptr && o97 == nullptr && o98 == nullptr && o99 == nullptr
1749 && o100 == nullptr && o101 == nullptr && o102 == nullptr && o103 == nullptr && o104 == nullptr
1750 && o105 == nullptr && o106 == nullptr && o107 == nullptr && o108 == nullptr && o109 == nullptr
1751 && o110 == nullptr && o111 == nullptr && o112 == nullptr && o113 == nullptr && o114 == nullptr
1752 && o115 == nullptr && o116 == nullptr && o117 == nullptr && o118 == nullptr && o119 == nullptr
1753 && o120 == nullptr && o121 == nullptr && o122 == nullptr && o123 == nullptr && o124 == nullptr
1754 && o125 == nullptr && o126 == nullptr && o127 == nullptr && o128 == nullptr && o129 == nullptr
1755 && o130 == nullptr && o131 == nullptr && o132 == nullptr && o133 == nullptr && o134 == nullptr
1756 && o135 == nullptr && o136 == nullptr && o137 == nullptr && o138 == nullptr && o139 == nullptr
1757 && o140 == nullptr && o141 == nullptr && o142 == nullptr && o143 == nullptr && o144 == nullptr
1758 && o145 == nullptr && o146 == nullptr && o147 == nullptr && o148 == nullptr && o149 == nullptr
1759 && o150 == nullptr && o151 == nullptr && o152 == nullptr && o153 == nullptr && o154 == nullptr
1760 && o155 == nullptr && o156 == nullptr && o157 == nullptr && o158 == nullptr && o159 == nullptr
1761 && o160 == nullptr && o161 == nullptr && o162 == nullptr && o163 == nullptr && o164 == nullptr
1762 && o165 == nullptr && o166 == nullptr && o167 == nullptr && o168 == nullptr && o169 == nullptr
1763 && o170 == nullptr && o171 == nullptr && o172 == nullptr && o173 == nullptr && o174 == nullptr
1764 && o175 == nullptr && o176 == nullptr && o177 == nullptr && o178 == nullptr && o179 == nullptr
1765 && o180 == nullptr && o181 == nullptr && o182 == nullptr && o183 == nullptr && o184 == nullptr
1766 && o185 == nullptr && o186 == nullptr && o187 == nullptr && o188 == nullptr && o189 == nullptr
1767 && o190 == nullptr && o191 == nullptr && o192 == nullptr && o193 == nullptr && o194 == nullptr
1768 && o195 == nullptr && o196 == nullptr && o197 == nullptr && o198 == nullptr && o199 == nullptr
1769 && o200 == nullptr && o201 == nullptr && o202 == nullptr && o203 == nullptr && o204 == nullptr
1770 && o205 == nullptr && o206 == nullptr && o207 == nullptr && o208 == nullptr && o209 == nullptr
1771 && o210 == nullptr && o211 == nullptr && o212 == nullptr && o213 == nullptr && o214 == nullptr
1772 && o215 == nullptr && o216 == nullptr && o217 == nullptr && o218 == nullptr && o219 == nullptr
1773 && o220 == nullptr && o221 == nullptr && o222 == nullptr && o223 == nullptr && o224 == nullptr
1774 && o225 == nullptr && o226 == nullptr && o227 == nullptr && o228 == nullptr && o229 == nullptr
1775 && o230 == nullptr && o231 == nullptr && o232 == nullptr && o233 == nullptr && o234 == nullptr
1776 && o235 == nullptr && o236 == nullptr && o237 == nullptr && o238 == nullptr && o239 == nullptr
1777 && o240 == nullptr && o241 == nullptr && o242 == nullptr && o243 == nullptr && o244 == nullptr
1778 && o245 == nullptr && o246 == nullptr && o247 == nullptr && o248 == nullptr && o249 == nullptr
1779 && o250 == nullptr && o251 == nullptr && o252 == nullptr && o253 == nullptr);
1780 } else {
1781 EXPECT_EQ(0, env->GetArrayLength(reinterpret_cast<jarray>(o0)));
1782 EXPECT_EQ(1, env->GetArrayLength(reinterpret_cast<jarray>(o1)));
1783 EXPECT_EQ(2, env->GetArrayLength(reinterpret_cast<jarray>(o2)));
1784 EXPECT_EQ(3, env->GetArrayLength(reinterpret_cast<jarray>(o3)));
1785 EXPECT_EQ(4, env->GetArrayLength(reinterpret_cast<jarray>(o4)));
1786 EXPECT_EQ(5, env->GetArrayLength(reinterpret_cast<jarray>(o5)));
1787 EXPECT_EQ(6, env->GetArrayLength(reinterpret_cast<jarray>(o6)));
1788 EXPECT_EQ(7, env->GetArrayLength(reinterpret_cast<jarray>(o7)));
1789 EXPECT_EQ(8, env->GetArrayLength(reinterpret_cast<jarray>(o8)));
1790 EXPECT_EQ(9, env->GetArrayLength(reinterpret_cast<jarray>(o9)));
1791 EXPECT_EQ(10, env->GetArrayLength(reinterpret_cast<jarray>(o10)));
1792 EXPECT_EQ(11, env->GetArrayLength(reinterpret_cast<jarray>(o11)));
1793 EXPECT_EQ(12, env->GetArrayLength(reinterpret_cast<jarray>(o12)));
1794 EXPECT_EQ(13, env->GetArrayLength(reinterpret_cast<jarray>(o13)));
1795 EXPECT_EQ(14, env->GetArrayLength(reinterpret_cast<jarray>(o14)));
1796 EXPECT_EQ(15, env->GetArrayLength(reinterpret_cast<jarray>(o15)));
1797 EXPECT_EQ(16, env->GetArrayLength(reinterpret_cast<jarray>(o16)));
1798 EXPECT_EQ(17, env->GetArrayLength(reinterpret_cast<jarray>(o17)));
1799 EXPECT_EQ(18, env->GetArrayLength(reinterpret_cast<jarray>(o18)));
1800 EXPECT_EQ(19, env->GetArrayLength(reinterpret_cast<jarray>(o19)));
1801 EXPECT_EQ(20, env->GetArrayLength(reinterpret_cast<jarray>(o20)));
1802 EXPECT_EQ(21, env->GetArrayLength(reinterpret_cast<jarray>(o21)));
1803 EXPECT_EQ(22, env->GetArrayLength(reinterpret_cast<jarray>(o22)));
1804 EXPECT_EQ(23, env->GetArrayLength(reinterpret_cast<jarray>(o23)));
1805 EXPECT_EQ(24, env->GetArrayLength(reinterpret_cast<jarray>(o24)));
1806 EXPECT_EQ(25, env->GetArrayLength(reinterpret_cast<jarray>(o25)));
1807 EXPECT_EQ(26, env->GetArrayLength(reinterpret_cast<jarray>(o26)));
1808 EXPECT_EQ(27, env->GetArrayLength(reinterpret_cast<jarray>(o27)));
1809 EXPECT_EQ(28, env->GetArrayLength(reinterpret_cast<jarray>(o28)));
1810 EXPECT_EQ(29, env->GetArrayLength(reinterpret_cast<jarray>(o29)));
1811 EXPECT_EQ(30, env->GetArrayLength(reinterpret_cast<jarray>(o30)));
1812 EXPECT_EQ(31, env->GetArrayLength(reinterpret_cast<jarray>(o31)));
1813 EXPECT_EQ(32, env->GetArrayLength(reinterpret_cast<jarray>(o32)));
1814 EXPECT_EQ(33, env->GetArrayLength(reinterpret_cast<jarray>(o33)));
1815 EXPECT_EQ(34, env->GetArrayLength(reinterpret_cast<jarray>(o34)));
1816 EXPECT_EQ(35, env->GetArrayLength(reinterpret_cast<jarray>(o35)));
1817 EXPECT_EQ(36, env->GetArrayLength(reinterpret_cast<jarray>(o36)));
1818 EXPECT_EQ(37, env->GetArrayLength(reinterpret_cast<jarray>(o37)));
1819 EXPECT_EQ(38, env->GetArrayLength(reinterpret_cast<jarray>(o38)));
1820 EXPECT_EQ(39, env->GetArrayLength(reinterpret_cast<jarray>(o39)));
1821 EXPECT_EQ(40, env->GetArrayLength(reinterpret_cast<jarray>(o40)));
1822 EXPECT_EQ(41, env->GetArrayLength(reinterpret_cast<jarray>(o41)));
1823 EXPECT_EQ(42, env->GetArrayLength(reinterpret_cast<jarray>(o42)));
1824 EXPECT_EQ(43, env->GetArrayLength(reinterpret_cast<jarray>(o43)));
1825 EXPECT_EQ(44, env->GetArrayLength(reinterpret_cast<jarray>(o44)));
1826 EXPECT_EQ(45, env->GetArrayLength(reinterpret_cast<jarray>(o45)));
1827 EXPECT_EQ(46, env->GetArrayLength(reinterpret_cast<jarray>(o46)));
1828 EXPECT_EQ(47, env->GetArrayLength(reinterpret_cast<jarray>(o47)));
1829 EXPECT_EQ(48, env->GetArrayLength(reinterpret_cast<jarray>(o48)));
1830 EXPECT_EQ(49, env->GetArrayLength(reinterpret_cast<jarray>(o49)));
1831 EXPECT_EQ(50, env->GetArrayLength(reinterpret_cast<jarray>(o50)));
1832 EXPECT_EQ(51, env->GetArrayLength(reinterpret_cast<jarray>(o51)));
1833 EXPECT_EQ(52, env->GetArrayLength(reinterpret_cast<jarray>(o52)));
1834 EXPECT_EQ(53, env->GetArrayLength(reinterpret_cast<jarray>(o53)));
1835 EXPECT_EQ(54, env->GetArrayLength(reinterpret_cast<jarray>(o54)));
1836 EXPECT_EQ(55, env->GetArrayLength(reinterpret_cast<jarray>(o55)));
1837 EXPECT_EQ(56, env->GetArrayLength(reinterpret_cast<jarray>(o56)));
1838 EXPECT_EQ(57, env->GetArrayLength(reinterpret_cast<jarray>(o57)));
1839 EXPECT_EQ(58, env->GetArrayLength(reinterpret_cast<jarray>(o58)));
1840 EXPECT_EQ(59, env->GetArrayLength(reinterpret_cast<jarray>(o59)));
1841 EXPECT_EQ(60, env->GetArrayLength(reinterpret_cast<jarray>(o60)));
1842 EXPECT_EQ(61, env->GetArrayLength(reinterpret_cast<jarray>(o61)));
1843 EXPECT_EQ(62, env->GetArrayLength(reinterpret_cast<jarray>(o62)));
1844 EXPECT_EQ(63, env->GetArrayLength(reinterpret_cast<jarray>(o63)));
1845 EXPECT_EQ(64, env->GetArrayLength(reinterpret_cast<jarray>(o64)));
1846 EXPECT_EQ(65, env->GetArrayLength(reinterpret_cast<jarray>(o65)));
1847 EXPECT_EQ(66, env->GetArrayLength(reinterpret_cast<jarray>(o66)));
1848 EXPECT_EQ(67, env->GetArrayLength(reinterpret_cast<jarray>(o67)));
1849 EXPECT_EQ(68, env->GetArrayLength(reinterpret_cast<jarray>(o68)));
1850 EXPECT_EQ(69, env->GetArrayLength(reinterpret_cast<jarray>(o69)));
1851 EXPECT_EQ(70, env->GetArrayLength(reinterpret_cast<jarray>(o70)));
1852 EXPECT_EQ(71, env->GetArrayLength(reinterpret_cast<jarray>(o71)));
1853 EXPECT_EQ(72, env->GetArrayLength(reinterpret_cast<jarray>(o72)));
1854 EXPECT_EQ(73, env->GetArrayLength(reinterpret_cast<jarray>(o73)));
1855 EXPECT_EQ(74, env->GetArrayLength(reinterpret_cast<jarray>(o74)));
1856 EXPECT_EQ(75, env->GetArrayLength(reinterpret_cast<jarray>(o75)));
1857 EXPECT_EQ(76, env->GetArrayLength(reinterpret_cast<jarray>(o76)));
1858 EXPECT_EQ(77, env->GetArrayLength(reinterpret_cast<jarray>(o77)));
1859 EXPECT_EQ(78, env->GetArrayLength(reinterpret_cast<jarray>(o78)));
1860 EXPECT_EQ(79, env->GetArrayLength(reinterpret_cast<jarray>(o79)));
1861 EXPECT_EQ(80, env->GetArrayLength(reinterpret_cast<jarray>(o80)));
1862 EXPECT_EQ(81, env->GetArrayLength(reinterpret_cast<jarray>(o81)));
1863 EXPECT_EQ(82, env->GetArrayLength(reinterpret_cast<jarray>(o82)));
1864 EXPECT_EQ(83, env->GetArrayLength(reinterpret_cast<jarray>(o83)));
1865 EXPECT_EQ(84, env->GetArrayLength(reinterpret_cast<jarray>(o84)));
1866 EXPECT_EQ(85, env->GetArrayLength(reinterpret_cast<jarray>(o85)));
1867 EXPECT_EQ(86, env->GetArrayLength(reinterpret_cast<jarray>(o86)));
1868 EXPECT_EQ(87, env->GetArrayLength(reinterpret_cast<jarray>(o87)));
1869 EXPECT_EQ(88, env->GetArrayLength(reinterpret_cast<jarray>(o88)));
1870 EXPECT_EQ(89, env->GetArrayLength(reinterpret_cast<jarray>(o89)));
1871 EXPECT_EQ(90, env->GetArrayLength(reinterpret_cast<jarray>(o90)));
1872 EXPECT_EQ(91, env->GetArrayLength(reinterpret_cast<jarray>(o91)));
1873 EXPECT_EQ(92, env->GetArrayLength(reinterpret_cast<jarray>(o92)));
1874 EXPECT_EQ(93, env->GetArrayLength(reinterpret_cast<jarray>(o93)));
1875 EXPECT_EQ(94, env->GetArrayLength(reinterpret_cast<jarray>(o94)));
1876 EXPECT_EQ(95, env->GetArrayLength(reinterpret_cast<jarray>(o95)));
1877 EXPECT_EQ(96, env->GetArrayLength(reinterpret_cast<jarray>(o96)));
1878 EXPECT_EQ(97, env->GetArrayLength(reinterpret_cast<jarray>(o97)));
1879 EXPECT_EQ(98, env->GetArrayLength(reinterpret_cast<jarray>(o98)));
1880 EXPECT_EQ(99, env->GetArrayLength(reinterpret_cast<jarray>(o99)));
1881 EXPECT_EQ(100, env->GetArrayLength(reinterpret_cast<jarray>(o100)));
1882 EXPECT_EQ(101, env->GetArrayLength(reinterpret_cast<jarray>(o101)));
1883 EXPECT_EQ(102, env->GetArrayLength(reinterpret_cast<jarray>(o102)));
1884 EXPECT_EQ(103, env->GetArrayLength(reinterpret_cast<jarray>(o103)));
1885 EXPECT_EQ(104, env->GetArrayLength(reinterpret_cast<jarray>(o104)));
1886 EXPECT_EQ(105, env->GetArrayLength(reinterpret_cast<jarray>(o105)));
1887 EXPECT_EQ(106, env->GetArrayLength(reinterpret_cast<jarray>(o106)));
1888 EXPECT_EQ(107, env->GetArrayLength(reinterpret_cast<jarray>(o107)));
1889 EXPECT_EQ(108, env->GetArrayLength(reinterpret_cast<jarray>(o108)));
1890 EXPECT_EQ(109, env->GetArrayLength(reinterpret_cast<jarray>(o109)));
1891 EXPECT_EQ(110, env->GetArrayLength(reinterpret_cast<jarray>(o110)));
1892 EXPECT_EQ(111, env->GetArrayLength(reinterpret_cast<jarray>(o111)));
1893 EXPECT_EQ(112, env->GetArrayLength(reinterpret_cast<jarray>(o112)));
1894 EXPECT_EQ(113, env->GetArrayLength(reinterpret_cast<jarray>(o113)));
1895 EXPECT_EQ(114, env->GetArrayLength(reinterpret_cast<jarray>(o114)));
1896 EXPECT_EQ(115, env->GetArrayLength(reinterpret_cast<jarray>(o115)));
1897 EXPECT_EQ(116, env->GetArrayLength(reinterpret_cast<jarray>(o116)));
1898 EXPECT_EQ(117, env->GetArrayLength(reinterpret_cast<jarray>(o117)));
1899 EXPECT_EQ(118, env->GetArrayLength(reinterpret_cast<jarray>(o118)));
1900 EXPECT_EQ(119, env->GetArrayLength(reinterpret_cast<jarray>(o119)));
1901 EXPECT_EQ(120, env->GetArrayLength(reinterpret_cast<jarray>(o120)));
1902 EXPECT_EQ(121, env->GetArrayLength(reinterpret_cast<jarray>(o121)));
1903 EXPECT_EQ(122, env->GetArrayLength(reinterpret_cast<jarray>(o122)));
1904 EXPECT_EQ(123, env->GetArrayLength(reinterpret_cast<jarray>(o123)));
1905 EXPECT_EQ(124, env->GetArrayLength(reinterpret_cast<jarray>(o124)));
1906 EXPECT_EQ(125, env->GetArrayLength(reinterpret_cast<jarray>(o125)));
1907 EXPECT_EQ(126, env->GetArrayLength(reinterpret_cast<jarray>(o126)));
1908 EXPECT_EQ(127, env->GetArrayLength(reinterpret_cast<jarray>(o127)));
1909 EXPECT_EQ(128, env->GetArrayLength(reinterpret_cast<jarray>(o128)));
1910 EXPECT_EQ(129, env->GetArrayLength(reinterpret_cast<jarray>(o129)));
1911 EXPECT_EQ(130, env->GetArrayLength(reinterpret_cast<jarray>(o130)));
1912 EXPECT_EQ(131, env->GetArrayLength(reinterpret_cast<jarray>(o131)));
1913 EXPECT_EQ(132, env->GetArrayLength(reinterpret_cast<jarray>(o132)));
1914 EXPECT_EQ(133, env->GetArrayLength(reinterpret_cast<jarray>(o133)));
1915 EXPECT_EQ(134, env->GetArrayLength(reinterpret_cast<jarray>(o134)));
1916 EXPECT_EQ(135, env->GetArrayLength(reinterpret_cast<jarray>(o135)));
1917 EXPECT_EQ(136, env->GetArrayLength(reinterpret_cast<jarray>(o136)));
1918 EXPECT_EQ(137, env->GetArrayLength(reinterpret_cast<jarray>(o137)));
1919 EXPECT_EQ(138, env->GetArrayLength(reinterpret_cast<jarray>(o138)));
1920 EXPECT_EQ(139, env->GetArrayLength(reinterpret_cast<jarray>(o139)));
1921 EXPECT_EQ(140, env->GetArrayLength(reinterpret_cast<jarray>(o140)));
1922 EXPECT_EQ(141, env->GetArrayLength(reinterpret_cast<jarray>(o141)));
1923 EXPECT_EQ(142, env->GetArrayLength(reinterpret_cast<jarray>(o142)));
1924 EXPECT_EQ(143, env->GetArrayLength(reinterpret_cast<jarray>(o143)));
1925 EXPECT_EQ(144, env->GetArrayLength(reinterpret_cast<jarray>(o144)));
1926 EXPECT_EQ(145, env->GetArrayLength(reinterpret_cast<jarray>(o145)));
1927 EXPECT_EQ(146, env->GetArrayLength(reinterpret_cast<jarray>(o146)));
1928 EXPECT_EQ(147, env->GetArrayLength(reinterpret_cast<jarray>(o147)));
1929 EXPECT_EQ(148, env->GetArrayLength(reinterpret_cast<jarray>(o148)));
1930 EXPECT_EQ(149, env->GetArrayLength(reinterpret_cast<jarray>(o149)));
1931 EXPECT_EQ(150, env->GetArrayLength(reinterpret_cast<jarray>(o150)));
1932 EXPECT_EQ(151, env->GetArrayLength(reinterpret_cast<jarray>(o151)));
1933 EXPECT_EQ(152, env->GetArrayLength(reinterpret_cast<jarray>(o152)));
1934 EXPECT_EQ(153, env->GetArrayLength(reinterpret_cast<jarray>(o153)));
1935 EXPECT_EQ(154, env->GetArrayLength(reinterpret_cast<jarray>(o154)));
1936 EXPECT_EQ(155, env->GetArrayLength(reinterpret_cast<jarray>(o155)));
1937 EXPECT_EQ(156, env->GetArrayLength(reinterpret_cast<jarray>(o156)));
1938 EXPECT_EQ(157, env->GetArrayLength(reinterpret_cast<jarray>(o157)));
1939 EXPECT_EQ(158, env->GetArrayLength(reinterpret_cast<jarray>(o158)));
1940 EXPECT_EQ(159, env->GetArrayLength(reinterpret_cast<jarray>(o159)));
1941 EXPECT_EQ(160, env->GetArrayLength(reinterpret_cast<jarray>(o160)));
1942 EXPECT_EQ(161, env->GetArrayLength(reinterpret_cast<jarray>(o161)));
1943 EXPECT_EQ(162, env->GetArrayLength(reinterpret_cast<jarray>(o162)));
1944 EXPECT_EQ(163, env->GetArrayLength(reinterpret_cast<jarray>(o163)));
1945 EXPECT_EQ(164, env->GetArrayLength(reinterpret_cast<jarray>(o164)));
1946 EXPECT_EQ(165, env->GetArrayLength(reinterpret_cast<jarray>(o165)));
1947 EXPECT_EQ(166, env->GetArrayLength(reinterpret_cast<jarray>(o166)));
1948 EXPECT_EQ(167, env->GetArrayLength(reinterpret_cast<jarray>(o167)));
1949 EXPECT_EQ(168, env->GetArrayLength(reinterpret_cast<jarray>(o168)));
1950 EXPECT_EQ(169, env->GetArrayLength(reinterpret_cast<jarray>(o169)));
1951 EXPECT_EQ(170, env->GetArrayLength(reinterpret_cast<jarray>(o170)));
1952 EXPECT_EQ(171, env->GetArrayLength(reinterpret_cast<jarray>(o171)));
1953 EXPECT_EQ(172, env->GetArrayLength(reinterpret_cast<jarray>(o172)));
1954 EXPECT_EQ(173, env->GetArrayLength(reinterpret_cast<jarray>(o173)));
1955 EXPECT_EQ(174, env->GetArrayLength(reinterpret_cast<jarray>(o174)));
1956 EXPECT_EQ(175, env->GetArrayLength(reinterpret_cast<jarray>(o175)));
1957 EXPECT_EQ(176, env->GetArrayLength(reinterpret_cast<jarray>(o176)));
1958 EXPECT_EQ(177, env->GetArrayLength(reinterpret_cast<jarray>(o177)));
1959 EXPECT_EQ(178, env->GetArrayLength(reinterpret_cast<jarray>(o178)));
1960 EXPECT_EQ(179, env->GetArrayLength(reinterpret_cast<jarray>(o179)));
1961 EXPECT_EQ(180, env->GetArrayLength(reinterpret_cast<jarray>(o180)));
1962 EXPECT_EQ(181, env->GetArrayLength(reinterpret_cast<jarray>(o181)));
1963 EXPECT_EQ(182, env->GetArrayLength(reinterpret_cast<jarray>(o182)));
1964 EXPECT_EQ(183, env->GetArrayLength(reinterpret_cast<jarray>(o183)));
1965 EXPECT_EQ(184, env->GetArrayLength(reinterpret_cast<jarray>(o184)));
1966 EXPECT_EQ(185, env->GetArrayLength(reinterpret_cast<jarray>(o185)));
1967 EXPECT_EQ(186, env->GetArrayLength(reinterpret_cast<jarray>(o186)));
1968 EXPECT_EQ(187, env->GetArrayLength(reinterpret_cast<jarray>(o187)));
1969 EXPECT_EQ(188, env->GetArrayLength(reinterpret_cast<jarray>(o188)));
1970 EXPECT_EQ(189, env->GetArrayLength(reinterpret_cast<jarray>(o189)));
1971 EXPECT_EQ(190, env->GetArrayLength(reinterpret_cast<jarray>(o190)));
1972 EXPECT_EQ(191, env->GetArrayLength(reinterpret_cast<jarray>(o191)));
1973 EXPECT_EQ(192, env->GetArrayLength(reinterpret_cast<jarray>(o192)));
1974 EXPECT_EQ(193, env->GetArrayLength(reinterpret_cast<jarray>(o193)));
1975 EXPECT_EQ(194, env->GetArrayLength(reinterpret_cast<jarray>(o194)));
1976 EXPECT_EQ(195, env->GetArrayLength(reinterpret_cast<jarray>(o195)));
1977 EXPECT_EQ(196, env->GetArrayLength(reinterpret_cast<jarray>(o196)));
1978 EXPECT_EQ(197, env->GetArrayLength(reinterpret_cast<jarray>(o197)));
1979 EXPECT_EQ(198, env->GetArrayLength(reinterpret_cast<jarray>(o198)));
1980 EXPECT_EQ(199, env->GetArrayLength(reinterpret_cast<jarray>(o199)));
1981 EXPECT_EQ(200, env->GetArrayLength(reinterpret_cast<jarray>(o200)));
1982 EXPECT_EQ(201, env->GetArrayLength(reinterpret_cast<jarray>(o201)));
1983 EXPECT_EQ(202, env->GetArrayLength(reinterpret_cast<jarray>(o202)));
1984 EXPECT_EQ(203, env->GetArrayLength(reinterpret_cast<jarray>(o203)));
1985 EXPECT_EQ(204, env->GetArrayLength(reinterpret_cast<jarray>(o204)));
1986 EXPECT_EQ(205, env->GetArrayLength(reinterpret_cast<jarray>(o205)));
1987 EXPECT_EQ(206, env->GetArrayLength(reinterpret_cast<jarray>(o206)));
1988 EXPECT_EQ(207, env->GetArrayLength(reinterpret_cast<jarray>(o207)));
1989 EXPECT_EQ(208, env->GetArrayLength(reinterpret_cast<jarray>(o208)));
1990 EXPECT_EQ(209, env->GetArrayLength(reinterpret_cast<jarray>(o209)));
1991 EXPECT_EQ(210, env->GetArrayLength(reinterpret_cast<jarray>(o210)));
1992 EXPECT_EQ(211, env->GetArrayLength(reinterpret_cast<jarray>(o211)));
1993 EXPECT_EQ(212, env->GetArrayLength(reinterpret_cast<jarray>(o212)));
1994 EXPECT_EQ(213, env->GetArrayLength(reinterpret_cast<jarray>(o213)));
1995 EXPECT_EQ(214, env->GetArrayLength(reinterpret_cast<jarray>(o214)));
1996 EXPECT_EQ(215, env->GetArrayLength(reinterpret_cast<jarray>(o215)));
1997 EXPECT_EQ(216, env->GetArrayLength(reinterpret_cast<jarray>(o216)));
1998 EXPECT_EQ(217, env->GetArrayLength(reinterpret_cast<jarray>(o217)));
1999 EXPECT_EQ(218, env->GetArrayLength(reinterpret_cast<jarray>(o218)));
2000 EXPECT_EQ(219, env->GetArrayLength(reinterpret_cast<jarray>(o219)));
2001 EXPECT_EQ(220, env->GetArrayLength(reinterpret_cast<jarray>(o220)));
2002 EXPECT_EQ(221, env->GetArrayLength(reinterpret_cast<jarray>(o221)));
2003 EXPECT_EQ(222, env->GetArrayLength(reinterpret_cast<jarray>(o222)));
2004 EXPECT_EQ(223, env->GetArrayLength(reinterpret_cast<jarray>(o223)));
2005 EXPECT_EQ(224, env->GetArrayLength(reinterpret_cast<jarray>(o224)));
2006 EXPECT_EQ(225, env->GetArrayLength(reinterpret_cast<jarray>(o225)));
2007 EXPECT_EQ(226, env->GetArrayLength(reinterpret_cast<jarray>(o226)));
2008 EXPECT_EQ(227, env->GetArrayLength(reinterpret_cast<jarray>(o227)));
2009 EXPECT_EQ(228, env->GetArrayLength(reinterpret_cast<jarray>(o228)));
2010 EXPECT_EQ(229, env->GetArrayLength(reinterpret_cast<jarray>(o229)));
2011 EXPECT_EQ(230, env->GetArrayLength(reinterpret_cast<jarray>(o230)));
2012 EXPECT_EQ(231, env->GetArrayLength(reinterpret_cast<jarray>(o231)));
2013 EXPECT_EQ(232, env->GetArrayLength(reinterpret_cast<jarray>(o232)));
2014 EXPECT_EQ(233, env->GetArrayLength(reinterpret_cast<jarray>(o233)));
2015 EXPECT_EQ(234, env->GetArrayLength(reinterpret_cast<jarray>(o234)));
2016 EXPECT_EQ(235, env->GetArrayLength(reinterpret_cast<jarray>(o235)));
2017 EXPECT_EQ(236, env->GetArrayLength(reinterpret_cast<jarray>(o236)));
2018 EXPECT_EQ(237, env->GetArrayLength(reinterpret_cast<jarray>(o237)));
2019 EXPECT_EQ(238, env->GetArrayLength(reinterpret_cast<jarray>(o238)));
2020 EXPECT_EQ(239, env->GetArrayLength(reinterpret_cast<jarray>(o239)));
2021 EXPECT_EQ(240, env->GetArrayLength(reinterpret_cast<jarray>(o240)));
2022 EXPECT_EQ(241, env->GetArrayLength(reinterpret_cast<jarray>(o241)));
2023 EXPECT_EQ(242, env->GetArrayLength(reinterpret_cast<jarray>(o242)));
2024 EXPECT_EQ(243, env->GetArrayLength(reinterpret_cast<jarray>(o243)));
2025 EXPECT_EQ(244, env->GetArrayLength(reinterpret_cast<jarray>(o244)));
2026 EXPECT_EQ(245, env->GetArrayLength(reinterpret_cast<jarray>(o245)));
2027 EXPECT_EQ(246, env->GetArrayLength(reinterpret_cast<jarray>(o246)));
2028 EXPECT_EQ(247, env->GetArrayLength(reinterpret_cast<jarray>(o247)));
2029 EXPECT_EQ(248, env->GetArrayLength(reinterpret_cast<jarray>(o248)));
2030 EXPECT_EQ(249, env->GetArrayLength(reinterpret_cast<jarray>(o249)));
2031 EXPECT_EQ(250, env->GetArrayLength(reinterpret_cast<jarray>(o250)));
2032 EXPECT_EQ(251, env->GetArrayLength(reinterpret_cast<jarray>(o251)));
2033 EXPECT_EQ(252, env->GetArrayLength(reinterpret_cast<jarray>(o252)));
2034 EXPECT_EQ(253, env->GetArrayLength(reinterpret_cast<jarray>(o253)));
2035 }
2036 }
2037
2038 const char* longSig =
2039 "(Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2040 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2041 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2042 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2043 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2044 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2045 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2046 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2047 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2048 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2049 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2050 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2051 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2052 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2053 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2054 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2055 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2056 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2057 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2058 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2059 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2060 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2061 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2062 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2063 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2064 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2065 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2066 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2067 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2068 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2069 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2070 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2071 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2072 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2073 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2074 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2075 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2076 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2077 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2078 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2079 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2080 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2081 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2082 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2083 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2084 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2085 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2086 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2087 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2088 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;"
2089 "Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)V";
2090
MaxParamNumberImpl()2091 void JniCompilerTest::MaxParamNumberImpl() {
2092 SetUpForTest(false, "maxParamNumber", longSig,
2093 CURRENT_JNI_WRAPPER(Java_MyClassNatives_maxParamNumber));
2094
2095 jvalue args[254];
2096
2097 // First test: test with all arguments null.
2098 for (int i = 0; i < 254; ++i) {
2099 args[i].l = nullptr;
2100 }
2101
2102 env_->CallNonvirtualVoidMethodA(jobj_, jklass_, jmethod_, args);
2103
2104 // Second test: test with int[] objects with increasing lengths
2105 for (int i = 0; i < 254; ++i) {
2106 jintArray tmp = env_->NewIntArray(i);
2107 args[i].l = tmp;
2108 EXPECT_NE(args[i].l, nullptr);
2109 }
2110
2111 env_->CallNonvirtualVoidMethodA(jobj_, jklass_, jmethod_, args);
2112 }
2113
JNI_TEST(MaxParamNumber)2114 JNI_TEST(MaxParamNumber)
2115
2116 void JniCompilerTest::WithoutImplementationImpl() {
2117 // This will lead to error messages in the log.
2118 ScopedLogSeverity sls(LogSeverity::FATAL);
2119
2120 SetUpForTest(false, "withoutImplementation", "()V", NORMAL_OR_FAST_JNI_ONLY_NULLPTR);
2121
2122 env_->CallVoidMethod(jobj_, jmethod_);
2123
2124 EXPECT_TRUE(Thread::Current()->IsExceptionPending());
2125 EXPECT_TRUE(env_->ExceptionCheck() == JNI_TRUE);
2126 }
2127
JNI_TEST(WithoutImplementation)2128 JNI_TEST(WithoutImplementation)
2129
2130 void JniCompilerTest::WithoutImplementationRefReturnImpl() {
2131 // This will lead to error messages in the log.
2132 ScopedLogSeverity sls(LogSeverity::FATAL);
2133
2134 SetUpForTest(false,
2135 "withoutImplementationRefReturn",
2136 "()Ljava/lang/Object;",
2137 NORMAL_OR_FAST_JNI_ONLY_NULLPTR);
2138
2139 env_->CallObjectMethod(jobj_, jmethod_);
2140
2141 EXPECT_TRUE(Thread::Current()->IsExceptionPending());
2142 EXPECT_TRUE(env_->ExceptionCheck() == JNI_TRUE);
2143 }
2144
JNI_TEST(WithoutImplementationRefReturn)2145 JNI_TEST(WithoutImplementationRefReturn)
2146
2147 void JniCompilerTest::StaticWithoutImplementationImpl() {
2148 // This will lead to error messages in the log.
2149 ScopedLogSeverity sls(LogSeverity::FATAL);
2150
2151 SetUpForTest(true, "staticWithoutImplementation", "()V", nullptr);
2152
2153 env_->CallStaticVoidMethod(jklass_, jmethod_);
2154
2155 EXPECT_TRUE(Thread::Current()->IsExceptionPending());
2156 EXPECT_TRUE(env_->ExceptionCheck() == JNI_TRUE);
2157 }
2158
JNI_TEST_CRITICAL(StaticWithoutImplementation)2159 JNI_TEST_CRITICAL(StaticWithoutImplementation)
2160
2161 void Java_MyClassNatives_stackArgsIntsFirst(JNIEnv*, jclass, jint i1, jint i2, jint i3,
2162 jint i4, jint i5, jint i6, jint i7, jint i8, jint i9,
2163 jint i10, jfloat f1, jfloat f2, jfloat f3, jfloat f4,
2164 jfloat f5, jfloat f6, jfloat f7, jfloat f8, jfloat f9,
2165 jfloat f10) {
2166 EXPECT_EQ(i1, 1);
2167 EXPECT_EQ(i2, 2);
2168 EXPECT_EQ(i3, 3);
2169 EXPECT_EQ(i4, 4);
2170 EXPECT_EQ(i5, 5);
2171 EXPECT_EQ(i6, 6);
2172 EXPECT_EQ(i7, 7);
2173 EXPECT_EQ(i8, 8);
2174 EXPECT_EQ(i9, 9);
2175 EXPECT_EQ(i10, 10);
2176
2177 jint i11 = bit_cast<jint, jfloat>(f1);
2178 EXPECT_EQ(i11, 11);
2179 jint i12 = bit_cast<jint, jfloat>(f2);
2180 EXPECT_EQ(i12, 12);
2181 jint i13 = bit_cast<jint, jfloat>(f3);
2182 EXPECT_EQ(i13, 13);
2183 jint i14 = bit_cast<jint, jfloat>(f4);
2184 EXPECT_EQ(i14, 14);
2185 jint i15 = bit_cast<jint, jfloat>(f5);
2186 EXPECT_EQ(i15, 15);
2187 jint i16 = bit_cast<jint, jfloat>(f6);
2188 EXPECT_EQ(i16, 16);
2189 jint i17 = bit_cast<jint, jfloat>(f7);
2190 EXPECT_EQ(i17, 17);
2191 jint i18 = bit_cast<jint, jfloat>(f8);
2192 EXPECT_EQ(i18, 18);
2193 jint i19 = bit_cast<jint, jfloat>(f9);
2194 EXPECT_EQ(i19, 19);
2195 jint i20 = bit_cast<jint, jfloat>(f10);
2196 EXPECT_EQ(i20, 20);
2197 }
2198
StackArgsIntsFirstImpl()2199 void JniCompilerTest::StackArgsIntsFirstImpl() {
2200 SetUpForTest(true, "stackArgsIntsFirst", "(IIIIIIIIIIFFFFFFFFFF)V",
2201 CURRENT_JNI_WRAPPER(Java_MyClassNatives_stackArgsIntsFirst));
2202
2203 jint i1 = 1;
2204 jint i2 = 2;
2205 jint i3 = 3;
2206 jint i4 = 4;
2207 jint i5 = 5;
2208 jint i6 = 6;
2209 jint i7 = 7;
2210 jint i8 = 8;
2211 jint i9 = 9;
2212 jint i10 = 10;
2213
2214 jfloat f1 = bit_cast<jfloat, jint>(11);
2215 jfloat f2 = bit_cast<jfloat, jint>(12);
2216 jfloat f3 = bit_cast<jfloat, jint>(13);
2217 jfloat f4 = bit_cast<jfloat, jint>(14);
2218 jfloat f5 = bit_cast<jfloat, jint>(15);
2219 jfloat f6 = bit_cast<jfloat, jint>(16);
2220 jfloat f7 = bit_cast<jfloat, jint>(17);
2221 jfloat f8 = bit_cast<jfloat, jint>(18);
2222 jfloat f9 = bit_cast<jfloat, jint>(19);
2223 jfloat f10 = bit_cast<jfloat, jint>(20);
2224
2225 env_->CallStaticVoidMethod(jklass_, jmethod_, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, f1, f2,
2226 f3, f4, f5, f6, f7, f8, f9, f10);
2227 }
2228
JNI_TEST_CRITICAL(StackArgsIntsFirst)2229 JNI_TEST_CRITICAL(StackArgsIntsFirst)
2230
2231 void Java_MyClassNatives_stackArgsFloatsFirst(JNIEnv*, jclass, jfloat f1, jfloat f2,
2232 jfloat f3, jfloat f4, jfloat f5, jfloat f6, jfloat f7,
2233 jfloat f8, jfloat f9, jfloat f10, jint i1, jint i2,
2234 jint i3, jint i4, jint i5, jint i6, jint i7, jint i8,
2235 jint i9, jint i10) {
2236 EXPECT_EQ(i1, 1);
2237 EXPECT_EQ(i2, 2);
2238 EXPECT_EQ(i3, 3);
2239 EXPECT_EQ(i4, 4);
2240 EXPECT_EQ(i5, 5);
2241 EXPECT_EQ(i6, 6);
2242 EXPECT_EQ(i7, 7);
2243 EXPECT_EQ(i8, 8);
2244 EXPECT_EQ(i9, 9);
2245 EXPECT_EQ(i10, 10);
2246
2247 jint i11 = bit_cast<jint, jfloat>(f1);
2248 EXPECT_EQ(i11, 11);
2249 jint i12 = bit_cast<jint, jfloat>(f2);
2250 EXPECT_EQ(i12, 12);
2251 jint i13 = bit_cast<jint, jfloat>(f3);
2252 EXPECT_EQ(i13, 13);
2253 jint i14 = bit_cast<jint, jfloat>(f4);
2254 EXPECT_EQ(i14, 14);
2255 jint i15 = bit_cast<jint, jfloat>(f5);
2256 EXPECT_EQ(i15, 15);
2257 jint i16 = bit_cast<jint, jfloat>(f6);
2258 EXPECT_EQ(i16, 16);
2259 jint i17 = bit_cast<jint, jfloat>(f7);
2260 EXPECT_EQ(i17, 17);
2261 jint i18 = bit_cast<jint, jfloat>(f8);
2262 EXPECT_EQ(i18, 18);
2263 jint i19 = bit_cast<jint, jfloat>(f9);
2264 EXPECT_EQ(i19, 19);
2265 jint i20 = bit_cast<jint, jfloat>(f10);
2266 EXPECT_EQ(i20, 20);
2267 }
2268
StackArgsFloatsFirstImpl()2269 void JniCompilerTest::StackArgsFloatsFirstImpl() {
2270 SetUpForTest(true, "stackArgsFloatsFirst", "(FFFFFFFFFFIIIIIIIIII)V",
2271 CURRENT_JNI_WRAPPER(Java_MyClassNatives_stackArgsFloatsFirst));
2272
2273 jint i1 = 1;
2274 jint i2 = 2;
2275 jint i3 = 3;
2276 jint i4 = 4;
2277 jint i5 = 5;
2278 jint i6 = 6;
2279 jint i7 = 7;
2280 jint i8 = 8;
2281 jint i9 = 9;
2282 jint i10 = 10;
2283
2284 jfloat f1 = bit_cast<jfloat, jint>(11);
2285 jfloat f2 = bit_cast<jfloat, jint>(12);
2286 jfloat f3 = bit_cast<jfloat, jint>(13);
2287 jfloat f4 = bit_cast<jfloat, jint>(14);
2288 jfloat f5 = bit_cast<jfloat, jint>(15);
2289 jfloat f6 = bit_cast<jfloat, jint>(16);
2290 jfloat f7 = bit_cast<jfloat, jint>(17);
2291 jfloat f8 = bit_cast<jfloat, jint>(18);
2292 jfloat f9 = bit_cast<jfloat, jint>(19);
2293 jfloat f10 = bit_cast<jfloat, jint>(20);
2294
2295 env_->CallStaticVoidMethod(jklass_, jmethod_, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, i1, i2, i3,
2296 i4, i5, i6, i7, i8, i9, i10);
2297 }
2298
JNI_TEST_CRITICAL(StackArgsFloatsFirst)2299 JNI_TEST_CRITICAL(StackArgsFloatsFirst)
2300
2301 void Java_MyClassNatives_stackArgsMixed(JNIEnv*, jclass, jint i1, jfloat f1, jint i2,
2302 jfloat f2, jint i3, jfloat f3, jint i4, jfloat f4, jint i5,
2303 jfloat f5, jint i6, jfloat f6, jint i7, jfloat f7, jint i8,
2304 jfloat f8, jint i9, jfloat f9, jint i10, jfloat f10) {
2305 EXPECT_EQ(i1, 1);
2306 EXPECT_EQ(i2, 2);
2307 EXPECT_EQ(i3, 3);
2308 EXPECT_EQ(i4, 4);
2309 EXPECT_EQ(i5, 5);
2310 EXPECT_EQ(i6, 6);
2311 EXPECT_EQ(i7, 7);
2312 EXPECT_EQ(i8, 8);
2313 EXPECT_EQ(i9, 9);
2314 EXPECT_EQ(i10, 10);
2315
2316 jint i11 = bit_cast<jint, jfloat>(f1);
2317 EXPECT_EQ(i11, 11);
2318 jint i12 = bit_cast<jint, jfloat>(f2);
2319 EXPECT_EQ(i12, 12);
2320 jint i13 = bit_cast<jint, jfloat>(f3);
2321 EXPECT_EQ(i13, 13);
2322 jint i14 = bit_cast<jint, jfloat>(f4);
2323 EXPECT_EQ(i14, 14);
2324 jint i15 = bit_cast<jint, jfloat>(f5);
2325 EXPECT_EQ(i15, 15);
2326 jint i16 = bit_cast<jint, jfloat>(f6);
2327 EXPECT_EQ(i16, 16);
2328 jint i17 = bit_cast<jint, jfloat>(f7);
2329 EXPECT_EQ(i17, 17);
2330 jint i18 = bit_cast<jint, jfloat>(f8);
2331 EXPECT_EQ(i18, 18);
2332 jint i19 = bit_cast<jint, jfloat>(f9);
2333 EXPECT_EQ(i19, 19);
2334 jint i20 = bit_cast<jint, jfloat>(f10);
2335 EXPECT_EQ(i20, 20);
2336 }
2337
StackArgsMixedImpl()2338 void JniCompilerTest::StackArgsMixedImpl() {
2339 SetUpForTest(true, "stackArgsMixed", "(IFIFIFIFIFIFIFIFIFIF)V",
2340 CURRENT_JNI_WRAPPER(Java_MyClassNatives_stackArgsMixed));
2341
2342 jint i1 = 1;
2343 jint i2 = 2;
2344 jint i3 = 3;
2345 jint i4 = 4;
2346 jint i5 = 5;
2347 jint i6 = 6;
2348 jint i7 = 7;
2349 jint i8 = 8;
2350 jint i9 = 9;
2351 jint i10 = 10;
2352
2353 jfloat f1 = bit_cast<jfloat, jint>(11);
2354 jfloat f2 = bit_cast<jfloat, jint>(12);
2355 jfloat f3 = bit_cast<jfloat, jint>(13);
2356 jfloat f4 = bit_cast<jfloat, jint>(14);
2357 jfloat f5 = bit_cast<jfloat, jint>(15);
2358 jfloat f6 = bit_cast<jfloat, jint>(16);
2359 jfloat f7 = bit_cast<jfloat, jint>(17);
2360 jfloat f8 = bit_cast<jfloat, jint>(18);
2361 jfloat f9 = bit_cast<jfloat, jint>(19);
2362 jfloat f10 = bit_cast<jfloat, jint>(20);
2363
2364 env_->CallStaticVoidMethod(jklass_, jmethod_, i1, f1, i2, f2, i3, f3, i4, f4, i5, f5, i6, f6, i7,
2365 f7, i8, f8, i9, f9, i10, f10);
2366 }
2367
JNI_TEST_CRITICAL(StackArgsMixed)2368 JNI_TEST_CRITICAL(StackArgsMixed)
2369
2370 void Java_MyClassNatives_normalNative(JNIEnv*, jclass) {
2371 // Intentionally left empty.
2372 }
2373
2374 // Methods not annotated with anything are not considered "fast native"
2375 // -- Check that the annotation lookup does not find it.
NormalNativeImpl()2376 void JniCompilerTest::NormalNativeImpl() {
2377 SetUpForTest(/* direct= */ true,
2378 "normalNative",
2379 "()V",
2380 CURRENT_JNI_WRAPPER(Java_MyClassNatives_normalNative));
2381
2382 ArtMethod* method = jni::DecodeArtMethod(jmethod_);
2383 ASSERT_TRUE(method != nullptr);
2384
2385 EXPECT_FALSE(method->IsCriticalNative());
2386 EXPECT_FALSE(method->IsFastNative());
2387 }
2388
2389 // TODO: just rename the java functions to the standard convention and remove duplicated tests
JNI_TEST_NORMAL_ONLY(NormalNative)2390 JNI_TEST_NORMAL_ONLY(NormalNative)
2391
2392 // Methods annotated with @FastNative are considered "fast native"
2393 // -- Check that the annotation lookup succeeds.
2394 void Java_MyClassNatives_fastNative(JNIEnv*, jclass) {
2395 // Intentionally left empty.
2396 }
2397
FastNativeImpl()2398 void JniCompilerTest::FastNativeImpl() {
2399 SetUpForTest(/* direct= */ true,
2400 "fastNative",
2401 "()V",
2402 CURRENT_JNI_WRAPPER(Java_MyClassNatives_fastNative));
2403
2404 ArtMethod* method = jni::DecodeArtMethod(jmethod_);
2405 ASSERT_TRUE(method != nullptr);
2406
2407 EXPECT_FALSE(method->IsCriticalNative());
2408 EXPECT_TRUE(method->IsFastNative());
2409 }
2410
2411 // TODO: just rename the java functions to the standard convention and remove duplicated tests
2412 JNI_TEST_NORMAL_ONLY(FastNative)
2413
2414 int gJava_myClassNatives_criticalNative_calls[kJniKindCount] = {};
2415 // Methods annotated with @CriticalNative are considered "critical native"
2416 // -- Check that the annotation lookup succeeds.
Java_MyClassNatives_criticalNative()2417 void Java_MyClassNatives_criticalNative() {
2418 gJava_myClassNatives_criticalNative_calls[gCurrentJni]++;
2419 }
2420
CriticalNativeImpl()2421 void JniCompilerTest::CriticalNativeImpl() {
2422 SetUpForTest(/* direct= */ true,
2423 // Important: Don't change the "current jni" yet to avoid a method name suffix.
2424 "criticalNative",
2425 "()V",
2426 // TODO: Use CURRENT_JNI_WRAPPER instead which is more generic.
2427 reinterpret_cast<void*>(&Java_MyClassNatives_criticalNative));
2428
2429 // TODO: remove this manual updating of the current JNI. Merge with the other tests.
2430 UpdateCurrentJni(JniKind::kCritical);
2431 ASSERT_TRUE(IsCurrentJniCritical());
2432
2433 ArtMethod* method = jni::DecodeArtMethod(jmethod_);
2434 ASSERT_TRUE(method != nullptr);
2435
2436 EXPECT_TRUE(method->IsCriticalNative());
2437 EXPECT_FALSE(method->IsFastNative());
2438
2439 EXPECT_EQ(0, gJava_myClassNatives_criticalNative_calls[gCurrentJni]);
2440 env_->CallStaticVoidMethod(jklass_, jmethod_);
2441 EXPECT_EQ(1, gJava_myClassNatives_criticalNative_calls[gCurrentJni]);
2442
2443 gJava_myClassNatives_criticalNative_calls[gCurrentJni] = 0;
2444 }
2445
2446 // TODO: just rename the java functions to the standard convention and remove duplicated tests
2447 JNI_TEST_NORMAL_ONLY(CriticalNative)
2448
2449 } // namespace art
2450