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