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 =
247 hs.NewHandle(class_linker_->FindClass(self, "LMyClassNatives;", loader));
248 const auto pointer_size = class_linker_->GetImagePointerSize();
249 ArtMethod* method = c->FindClassMethod(method_name, method_sig, pointer_size);
250 ASSERT_TRUE(method != nullptr) << method_name << " " << method_sig;
251 ASSERT_EQ(direct, method->IsDirect()) << method_name << " " << method_sig;
252 if (direct) {
253 // Class initialization could replace the entrypoint, so force
254 // the initialization before we set up the entrypoint below.
255 class_linker_->EnsureInitialized(
256 self, c, /*can_init_fields=*/ true, /*can_init_parents=*/ true);
257 {
258 ScopedThreadSuspension sts(self, ThreadState::kNative);
259 class_linker_->MakeInitializedClassesVisiblyInitialized(self, /*wait=*/ true);
260 }
261 }
262 if (check_generic_jni_) {
263 method->SetEntryPointFromQuickCompiledCode(class_linker_->GetRuntimeQuickGenericJniStub());
264 } else {
265 const void* code = method->GetEntryPointFromQuickCompiledCode();
266 if (code == nullptr || class_linker_->IsQuickGenericJniStub(code)) {
267 CompileMethod(method);
268 ASSERT_TRUE(method->GetEntryPointFromQuickCompiledCode() != nullptr)
269 << method_name << " " << method_sig;
270 }
271 }
272 }
273
274 protected:
CompileForTestWithCurrentJni(jobject class_loader,bool direct,const char * method_name_orig,const char * method_sig)275 void CompileForTestWithCurrentJni(jobject class_loader,
276 bool direct,
277 const char* method_name_orig,
278 const char* method_sig) {
279 // Append the JNI kind to the method name, so that we automatically get the
280 // fast or critical versions of the same method.
281 std::string method_name_str = std::string(method_name_orig) + CurrentJniStringSuffix();
282 const char* method_name = method_name_str.c_str();
283
284 CompileForTest(class_loader, direct, method_name, method_sig);
285 }
286
SetUpForTest(bool direct,const char * method_name_orig,const char * method_sig,void * native_fnptr)287 void SetUpForTest(bool direct,
288 const char* method_name_orig,
289 const char* method_sig,
290 void* native_fnptr) {
291 // Append the JNI kind to the method name, so that we automatically get the
292 // fast or critical versions of the same method.
293 std::string method_name_str = std::string(method_name_orig) + CurrentJniStringSuffix();
294 const char* method_name = method_name_str.c_str();
295
296 // Initialize class loader and compile method when runtime not started.
297 if (!runtime_->IsStarted()) {
298 {
299 ScopedObjectAccess soa(Thread::Current());
300 class_loader_ = LoadDex("MyClassNatives");
301 }
302 CompileForTest(class_loader_, direct, method_name, method_sig);
303 // Start runtime.
304 Thread::Current()->TransitionFromSuspendedToRunnable();
305 android::InitializeNativeLoader();
306 bool started = runtime_->Start();
307 CHECK(started);
308 }
309 // JNI operations after runtime start.
310 env_ = Thread::Current()->GetJniEnv();
311 jklass_ = env_->FindClass("MyClassNatives");
312 ASSERT_TRUE(jklass_ != nullptr) << method_name << " " << method_sig;
313
314 if (direct) {
315 jmethod_ = env_->GetStaticMethodID(jklass_, method_name, method_sig);
316 } else {
317 jmethod_ = env_->GetMethodID(jklass_, method_name, method_sig);
318 }
319 ASSERT_TRUE(jmethod_ != nullptr) << method_name << " " << method_sig;
320
321 // Make sure the test class is visibly initialized so that the RegisterNatives() below
322 // sets the JNI entrypoint rather than leaving it as null (this test pretends to be an
323 // AOT compiler and therefore the ClassLinker skips entrypoint initialization). Even
324 // if the ClassLinker initialized it with a stub, we would not want to test that here.
325 class_linker_->MakeInitializedClassesVisiblyInitialized(Thread::Current(), /*wait=*/ true);
326
327 if (native_fnptr != nullptr) {
328 JNINativeMethod methods[] = { { method_name, method_sig, native_fnptr } };
329 ASSERT_EQ(JNI_OK, env_->RegisterNatives(jklass_, methods, 1))
330 << method_name << " " << method_sig;
331 } else {
332 env_->UnregisterNatives(jklass_);
333 }
334
335 jmethodID constructor = env_->GetMethodID(jklass_, "<init>", "()V");
336 jobj_ = env_->NewObject(jklass_, constructor);
337 ASSERT_TRUE(jobj_ != nullptr) << method_name << " " << method_sig;
338 }
339
340 public:
341 // Available as statics so our JNI handlers can access these.
342 static jclass jklass_;
343 static jobject jobj_;
344 static jobject class_loader_;
345
346 static void AssertCallerObjectLocked(JNIEnv* env);
347
348 static LockWord GetLockWord(jobject obj);
349
350 protected:
351 // We have to list the methods here so we can share them between default and generic JNI.
352 void CompileAndRunNoArgMethodImpl();
353 void CompileAndRunIntMethodThroughStubImpl();
354 void CompileAndRunStaticIntMethodThroughStubImpl();
355 void CompileAndRunIntMethodImpl();
356 void CompileAndRunIntIntMethodImpl();
357 void CompileAndRunLongLongMethodImpl();
358 void CompileAndRunDoubleDoubleMethodImpl();
359 void CompileAndRun_fooJJ_synchronizedImpl();
360 void CompileAndRunIntObjectObjectMethodImpl();
361 void CompileAndRunStaticIntIntMethodImpl();
362 void CompileAndRunStaticDoubleDoubleMethodImpl();
363 void RunStaticLogDoubleMethodImpl();
364 void RunStaticLogFloatMethodImpl();
365 void RunStaticReturnTrueImpl();
366 void RunStaticReturnFalseImpl();
367 void RunGenericStaticReturnIntImpl();
368 void RunGenericStaticReturnDoubleImpl();
369 void RunGenericStaticReturnLongImpl();
370 void CompileAndRunStaticIntObjectObjectMethodImpl();
371 void CompileAndRunStaticSynchronizedIntObjectObjectMethodImpl();
372 void ExceptionHandlingImpl();
373 void NativeStackTraceElementImpl();
374 void ReturnGlobalRefImpl();
375 void LocalReferenceTableClearingTestImpl();
376 void JavaLangSystemArrayCopyImpl();
377 void CompareAndSwapIntImpl();
378 void GetTextImpl();
379 void GetSinkPropertiesNativeImpl();
380 void UpcallReturnTypeChecking_InstanceImpl();
381 void UpcallReturnTypeChecking_StaticImpl();
382 void UpcallArgumentTypeChecking_InstanceImpl();
383 void UpcallArgumentTypeChecking_StaticImpl();
384 void CompileAndRunFloatFloatMethodImpl();
385 void CheckParameterAlignImpl();
386 void MaxParamNumberImpl();
387 void WithoutImplementationImpl();
388 void WithoutImplementationRefReturnImpl();
389 void StaticWithoutImplementationImpl();
390 void StackArgsIntsFirstImpl();
391 void StackArgsFloatsFirstImpl();
392 void StackArgsMixedImpl();
393
394 void NormalNativeImpl();
395 void FastNativeImpl();
396 void CriticalNativeImpl();
397
398 JNIEnv* env_;
399 jmethodID jmethod_;
400
401 private:
402 bool check_generic_jni_;
403 };
404
405 jclass JniCompilerTest::jklass_;
406 jobject JniCompilerTest::jobj_;
407 jobject JniCompilerTest::class_loader_;
408
AssertCallerObjectLocked(JNIEnv * env)409 void JniCompilerTest::AssertCallerObjectLocked(JNIEnv* env) {
410 Thread* self = Thread::ForEnv(env);
411 CHECK_EQ(self, Thread::Current());
412 ScopedObjectAccess soa(self);
413 ArtMethod** caller_frame = self->GetManagedStack()->GetTopQuickFrame();
414 CHECK(caller_frame != nullptr);
415 ArtMethod* caller = *caller_frame;
416 CHECK(caller != nullptr);
417 CHECK(caller->IsNative());
418 CHECK(!caller->IsFastNative());
419 CHECK(!caller->IsCriticalNative());
420 CHECK(caller->IsSynchronized());
421 ObjPtr<mirror::Object> lock;
422 if (self->GetManagedStack()->GetTopQuickFrameGenericJniTag()) {
423 // Generic JNI.
424 lock = GetGenericJniSynchronizationObject(self, caller);
425 } else if (caller->IsStatic()) {
426 lock = caller->GetDeclaringClass();
427 } else {
428 uint8_t* sp = reinterpret_cast<uint8_t*>(caller_frame);
429 const void* code_ptr = EntryPointToCodePointer(caller->GetEntryPointFromQuickCompiledCode());
430 OatQuickMethodHeader* method_header = OatQuickMethodHeader::FromCodePointer(code_ptr);
431 size_t frame_size = method_header->GetFrameSizeInBytes();
432 StackReference<mirror::Object>* this_ref = reinterpret_cast<StackReference<mirror::Object>*>(
433 sp + frame_size + static_cast<size_t>(kRuntimePointerSize));
434 lock = this_ref->AsMirrorPtr();
435 }
436 CHECK_EQ(Monitor::GetLockOwnerThreadId(lock), self->GetThreadId());
437 }
438
GetLockWord(jobject obj)439 LockWord JniCompilerTest::GetLockWord(jobject obj) {
440 ScopedObjectAccess soa(Thread::Current());
441 return soa.Decode<mirror::Object>(obj)->GetLockWord(/*as_volatile=*/ false);
442 }
443
444 // Test the normal compiler and normal generic JNI only.
445 // The following features are unsupported in @FastNative:
446 // 1) synchronized keyword
447 # define JNI_TEST_NORMAL_ONLY(TestName) \
448 TEST_F(JniCompilerTest, TestName ## NormalCompiler) { \
449 ScopedCheckHandleScope top_handle_scope_check; \
450 SCOPED_TRACE("Normal JNI with compiler"); \
451 gCurrentJni = static_cast<uint32_t>(JniKind::kNormal); \
452 TestName ## Impl(); \
453 } \
454 TEST_F(JniCompilerTest, TestName ## NormalGeneric) { \
455 ScopedCheckHandleScope top_handle_scope_check; \
456 SCOPED_TRACE("Normal JNI with generic"); \
457 gCurrentJni = static_cast<uint32_t>(JniKind::kNormal); \
458 SetCheckGenericJni(true); \
459 TestName ## Impl(); \
460 }
461
462 // Test (normal, @FastNative) x (compiler, generic).
463 #define JNI_TEST(TestName) \
464 JNI_TEST_NORMAL_ONLY(TestName) \
465 TEST_F(JniCompilerTest, TestName ## FastCompiler) { \
466 ScopedCheckHandleScope top_handle_scope_check; \
467 SCOPED_TRACE("@FastNative JNI with compiler"); \
468 gCurrentJni = static_cast<uint32_t>(JniKind::kFast); \
469 TestName ## Impl(); \
470 } \
471 \
472 TEST_F(JniCompilerTest, TestName ## FastGeneric) { \
473 ScopedCheckHandleScope top_handle_scope_check; \
474 SCOPED_TRACE("@FastNative JNI with generic"); \
475 gCurrentJni = static_cast<uint32_t>(JniKind::kFast); \
476 SetCheckGenericJni(true); \
477 TestName ## Impl(); \
478 }
479
480 // Test (@CriticalNative) x (compiler, generic) only.
481 #define JNI_TEST_CRITICAL_ONLY(TestName) \
482 TEST_F(JniCompilerTest, TestName ## CriticalCompiler) { \
483 ScopedCheckHandleScope top_handle_scope_check; \
484 SCOPED_TRACE("@CriticalNative JNI with compiler"); \
485 gCurrentJni = static_cast<uint32_t>(JniKind::kCritical); \
486 TestName ## Impl(); \
487 } \
488 TEST_F(JniCompilerTest, TestName ## CriticalGeneric) { \
489 ScopedCheckHandleScope top_handle_scope_check; \
490 SCOPED_TRACE("@CriticalNative JNI with generic"); \
491 gCurrentJni = static_cast<uint32_t>(JniKind::kCritical); \
492 SetCheckGenericJni(true); \
493 TestName ## Impl(); \
494 }
495
496 // Test everything: (normal, @FastNative, @CriticalNative) x (compiler, generic).
497 #define JNI_TEST_CRITICAL(TestName) \
498 JNI_TEST(TestName) \
499 JNI_TEST_CRITICAL_ONLY(TestName) \
500
expectValidThreadState()501 static void expectValidThreadState() {
502 // Normal JNI always transitions to "Native". Other JNIs stay in the "Runnable" state.
503 if (IsCurrentJniNormal()) {
504 EXPECT_EQ(ThreadState::kNative, Thread::Current()->GetState());
505 } else {
506 EXPECT_EQ(ThreadState::kRunnable, Thread::Current()->GetState());
507 }
508 }
509
510 #define EXPECT_THREAD_STATE_FOR_CURRENT_JNI() expectValidThreadState()
511
expectValidMutatorLockHeld()512 static void expectValidMutatorLockHeld() {
513 if (IsCurrentJniNormal()) {
514 Locks::mutator_lock_->AssertNotHeld(Thread::Current());
515 } else {
516 Locks::mutator_lock_->AssertSharedHeld(Thread::Current());
517 }
518 }
519
520 #define EXPECT_MUTATOR_LOCK_FOR_CURRENT_JNI() expectValidMutatorLockHeld()
521
expectValidJniEnvAndObject(JNIEnv * env,jobject thisObj)522 static void expectValidJniEnvAndObject(JNIEnv* env, jobject thisObj) {
523 if (!IsCurrentJniCritical()) {
524 EXPECT_EQ(Thread::Current()->GetJniEnv(), env);
525 ASSERT_TRUE(thisObj != nullptr);
526 EXPECT_TRUE(env->IsInstanceOf(thisObj, JniCompilerTest::jklass_));
527 } else {
528 LOG(FATAL) << "Objects are not supported for @CriticalNative, why is this being tested?";
529 UNREACHABLE();
530 }
531 }
532
533 // Validates the JNIEnv to be the same as the current thread's JNIEnv, and makes sure
534 // that the object here is an instance of the class we registered the method with.
535 //
536 // Hard-fails if this somehow gets invoked for @CriticalNative since objects are unsupported.
537 #define EXPECT_JNI_ENV_AND_OBJECT_FOR_CURRENT_JNI(env, thisObj) \
538 expectValidJniEnvAndObject(env, thisObj)
539
expectValidJniEnvAndClass(JNIEnv * env,jclass kls)540 static void expectValidJniEnvAndClass(JNIEnv* env, jclass kls) {
541 if (!IsCurrentJniCritical()) {
542 EXPECT_EQ(Thread::Current()->GetJniEnv(), env);
543 ASSERT_TRUE(kls != nullptr);
544 EXPECT_TRUE(env->IsSameObject(static_cast<jobject>(JniCompilerTest::jklass_),
545 static_cast<jobject>(kls)));
546 } else {
547 // This is pretty much vacuously true but catch any testing setup mistakes.
548 EXPECT_EQ(env, kCriticalFakeJniEnv);
549 EXPECT_EQ(kls, kCriticalFakeJniClass);
550 }
551 }
552
553 // Validates the JNIEnv is the same as the current thread's JNIenv, and makes sure
554 // that the jclass we got in the JNI handler is the same one as the class the method was looked
555 // up for.
556 //
557 // (Checks are skipped for @CriticalNative since the two values are fake).
558 #define EXPECT_JNI_ENV_AND_CLASS_FOR_CURRENT_JNI(env, kls) expectValidJniEnvAndClass(env, kls)
559
560 // Temporarily disable the EXPECT_NUM_STACK_REFERENCES check (for a single test).
561 struct ScopedDisableCheckNumStackReferences {
ScopedDisableCheckNumStackReferencesart::ScopedDisableCheckNumStackReferences562 ScopedDisableCheckNumStackReferences() {
563 CHECK(sCheckNumStackReferences); // No nested support.
564 sCheckNumStackReferences = false;
565 }
566
~ScopedDisableCheckNumStackReferencesart::ScopedDisableCheckNumStackReferences567 ~ScopedDisableCheckNumStackReferences() {
568 sCheckNumStackReferences = true;
569 }
570
571 static bool sCheckNumStackReferences;
572 };
573
574 bool ScopedDisableCheckNumStackReferences::sCheckNumStackReferences = true;
575
576 // Check that the handle scope at the start of this block is the same
577 // as the handle scope at the end of the block.
578 struct ScopedCheckHandleScope {
ScopedCheckHandleScopeart::ScopedCheckHandleScope579 ScopedCheckHandleScope() : handle_scope_(Thread::Current()->GetTopHandleScope()) {
580 }
581
~ScopedCheckHandleScopeart::ScopedCheckHandleScope582 ~ScopedCheckHandleScope() {
583 EXPECT_EQ(handle_scope_, Thread::Current()->GetTopHandleScope())
584 << "Top-most handle scope must be the same after all the JNI "
585 << "invocations have finished (as before they were invoked).";
586 }
587
588 BaseHandleScope* const handle_scope_;
589 };
590
591 class CountReferencesVisitor : public RootVisitor {
592 public:
VisitRoots(mirror::Object *** roots,size_t count,const RootInfo & info)593 void VisitRoots([[maybe_unused]] mirror::Object*** roots,
594 size_t count,
595 const RootInfo& info) override REQUIRES_SHARED(Locks::mutator_lock_) {
596 if (info.GetType() == art::RootType::kRootJavaFrame) {
597 const JavaFrameRootInfo& jrfi = static_cast<const JavaFrameRootInfo&>(info);
598 if (jrfi.GetVReg() == JavaFrameRootInfo::kNativeReferenceArgument) {
599 DCHECK_EQ(count, 1u);
600 num_references_ += count;
601 }
602 }
603 }
604
VisitRoots(mirror::CompressedReference<mirror::Object> ** roots,size_t count,const RootInfo & info)605 void VisitRoots([[maybe_unused]] mirror::CompressedReference<mirror::Object>** roots,
606 [[maybe_unused]] size_t count,
607 const RootInfo& info) override REQUIRES_SHARED(Locks::mutator_lock_) {
608 CHECK_NE(info.GetType(), art::RootType::kRootJavaFrame);
609 }
610
NumReferences() const611 size_t NumReferences() const {
612 return num_references_;
613 }
614
615 private:
616 size_t num_references_ = 0u;
617 };
618
619 // Number of references allocated in handle scopes & JNI shadow frames on this thread.
NumStackReferences(Thread * self)620 static size_t NumStackReferences(Thread* self) REQUIRES_SHARED(Locks::mutator_lock_) {
621 CountReferencesVisitor visitor;
622 self->VisitRoots(&visitor, kVisitRootFlagAllRoots);
623 return visitor.NumReferences();
624 }
625
expectNumStackReferences(size_t expected)626 static void expectNumStackReferences(size_t expected) {
627 // In rare cases when JNI functions call themselves recursively,
628 // disable this test because it will have a false negative.
629 if (!IsCurrentJniCritical() && ScopedDisableCheckNumStackReferences::sCheckNumStackReferences) {
630 /* @CriticalNative doesn't build a HandleScope, so this test is meaningless then. */
631 ScopedObjectAccess soa(Thread::Current());
632
633 size_t num_references = NumStackReferences(Thread::Current());
634 EXPECT_EQ(expected, num_references);
635 }
636 }
637
638 #define EXPECT_NUM_STACK_REFERENCES(expected) expectNumStackReferences(expected)
639
640 template <typename T, T* fn>
641 struct make_jni_test_decorator;
642
643 // Decorator for "static" JNI callbacks.
644 template <typename R, typename ... Args, R (*fn)(JNIEnv*, jclass, Args...)>
645 struct make_jni_test_decorator<R(JNIEnv*, jclass kls, Args...), fn> {
applyart::make_jni_test_decorator646 static R apply(JNIEnv* env, jclass kls, Args ... args) {
647 EXPECT_THREAD_STATE_FOR_CURRENT_JNI();
648 EXPECT_MUTATOR_LOCK_FOR_CURRENT_JNI();
649 EXPECT_JNI_ENV_AND_CLASS_FOR_CURRENT_JNI(env, kls);
650 // All incoming parameters get spilled into the JNI transition frame.
651 // The `jclass` is just a reference to the method's declaring class field.
652 EXPECT_NUM_STACK_REFERENCES(count_nonnull_refs(args...));
653
654 return fn(env, kls, args...);
655 }
656 };
657
658 // Decorator for instance JNI callbacks.
659 template <typename R, typename ... Args, R (*fn)(JNIEnv*, jobject, Args...)>
660 struct make_jni_test_decorator<R(JNIEnv*, jobject, Args...), fn> {
applyart::make_jni_test_decorator661 static R apply(JNIEnv* env, jobject thisObj, Args ... args) {
662 EXPECT_THREAD_STATE_FOR_CURRENT_JNI();
663 EXPECT_MUTATOR_LOCK_FOR_CURRENT_JNI();
664 EXPECT_JNI_ENV_AND_OBJECT_FOR_CURRENT_JNI(env, thisObj);
665 // All incoming parameters + the implicit 'this' get spilled into the JNI transition frame.
666 EXPECT_NUM_STACK_REFERENCES(count_nonnull_refs(thisObj, args...));
667
668 return fn(env, thisObj, args...);
669 }
670 };
671
672 // Decorate the regular JNI callee with the extra gtest checks.
673 // This way we can have common test logic for everything generic like checking if a lock is held,
674 // checking handle scope state, etc.
675 #define MAKE_JNI_TEST_DECORATOR(fn) make_jni_test_decorator<decltype(fn), (fn)>::apply
676
677 // Convert function f(JNIEnv*,jclass,a,b,c,d...) into f2(a,b,c,d...)
678 // -- This way we don't have to write out each implementation twice for @CriticalNative.
679 #define JNI_CRITICAL_WRAPPER(func) jni_remove_extra_parameters<decltype(func), (func)>::apply
680 // Get a function pointer whose calling convention either matches a regular native
681 // or a critical native depending on which kind of jni is currently under test.
682 // -- This also has the benefit of genering a compile time error if the 'func' doesn't properly
683 // have JNIEnv and jclass parameters first.
684 #define CURRENT_JNI_WRAPPER(func) \
685 (IsCurrentJniCritical() \
686 ? reinterpret_cast<void*>(&JNI_CRITICAL_WRAPPER(MAKE_JNI_TEST_DECORATOR(func))) \
687 : reinterpret_cast<void*>(&MAKE_JNI_TEST_DECORATOR(func)))
688
689 // Do the opposite of the above. Do *not* wrap the function, instead just cast it to a void*.
690 // Only for "TEST_JNI_NORMAL_ONLY" configs, and it inserts a test assert to ensure this is the case.
691 #define NORMAL_JNI_ONLY_NOWRAP(func) \
692 ({ ASSERT_TRUE(IsCurrentJniNormal()); reinterpret_cast<void*>(&(func)); })
693 // Same as above, but with nullptr. When we want to test the stub functionality.
694 #define NORMAL_OR_FAST_JNI_ONLY_NULLPTR \
695 ({ ASSERT_TRUE(IsCurrentJniNormal() || IsCurrentJniFast()); nullptr; })
696
697
698 int gJava_MyClassNatives_foo_calls[kJniKindCount] = {};
Java_MyClassNatives_foo(JNIEnv *,jobject)699 void Java_MyClassNatives_foo(JNIEnv*, jobject) {
700 gJava_MyClassNatives_foo_calls[gCurrentJni]++;
701 }
702
CompileAndRunNoArgMethodImpl()703 void JniCompilerTest::CompileAndRunNoArgMethodImpl() {
704 SetUpForTest(false, "foo", "()V", CURRENT_JNI_WRAPPER(Java_MyClassNatives_foo));
705
706 EXPECT_EQ(0, gJava_MyClassNatives_foo_calls[gCurrentJni]);
707 env_->CallNonvirtualVoidMethod(jobj_, jklass_, jmethod_);
708 EXPECT_EQ(1, gJava_MyClassNatives_foo_calls[gCurrentJni]);
709 env_->CallNonvirtualVoidMethod(jobj_, jklass_, jmethod_);
710 EXPECT_EQ(2, gJava_MyClassNatives_foo_calls[gCurrentJni]);
711
712 gJava_MyClassNatives_foo_calls[gCurrentJni] = 0;
713 }
714
JNI_TEST(CompileAndRunNoArgMethod)715 JNI_TEST(CompileAndRunNoArgMethod)
716
717 void JniCompilerTest::CompileAndRunIntMethodThroughStubImpl() {
718 SetUpForTest(false, "bar", "(I)I", NORMAL_OR_FAST_JNI_ONLY_NULLPTR);
719 // calling through stub will link with &Java_MyClassNatives_bar{,_1Fast}
720
721 std::string reason;
722 ASSERT_TRUE(Runtime::Current()->GetJavaVM()->
723 LoadNativeLibrary(env_, "", class_loader_, nullptr, &reason))
724 << reason;
725
726 jint result = env_->CallNonvirtualIntMethod(jobj_, jklass_, jmethod_, 24);
727 EXPECT_EQ(25, result);
728 }
729
730 // Note: @CriticalNative is only for static methods.
JNI_TEST(CompileAndRunIntMethodThroughStub)731 JNI_TEST(CompileAndRunIntMethodThroughStub)
732
733 void JniCompilerTest::CompileAndRunStaticIntMethodThroughStubImpl() {
734 SetUpForTest(true, "sbar", "(I)I", nullptr);
735 // calling through stub will link with &Java_MyClassNatives_sbar{,_1Fast,_1Critical}
736
737 std::string reason;
738 ASSERT_TRUE(Runtime::Current()->GetJavaVM()->
739 LoadNativeLibrary(env_, "", class_loader_, nullptr, &reason))
740 << reason;
741
742 jint result = env_->CallStaticIntMethod(jklass_, jmethod_, 42);
743 EXPECT_EQ(43, result);
744 }
745
746 JNI_TEST_CRITICAL(CompileAndRunStaticIntMethodThroughStub)
747
748 int gJava_MyClassNatives_fooI_calls[kJniKindCount] = {};
Java_MyClassNatives_fooI(JNIEnv *,jobject,jint x)749 jint Java_MyClassNatives_fooI(JNIEnv*, jobject, jint x) {
750 gJava_MyClassNatives_fooI_calls[gCurrentJni]++;
751 return x;
752 }
753
CompileAndRunIntMethodImpl()754 void JniCompilerTest::CompileAndRunIntMethodImpl() {
755 SetUpForTest(false, "fooI", "(I)I",
756 CURRENT_JNI_WRAPPER(Java_MyClassNatives_fooI));
757
758 EXPECT_EQ(0, gJava_MyClassNatives_fooI_calls[gCurrentJni]);
759 jint result = env_->CallNonvirtualIntMethod(jobj_, jklass_, jmethod_, 42);
760 EXPECT_EQ(42, result);
761 EXPECT_EQ(1, gJava_MyClassNatives_fooI_calls[gCurrentJni]);
762 result = env_->CallNonvirtualIntMethod(jobj_, jklass_, jmethod_, 0xCAFED00D);
763 EXPECT_EQ(static_cast<jint>(0xCAFED00D), result);
764 EXPECT_EQ(2, gJava_MyClassNatives_fooI_calls[gCurrentJni]);
765
766 gJava_MyClassNatives_fooI_calls[gCurrentJni] = 0;
767 }
768
769 JNI_TEST(CompileAndRunIntMethod)
770
771 int gJava_MyClassNatives_fooII_calls[kJniKindCount] = {};
Java_MyClassNatives_fooII(JNIEnv *,jobject,jint x,jint y)772 jint Java_MyClassNatives_fooII(JNIEnv*, jobject, jint x, jint y) {
773 gJava_MyClassNatives_fooII_calls[gCurrentJni]++;
774 return x - y; // non-commutative operator
775 }
776
CompileAndRunIntIntMethodImpl()777 void JniCompilerTest::CompileAndRunIntIntMethodImpl() {
778 SetUpForTest(false, "fooII", "(II)I",
779 CURRENT_JNI_WRAPPER(Java_MyClassNatives_fooII));
780
781 EXPECT_EQ(0, gJava_MyClassNatives_fooII_calls[gCurrentJni]);
782 jint result = env_->CallNonvirtualIntMethod(jobj_, jklass_, jmethod_, 99, 10);
783 EXPECT_EQ(99 - 10, result);
784 EXPECT_EQ(1, gJava_MyClassNatives_fooII_calls[gCurrentJni]);
785 result = env_->CallNonvirtualIntMethod(jobj_, jklass_, jmethod_, 0xCAFEBABE,
786 0xCAFED00D);
787 EXPECT_EQ(static_cast<jint>(0xCAFEBABE - 0xCAFED00D), result);
788 EXPECT_EQ(2, gJava_MyClassNatives_fooII_calls[gCurrentJni]);
789
790 gJava_MyClassNatives_fooII_calls[gCurrentJni] = 0;
791 }
792
793 JNI_TEST(CompileAndRunIntIntMethod)
794
795 int gJava_MyClassNatives_fooJJ_calls[kJniKindCount] = {};
Java_MyClassNatives_fooJJ(JNIEnv *,jobject,jlong x,jlong y)796 jlong Java_MyClassNatives_fooJJ(JNIEnv*, jobject, jlong x, jlong y) {
797 gJava_MyClassNatives_fooJJ_calls[gCurrentJni]++;
798 return x - y; // non-commutative operator
799 }
800
CompileAndRunLongLongMethodImpl()801 void JniCompilerTest::CompileAndRunLongLongMethodImpl() {
802 SetUpForTest(false, "fooJJ", "(JJ)J",
803 CURRENT_JNI_WRAPPER(Java_MyClassNatives_fooJJ));
804
805 EXPECT_EQ(0, gJava_MyClassNatives_fooJJ_calls[gCurrentJni]);
806 jlong a = INT64_C(0x1234567890ABCDEF);
807 jlong b = INT64_C(0xFEDCBA0987654321);
808 jlong result = env_->CallNonvirtualLongMethod(jobj_, jklass_, jmethod_, a, b);
809 EXPECT_EQ(a - b, result);
810 EXPECT_EQ(1, gJava_MyClassNatives_fooJJ_calls[gCurrentJni]);
811 result = env_->CallNonvirtualLongMethod(jobj_, jklass_, jmethod_, b, a);
812 EXPECT_EQ(b - a, result);
813 EXPECT_EQ(2, gJava_MyClassNatives_fooJJ_calls[gCurrentJni]);
814
815 gJava_MyClassNatives_fooJJ_calls[gCurrentJni] = 0;
816 }
817
818 JNI_TEST(CompileAndRunLongLongMethod)
819
820 int gJava_MyClassNatives_fooDD_calls[kJniKindCount] = {};
Java_MyClassNatives_fooDD(JNIEnv *,jobject,jdouble x,jdouble y)821 jdouble Java_MyClassNatives_fooDD(JNIEnv*, jobject, jdouble x, jdouble y) {
822 gJava_MyClassNatives_fooDD_calls[gCurrentJni]++;
823 return x - y; // non-commutative operator
824 }
825
CompileAndRunDoubleDoubleMethodImpl()826 void JniCompilerTest::CompileAndRunDoubleDoubleMethodImpl() {
827 SetUpForTest(false, "fooDD", "(DD)D",
828 CURRENT_JNI_WRAPPER(Java_MyClassNatives_fooDD));
829
830 EXPECT_EQ(0, gJava_MyClassNatives_fooDD_calls[gCurrentJni]);
831 jdouble result = env_->CallNonvirtualDoubleMethod(jobj_, jklass_, jmethod_,
832 99.0, 10.0);
833 EXPECT_DOUBLE_EQ(99.0 - 10.0, result);
834 EXPECT_EQ(1, gJava_MyClassNatives_fooDD_calls[gCurrentJni]);
835 jdouble a = 3.14159265358979323846;
836 jdouble b = 0.69314718055994530942;
837 result = env_->CallNonvirtualDoubleMethod(jobj_, jklass_, jmethod_, a, b);
838 EXPECT_DOUBLE_EQ(a - b, result);
839 EXPECT_EQ(2, gJava_MyClassNatives_fooDD_calls[gCurrentJni]);
840
841 gJava_MyClassNatives_fooDD_calls[gCurrentJni] = 0;
842 }
843
844 int gJava_MyClassNatives_fooJJ_synchronized_calls[kJniKindCount] = {};
Java_MyClassNatives_fooJJ_synchronized(JNIEnv * env,jobject,jlong x,jlong y)845 jlong Java_MyClassNatives_fooJJ_synchronized(JNIEnv* env, jobject, jlong x, jlong y) {
846 JniCompilerTest::AssertCallerObjectLocked(env);
847 gJava_MyClassNatives_fooJJ_synchronized_calls[gCurrentJni]++;
848 return x | y;
849 }
850
851 EXPORT // Defined in `libart.so`.
852 void InitEntryPoints(JniEntryPoints* jpoints,
853 QuickEntryPoints* qpoints,
854 bool monitor_jni_entry_exit);
855
CompileAndRun_fooJJ_synchronizedImpl()856 void JniCompilerTest::CompileAndRun_fooJJ_synchronizedImpl() {
857 SetUpForTest(false, "fooJJ_synchronized", "(JJ)J",
858 CURRENT_JNI_WRAPPER(Java_MyClassNatives_fooJJ_synchronized));
859
860 EXPECT_EQ(0, gJava_MyClassNatives_fooJJ_synchronized_calls[gCurrentJni]);
861 jlong a = 0x1000000020000000ULL;
862 jlong b = 0x00ff000000aa0000ULL;
863 jlong result = env_->CallNonvirtualLongMethod(jobj_, jklass_, jmethod_, a, b);
864 EXPECT_EQ(a | b, result);
865 EXPECT_EQ(1, gJava_MyClassNatives_fooJJ_synchronized_calls[gCurrentJni]);
866
867 // Exercise recursive thin locking/unlocking.
868 // Note: Thin lock count 0 means locked once.
869 env_->MonitorEnter(jobj_);
870 LockWord lock_word = GetLockWord(jobj_);
871 ASSERT_EQ(lock_word.GetState(), LockWord::kThinLocked);
872 ASSERT_EQ(lock_word.ThinLockCount(), 0u);
873 result = env_->CallNonvirtualLongMethod(jobj_, jklass_, jmethod_, a, b);
874 EXPECT_EQ(a | b, result);
875 EXPECT_EQ(2, gJava_MyClassNatives_fooJJ_synchronized_calls[gCurrentJni]);
876 lock_word = GetLockWord(jobj_);
877 ASSERT_EQ(lock_word.GetState(), LockWord::kThinLocked);
878 ASSERT_EQ(lock_word.ThinLockCount(), 0u);
879 env_->MonitorExit(jobj_);
880 lock_word = GetLockWord(jobj_);
881 ASSERT_EQ(lock_word.GetState(), LockWord::kUnlocked);
882
883 // Exercise lock inflation due to thin lock count overflow.
884 constexpr uint32_t kMaxThinLockRecursiveLocks = 1u << LockWord::kThinLockCountSize;
885 for (uint32_t i = 0; i != kMaxThinLockRecursiveLocks; ++i) {
886 env_->MonitorEnter(jobj_);
887 lock_word = GetLockWord(jobj_);
888 ASSERT_EQ(lock_word.GetState(), LockWord::kThinLocked);
889 ASSERT_EQ(lock_word.ThinLockCount(), i);
890 }
891 result = env_->CallNonvirtualLongMethod(jobj_, jklass_, jmethod_, a, b);
892 EXPECT_EQ(a | b, result);
893 EXPECT_EQ(3, gJava_MyClassNatives_fooJJ_synchronized_calls[gCurrentJni]);
894 lock_word = GetLockWord(jobj_);
895 ASSERT_EQ(lock_word.GetState(), LockWord::kFatLocked);
896 for (uint32_t i = 0; i != kMaxThinLockRecursiveLocks; ++i) {
897 env_->MonitorExit(jobj_); // Remains "fat-locked" even if actually unlocked.
898 }
899
900 // Exercise locking for "fat-locked".
901 lock_word = GetLockWord(jobj_);
902 ASSERT_EQ(lock_word.GetState(), LockWord::kFatLocked);
903 result = env_->CallNonvirtualLongMethod(jobj_, jklass_, jmethod_, a, b);
904 EXPECT_EQ(a | b, result);
905 EXPECT_EQ(4, gJava_MyClassNatives_fooJJ_synchronized_calls[gCurrentJni]);
906 lock_word = GetLockWord(jobj_);
907 ASSERT_EQ(lock_word.GetState(), LockWord::kFatLocked);
908
909 // Exercise locking/unocking for "fat-locked" through the "no_inline" path.
910 // These entrypoints are selected with verbose "systrace_lock_logging".
911 Thread* self = Thread::Current();
912 ASSERT_FALSE(gLogVerbosity.systrace_lock_logging);
913 gLogVerbosity.systrace_lock_logging = true;
914 InitEntryPoints(&self->tlsPtr_.jni_entrypoints,
915 &self->tlsPtr_.quick_entrypoints,
916 self->ReadFlag(ThreadFlag::kMonitorJniEntryExit));
917 result = env_->CallNonvirtualLongMethod(jobj_, jklass_, jmethod_, a, b);
918 EXPECT_EQ(a | b, result);
919 EXPECT_EQ(5, gJava_MyClassNatives_fooJJ_synchronized_calls[gCurrentJni]);
920 gLogVerbosity.systrace_lock_logging = false;
921 InitEntryPoints(&self->tlsPtr_.jni_entrypoints,
922 &self->tlsPtr_.quick_entrypoints,
923 self->ReadFlag(ThreadFlag::kMonitorJniEntryExit));
924
925 gJava_MyClassNatives_fooJJ_synchronized_calls[gCurrentJni] = 0;
926 }
927
928 JNI_TEST_NORMAL_ONLY(CompileAndRun_fooJJ_synchronized)
929
930 int gJava_MyClassNatives_fooIOO_calls[kJniKindCount] = {};
Java_MyClassNatives_fooIOO(JNIEnv *,jobject thisObj,jint x,jobject y,jobject z)931 jobject Java_MyClassNatives_fooIOO(JNIEnv*, jobject thisObj, jint x, jobject y,
932 jobject z) {
933 gJava_MyClassNatives_fooIOO_calls[gCurrentJni]++;
934 switch (x) {
935 case 1:
936 return y;
937 case 2:
938 return z;
939 default:
940 return thisObj;
941 }
942 }
943
CompileAndRunIntObjectObjectMethodImpl()944 void JniCompilerTest::CompileAndRunIntObjectObjectMethodImpl() {
945 SetUpForTest(false, "fooIOO",
946 "(ILjava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
947 CURRENT_JNI_WRAPPER(Java_MyClassNatives_fooIOO));
948
949 EXPECT_EQ(0, gJava_MyClassNatives_fooIOO_calls[gCurrentJni]);
950 jobject result = env_->CallNonvirtualObjectMethod(jobj_, jklass_, jmethod_, 0, nullptr, nullptr);
951 EXPECT_TRUE(env_->IsSameObject(jobj_, result));
952 EXPECT_EQ(1, gJava_MyClassNatives_fooIOO_calls[gCurrentJni]);
953
954 result = env_->CallNonvirtualObjectMethod(jobj_, jklass_, jmethod_, 0, nullptr, jklass_);
955 EXPECT_TRUE(env_->IsSameObject(jobj_, result));
956 EXPECT_EQ(2, gJava_MyClassNatives_fooIOO_calls[gCurrentJni]);
957 result = env_->CallNonvirtualObjectMethod(jobj_, jklass_, jmethod_, 1, nullptr, jklass_);
958 EXPECT_TRUE(env_->IsSameObject(nullptr, result));
959 EXPECT_EQ(3, gJava_MyClassNatives_fooIOO_calls[gCurrentJni]);
960 result = env_->CallNonvirtualObjectMethod(jobj_, jklass_, jmethod_, 2, nullptr, jklass_);
961 EXPECT_TRUE(env_->IsSameObject(jklass_, result));
962 EXPECT_EQ(4, gJava_MyClassNatives_fooIOO_calls[gCurrentJni]);
963
964 result = env_->CallNonvirtualObjectMethod(jobj_, jklass_, jmethod_, 0, jklass_, nullptr);
965 EXPECT_TRUE(env_->IsSameObject(jobj_, result));
966 EXPECT_EQ(5, gJava_MyClassNatives_fooIOO_calls[gCurrentJni]);
967 result = env_->CallNonvirtualObjectMethod(jobj_, jklass_, jmethod_, 1, jklass_, nullptr);
968 EXPECT_TRUE(env_->IsSameObject(jklass_, result));
969 EXPECT_EQ(6, gJava_MyClassNatives_fooIOO_calls[gCurrentJni]);
970 result = env_->CallNonvirtualObjectMethod(jobj_, jklass_, jmethod_, 2, jklass_, nullptr);
971 EXPECT_TRUE(env_->IsSameObject(nullptr, result));
972 EXPECT_EQ(7, gJava_MyClassNatives_fooIOO_calls[gCurrentJni]);
973
974 gJava_MyClassNatives_fooIOO_calls[gCurrentJni] = 0;
975 }
976
977 JNI_TEST(CompileAndRunIntObjectObjectMethod)
978
979 int gJava_MyClassNatives_fooSII_calls[kJniKindCount] = {};
Java_MyClassNatives_fooSII(JNIEnv * env,jclass klass,jint x,jint y)980 jint Java_MyClassNatives_fooSII([[maybe_unused]] JNIEnv* env,
981 [[maybe_unused]] jclass klass,
982 jint x,
983 jint y) {
984 gJava_MyClassNatives_fooSII_calls[gCurrentJni]++;
985 return x + y;
986 }
987
CompileAndRunStaticIntIntMethodImpl()988 void JniCompilerTest::CompileAndRunStaticIntIntMethodImpl() {
989 SetUpForTest(true, "fooSII", "(II)I",
990 CURRENT_JNI_WRAPPER(Java_MyClassNatives_fooSII));
991
992 EXPECT_EQ(0, gJava_MyClassNatives_fooSII_calls[gCurrentJni]);
993 jint result = env_->CallStaticIntMethod(jklass_, jmethod_, 20, 30);
994 EXPECT_EQ(50, result);
995 EXPECT_EQ(1, gJava_MyClassNatives_fooSII_calls[gCurrentJni]);
996
997 gJava_MyClassNatives_fooSII_calls[gCurrentJni] = 0;
998 }
999
1000 JNI_TEST_CRITICAL(CompileAndRunStaticIntIntMethod)
1001
1002 int gJava_MyClassNatives_fooSDD_calls[kJniKindCount] = {};
Java_MyClassNatives_fooSDD(JNIEnv * env,jclass klass,jdouble x,jdouble y)1003 jdouble Java_MyClassNatives_fooSDD([[maybe_unused]] JNIEnv* env,
1004 [[maybe_unused]] jclass klass,
1005 jdouble x,
1006 jdouble y) {
1007 gJava_MyClassNatives_fooSDD_calls[gCurrentJni]++;
1008 return x - y; // non-commutative operator
1009 }
1010
CompileAndRunStaticDoubleDoubleMethodImpl()1011 void JniCompilerTest::CompileAndRunStaticDoubleDoubleMethodImpl() {
1012 SetUpForTest(true, "fooSDD", "(DD)D",
1013 CURRENT_JNI_WRAPPER(Java_MyClassNatives_fooSDD));
1014
1015 EXPECT_EQ(0, gJava_MyClassNatives_fooSDD_calls[gCurrentJni]);
1016 jdouble result = env_->CallStaticDoubleMethod(jklass_, jmethod_, 99.0, 10.0);
1017 EXPECT_DOUBLE_EQ(99.0 - 10.0, result);
1018 EXPECT_EQ(1, gJava_MyClassNatives_fooSDD_calls[gCurrentJni]);
1019 jdouble a = 3.14159265358979323846;
1020 jdouble b = 0.69314718055994530942;
1021 result = env_->CallStaticDoubleMethod(jklass_, jmethod_, a, b);
1022 EXPECT_DOUBLE_EQ(a - b, result);
1023 EXPECT_DOUBLE_EQ(2, gJava_MyClassNatives_fooSDD_calls[gCurrentJni]);
1024
1025 gJava_MyClassNatives_fooSDD_calls[gCurrentJni] = 0;
1026 }
1027
JNI_TEST_CRITICAL(CompileAndRunStaticDoubleDoubleMethod)1028 JNI_TEST_CRITICAL(CompileAndRunStaticDoubleDoubleMethod)
1029
1030 // The x86 generic JNI code had a bug where it assumed a floating
1031 // point return value would be in xmm0. We use log, to somehow ensure
1032 // the compiler will use the floating point stack.
1033
1034 jdouble Java_MyClassNatives_logD(JNIEnv*, jclass, jdouble x) {
1035 return log(x);
1036 }
1037
Java_MyClassNatives_logD_notNormal(JNIEnv *,jclass,jdouble x)1038 jdouble Java_MyClassNatives_logD_notNormal(JNIEnv*, jclass, jdouble x) {
1039 EXPECT_DOUBLE_EQ(2.0, x);
1040 return log(x);
1041 }
1042
RunStaticLogDoubleMethodImpl()1043 void JniCompilerTest::RunStaticLogDoubleMethodImpl() {
1044 void* jni_handler;
1045 if (IsCurrentJniNormal()) {
1046 // This test seems a bit special, don't use a JNI wrapper here.
1047 jni_handler = NORMAL_JNI_ONLY_NOWRAP(Java_MyClassNatives_logD);
1048 } else {
1049 jni_handler = CURRENT_JNI_WRAPPER(Java_MyClassNatives_logD_notNormal);
1050 }
1051 SetUpForTest(true, "logD", "(D)D", jni_handler);
1052
1053 jdouble result = env_->CallStaticDoubleMethod(jklass_, jmethod_, 2.0);
1054 EXPECT_DOUBLE_EQ(log(2.0), result);
1055 }
1056
JNI_TEST_CRITICAL(RunStaticLogDoubleMethod)1057 JNI_TEST_CRITICAL(RunStaticLogDoubleMethod)
1058
1059 jfloat Java_MyClassNatives_logF(JNIEnv*, jclass, jfloat x) {
1060 return logf(x);
1061 }
1062
RunStaticLogFloatMethodImpl()1063 void JniCompilerTest::RunStaticLogFloatMethodImpl() {
1064 void* jni_handler;
1065 if (IsCurrentJniNormal()) {
1066 // This test seems a bit special, don't use a JNI wrapper here.
1067 jni_handler = NORMAL_JNI_ONLY_NOWRAP(Java_MyClassNatives_logF);
1068 } else {
1069 jni_handler = CURRENT_JNI_WRAPPER(Java_MyClassNatives_logF);
1070 }
1071
1072 SetUpForTest(true, "logF", "(F)F", jni_handler);
1073
1074 jfloat result = env_->CallStaticFloatMethod(jklass_, jmethod_, 2.0);
1075 EXPECT_FLOAT_EQ(logf(2.0), result);
1076 }
1077
JNI_TEST_CRITICAL(RunStaticLogFloatMethod)1078 JNI_TEST_CRITICAL(RunStaticLogFloatMethod)
1079
1080 jboolean Java_MyClassNatives_returnTrue(JNIEnv*, jclass) {
1081 return JNI_TRUE;
1082 }
1083
Java_MyClassNatives_returnFalse(JNIEnv *,jclass)1084 jboolean Java_MyClassNatives_returnFalse(JNIEnv*, jclass) {
1085 return JNI_FALSE;
1086 }
1087
Java_MyClassNatives_returnInt(JNIEnv *,jclass)1088 jint Java_MyClassNatives_returnInt(JNIEnv*, jclass) {
1089 return 42;
1090 }
1091
RunStaticReturnTrueImpl()1092 void JniCompilerTest::RunStaticReturnTrueImpl() {
1093 SetUpForTest(true, "returnTrue", "()Z", CURRENT_JNI_WRAPPER(Java_MyClassNatives_returnTrue));
1094
1095 jboolean result = env_->CallStaticBooleanMethod(jklass_, jmethod_);
1096 EXPECT_TRUE(result);
1097 }
1098
JNI_TEST_CRITICAL(RunStaticReturnTrue)1099 JNI_TEST_CRITICAL(RunStaticReturnTrue)
1100
1101 void JniCompilerTest::RunStaticReturnFalseImpl() {
1102 SetUpForTest(true, "returnFalse", "()Z",
1103 CURRENT_JNI_WRAPPER(Java_MyClassNatives_returnFalse));
1104
1105 jboolean result = env_->CallStaticBooleanMethod(jklass_, jmethod_);
1106 EXPECT_FALSE(result);
1107 }
1108
JNI_TEST_CRITICAL(RunStaticReturnFalse)1109 JNI_TEST_CRITICAL(RunStaticReturnFalse)
1110
1111 void JniCompilerTest::RunGenericStaticReturnIntImpl() {
1112 SetUpForTest(true, "returnInt", "()I", CURRENT_JNI_WRAPPER(Java_MyClassNatives_returnInt));
1113
1114 jint result = env_->CallStaticIntMethod(jklass_, jmethod_);
1115 EXPECT_EQ(42, result);
1116 }
1117
1118 JNI_TEST_CRITICAL(RunGenericStaticReturnInt)
1119
1120 int gJava_MyClassNatives_returnDouble_calls[kJniKindCount] = {};
Java_MyClassNatives_returnDouble(JNIEnv *,jclass)1121 jdouble Java_MyClassNatives_returnDouble(JNIEnv*, jclass) {
1122 gJava_MyClassNatives_returnDouble_calls[gCurrentJni]++;
1123 return 4.0;
1124 }
1125
RunGenericStaticReturnDoubleImpl()1126 void JniCompilerTest::RunGenericStaticReturnDoubleImpl() {
1127 SetUpForTest(true, "returnDouble", "()D", CURRENT_JNI_WRAPPER(Java_MyClassNatives_returnDouble));
1128
1129 jdouble result = env_->CallStaticDoubleMethod(jklass_, jmethod_);
1130 EXPECT_DOUBLE_EQ(4.0, result);
1131 EXPECT_EQ(1, gJava_MyClassNatives_returnDouble_calls[gCurrentJni]);
1132
1133 gJava_MyClassNatives_returnDouble_calls[gCurrentJni] = 0;
1134 }
1135
JNI_TEST_CRITICAL(RunGenericStaticReturnDouble)1136 JNI_TEST_CRITICAL(RunGenericStaticReturnDouble)
1137
1138 jlong Java_MyClassNatives_returnLong(JNIEnv*, jclass) {
1139 return 0xFEEDDEADFEEDL;
1140 }
1141
RunGenericStaticReturnLongImpl()1142 void JniCompilerTest::RunGenericStaticReturnLongImpl() {
1143 SetUpForTest(true, "returnLong", "()J", CURRENT_JNI_WRAPPER(Java_MyClassNatives_returnLong));
1144
1145 jlong result = env_->CallStaticLongMethod(jklass_, jmethod_);
1146 EXPECT_EQ(0xFEEDDEADFEEDL, result);
1147 }
1148
1149 JNI_TEST_CRITICAL(RunGenericStaticReturnLong)
1150
1151 int gJava_MyClassNatives_fooSIOO_calls[kJniKindCount] = {};
Java_MyClassNatives_fooSIOO(JNIEnv *,jclass klass,jint x,jobject y,jobject z)1152 jobject Java_MyClassNatives_fooSIOO(JNIEnv*, jclass klass, jint x, jobject y, jobject z) {
1153 gJava_MyClassNatives_fooSIOO_calls[gCurrentJni]++;
1154 switch (x) {
1155 case 1:
1156 return y;
1157 case 2:
1158 return z;
1159 default:
1160 return klass;
1161 }
1162 }
1163
CompileAndRunStaticIntObjectObjectMethodImpl()1164 void JniCompilerTest::CompileAndRunStaticIntObjectObjectMethodImpl() {
1165 SetUpForTest(true, "fooSIOO",
1166 "(ILjava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
1167 CURRENT_JNI_WRAPPER(Java_MyClassNatives_fooSIOO));
1168
1169 EXPECT_EQ(0, gJava_MyClassNatives_fooSIOO_calls[gCurrentJni]);
1170 jobject result = env_->CallStaticObjectMethod(jklass_, jmethod_, 0, nullptr, nullptr);
1171 EXPECT_TRUE(env_->IsSameObject(jklass_, result));
1172 EXPECT_EQ(1, gJava_MyClassNatives_fooSIOO_calls[gCurrentJni]);
1173
1174 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 0, nullptr, jobj_);
1175 EXPECT_TRUE(env_->IsSameObject(jklass_, result));
1176 EXPECT_EQ(2, gJava_MyClassNatives_fooSIOO_calls[gCurrentJni]);
1177 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 1, nullptr, jobj_);
1178 EXPECT_TRUE(env_->IsSameObject(nullptr, result));
1179 EXPECT_EQ(3, gJava_MyClassNatives_fooSIOO_calls[gCurrentJni]);
1180 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 2, nullptr, jobj_);
1181 EXPECT_TRUE(env_->IsSameObject(jobj_, result));
1182 EXPECT_EQ(4, gJava_MyClassNatives_fooSIOO_calls[gCurrentJni]);
1183
1184 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 0, jobj_, nullptr);
1185 EXPECT_TRUE(env_->IsSameObject(jklass_, result));
1186 EXPECT_EQ(5, gJava_MyClassNatives_fooSIOO_calls[gCurrentJni]);
1187 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 1, jobj_, nullptr);
1188 EXPECT_TRUE(env_->IsSameObject(jobj_, result));
1189 EXPECT_EQ(6, gJava_MyClassNatives_fooSIOO_calls[gCurrentJni]);
1190 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 2, jobj_, nullptr);
1191 EXPECT_TRUE(env_->IsSameObject(nullptr, result));
1192 EXPECT_EQ(7, gJava_MyClassNatives_fooSIOO_calls[gCurrentJni]);
1193
1194 gJava_MyClassNatives_fooSIOO_calls[gCurrentJni] = 0;
1195 }
1196
1197 JNI_TEST(CompileAndRunStaticIntObjectObjectMethod)
1198
1199 int gJava_MyClassNatives_fooSSIOO_calls[kJniKindCount] = {};
Java_MyClassNatives_fooSSIOO(JNIEnv * env,jclass klass,jint x,jobject y,jobject z)1200 jobject Java_MyClassNatives_fooSSIOO(JNIEnv* env, jclass klass, jint x, jobject y, jobject z) {
1201 JniCompilerTest::AssertCallerObjectLocked(env);
1202 gJava_MyClassNatives_fooSSIOO_calls[gCurrentJni]++;
1203 switch (x) {
1204 case 1:
1205 return y;
1206 case 2:
1207 return z;
1208 default:
1209 return klass;
1210 }
1211 }
1212
CompileAndRunStaticSynchronizedIntObjectObjectMethodImpl()1213 void JniCompilerTest::CompileAndRunStaticSynchronizedIntObjectObjectMethodImpl() {
1214 SetUpForTest(true, "fooSSIOO",
1215 "(ILjava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
1216 CURRENT_JNI_WRAPPER(Java_MyClassNatives_fooSSIOO));
1217
1218 EXPECT_EQ(0, gJava_MyClassNatives_fooSSIOO_calls[gCurrentJni]);
1219 jobject result = env_->CallStaticObjectMethod(jklass_, jmethod_, 0, nullptr, nullptr);
1220 EXPECT_TRUE(env_->IsSameObject(jklass_, result));
1221 EXPECT_EQ(1, gJava_MyClassNatives_fooSSIOO_calls[gCurrentJni]);
1222
1223 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 0, nullptr, jobj_);
1224 EXPECT_TRUE(env_->IsSameObject(jklass_, result));
1225 EXPECT_EQ(2, gJava_MyClassNatives_fooSSIOO_calls[gCurrentJni]);
1226 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 1, nullptr, jobj_);
1227 EXPECT_TRUE(env_->IsSameObject(nullptr, result));
1228 EXPECT_EQ(3, gJava_MyClassNatives_fooSSIOO_calls[gCurrentJni]);
1229 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 2, nullptr, jobj_);
1230 EXPECT_TRUE(env_->IsSameObject(jobj_, result));
1231 EXPECT_EQ(4, gJava_MyClassNatives_fooSSIOO_calls[gCurrentJni]);
1232
1233 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 0, jobj_, nullptr);
1234 EXPECT_TRUE(env_->IsSameObject(jklass_, result));
1235 EXPECT_EQ(5, gJava_MyClassNatives_fooSSIOO_calls[gCurrentJni]);
1236 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 1, jobj_, nullptr);
1237 EXPECT_TRUE(env_->IsSameObject(jobj_, result));
1238 EXPECT_EQ(6, gJava_MyClassNatives_fooSSIOO_calls[gCurrentJni]);
1239 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 2, jobj_, nullptr);
1240 EXPECT_TRUE(env_->IsSameObject(nullptr, result));
1241 EXPECT_EQ(7, gJava_MyClassNatives_fooSSIOO_calls[gCurrentJni]);
1242
1243 // Exercise recursive thin locking/unlocking.
1244 // Note: Thin lock count 0 means locked once.
1245 env_->MonitorEnter(jklass_);
1246 LockWord lock_word = GetLockWord(jklass_);
1247 ASSERT_EQ(lock_word.GetState(), LockWord::kThinLocked);
1248 ASSERT_EQ(lock_word.ThinLockCount(), 0u);
1249 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 2, jobj_, nullptr);
1250 EXPECT_TRUE(env_->IsSameObject(nullptr, result));
1251 EXPECT_EQ(8, gJava_MyClassNatives_fooSSIOO_calls[gCurrentJni]);
1252 lock_word = GetLockWord(jklass_);
1253 ASSERT_EQ(lock_word.GetState(), LockWord::kThinLocked);
1254 ASSERT_EQ(lock_word.ThinLockCount(), 0u);
1255 env_->MonitorExit(jklass_);
1256 lock_word = GetLockWord(jklass_);
1257 ASSERT_EQ(lock_word.GetState(), LockWord::kUnlocked);
1258
1259 // Exercise lock inflation due to thin lock count overflow.
1260 constexpr uint32_t kMaxThinLockRecursiveLocks = 1u << LockWord::kThinLockCountSize;
1261 for (uint32_t i = 0; i != kMaxThinLockRecursiveLocks; ++i) {
1262 env_->MonitorEnter(jklass_);
1263 lock_word = GetLockWord(jklass_);
1264 ASSERT_EQ(lock_word.GetState(), LockWord::kThinLocked);
1265 ASSERT_EQ(lock_word.ThinLockCount(), i);
1266 }
1267 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 2, jobj_, nullptr);
1268 EXPECT_TRUE(env_->IsSameObject(nullptr, result));
1269 EXPECT_EQ(9, gJava_MyClassNatives_fooSSIOO_calls[gCurrentJni]);
1270 lock_word = GetLockWord(jklass_);
1271 ASSERT_EQ(lock_word.GetState(), LockWord::kFatLocked);
1272 for (uint32_t i = 0; i != kMaxThinLockRecursiveLocks; ++i) {
1273 env_->MonitorExit(jklass_); // Remains "fat-locked" even if actually unlocked.
1274 }
1275
1276 // Exercise locking for "fat-locked".
1277 lock_word = GetLockWord(jklass_);
1278 result = env_->CallStaticObjectMethod(jklass_, jmethod_, 2, jobj_, nullptr);
1279 EXPECT_TRUE(env_->IsSameObject(nullptr, result));
1280 EXPECT_EQ(10, gJava_MyClassNatives_fooSSIOO_calls[gCurrentJni]);
1281 lock_word = GetLockWord(jklass_);
1282 ASSERT_EQ(lock_word.GetState(), LockWord::kFatLocked);
1283
1284 gJava_MyClassNatives_fooSSIOO_calls[gCurrentJni] = 0;
1285 }
1286
1287 // TODO: Maybe. @FastNative support for returning Objects?
JNI_TEST_NORMAL_ONLY(CompileAndRunStaticSynchronizedIntObjectObjectMethod)1288 JNI_TEST_NORMAL_ONLY(CompileAndRunStaticSynchronizedIntObjectObjectMethod)
1289
1290 void Java_MyClassNatives_throwException(JNIEnv* env, jobject) {
1291 jclass c = env->FindClass("java/lang/RuntimeException");
1292 env->ThrowNew(c, "hello");
1293 }
1294
Java_MyClassNatives_synchronizedThrowException(JNIEnv * env,jobject)1295 void Java_MyClassNatives_synchronizedThrowException(JNIEnv* env, jobject) {
1296 JniCompilerTest::AssertCallerObjectLocked(env);
1297 jclass c = env->FindClass("java/lang/RuntimeException");
1298 env->ThrowNew(c, "hello");
1299 }
1300
ExceptionHandlingImpl()1301 void JniCompilerTest::ExceptionHandlingImpl() {
1302 {
1303 ASSERT_FALSE(runtime_->IsStarted());
1304 ScopedObjectAccess soa(Thread::Current());
1305 class_loader_ = LoadDex("MyClassNatives");
1306
1307 // all compilation needs to happen before Runtime::Start
1308 CompileForTestWithCurrentJni(class_loader_, false, "foo", "()V");
1309 CompileForTestWithCurrentJni(class_loader_, false, "throwException", "()V");
1310 if (gCurrentJni == enum_cast<uint32_t>(JniKind::kNormal)) {
1311 CompileForTestWithCurrentJni(class_loader_, false, "synchronizedThrowException", "()V");
1312 }
1313 }
1314 // Start runtime to avoid re-initialization in SetUpForTest.
1315 Thread::Current()->TransitionFromSuspendedToRunnable();
1316 bool started = runtime_->Start();
1317 CHECK(started);
1318
1319 gJava_MyClassNatives_foo_calls[gCurrentJni] = 0;
1320
1321 // Check a single call of a JNI method is ok
1322 SetUpForTest(false, "foo", "()V", CURRENT_JNI_WRAPPER(Java_MyClassNatives_foo));
1323 env_->CallNonvirtualVoidMethod(jobj_, jklass_, jmethod_);
1324 EXPECT_EQ(1, gJava_MyClassNatives_foo_calls[gCurrentJni]);
1325 EXPECT_FALSE(Thread::Current()->IsExceptionPending());
1326
1327 // Get class for exception we expect to be thrown
1328 ScopedLocalRef<jclass> jlre(env_, env_->FindClass("java/lang/RuntimeException"));
1329 SetUpForTest(false, "throwException", "()V",
1330 CURRENT_JNI_WRAPPER(Java_MyClassNatives_throwException));
1331 // Call Java_MyClassNatives_throwException (JNI method that throws exception)
1332 env_->CallNonvirtualVoidMethod(jobj_, jklass_, jmethod_);
1333 EXPECT_TRUE(env_->ExceptionCheck() == JNI_TRUE);
1334 ScopedLocalRef<jthrowable> exception(env_, env_->ExceptionOccurred());
1335 env_->ExceptionClear();
1336 EXPECT_TRUE(env_->IsInstanceOf(exception.get(), jlre.get()));
1337
1338 // Check a single call of a JNI method is ok
1339 EXPECT_EQ(1, gJava_MyClassNatives_foo_calls[gCurrentJni]);
1340 SetUpForTest(false, "foo", "()V", reinterpret_cast<void*>(&Java_MyClassNatives_foo));
1341 env_->CallNonvirtualVoidMethod(jobj_, jklass_, jmethod_);
1342 EXPECT_EQ(2, gJava_MyClassNatives_foo_calls[gCurrentJni]);
1343
1344 if (gCurrentJni == enum_cast<uint32_t>(JniKind::kNormal)) {
1345 SetUpForTest(false, "synchronizedThrowException", "()V",
1346 CURRENT_JNI_WRAPPER(Java_MyClassNatives_synchronizedThrowException));
1347 LockWord lock_word = GetLockWord(jobj_);
1348 ASSERT_EQ(lock_word.GetState(), LockWord::kUnlocked);
1349 // Call Java_MyClassNatives_synchronizedThrowException (synchronized JNI method
1350 // that throws exception) to check that we correctly unlock the object.
1351 env_->CallNonvirtualVoidMethod(jobj_, jklass_, jmethod_);
1352 EXPECT_TRUE(env_->ExceptionCheck() == JNI_TRUE);
1353 ScopedLocalRef<jthrowable> exception2(env_, env_->ExceptionOccurred());
1354 env_->ExceptionClear();
1355 EXPECT_TRUE(env_->IsInstanceOf(exception2.get(), jlre.get()));
1356 lock_word = GetLockWord(jobj_);
1357 EXPECT_EQ(lock_word.GetState(), LockWord::kUnlocked);
1358
1359 // Check a single call of a JNI method is ok
1360 EXPECT_EQ(2, gJava_MyClassNatives_foo_calls[gCurrentJni]);
1361 SetUpForTest(false, "foo", "()V", reinterpret_cast<void*>(&Java_MyClassNatives_foo));
1362 env_->CallNonvirtualVoidMethod(jobj_, jklass_, jmethod_);
1363 EXPECT_EQ(3, gJava_MyClassNatives_foo_calls[gCurrentJni]);
1364 }
1365
1366 gJava_MyClassNatives_foo_calls[gCurrentJni] = 0;
1367 }
1368
JNI_TEST(ExceptionHandling)1369 JNI_TEST(ExceptionHandling)
1370
1371 jint Java_MyClassNatives_nativeUpCall(JNIEnv* env, jobject thisObj, jint i) {
1372 if (i <= 0) {
1373 // We want to check raw Object* / Array* below
1374 ScopedObjectAccess soa(env);
1375
1376 // Build stack trace
1377 jobject internal = 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