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