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