From 48b2b3e57e0510f549e9dc5c5a61f50eec697cf5 Mon Sep 17 00:00:00 2001 From: Mathieu Chartier Date: Thu, 5 May 2016 15:31:12 -0700 Subject: [PATCH] Fix libarttest to be non debug Previously both libarttest and libarttestd had debug enabled. This made it hard to know which one was loaded (couldn't look at kIsDebugBuild). Fixes test 136 with ART_TEST_RUN_TEST_NDEBUG configuration. Bug: 28406866 Change-Id: I92983f71374b211f96f5b346fec326ea8543f876 --- test/004-JniTest/jni_test.cc | 334 +++++++++++---------- test/004-ReferenceMap/stack_walk_refmap_jni.cc | 1 + test/004-StackWalk/stack_walk_jni.cc | 1 + .../136-daemon-jni-shutdown/daemon_jni_shutdown.cc | 3 +- test/570-checker-osr/osr.cc | 2 +- test/595-profile-saving/profile-saving.cc | 1 + test/596-app-images/app_images.cc | 1 - test/Android.libarttest.mk | 7 +- 8 files changed, 180 insertions(+), 170 deletions(-) diff --git a/test/004-JniTest/jni_test.cc b/test/004-JniTest/jni_test.cc index 2bdf8d1e7..8619ff7f3 100644 --- a/test/004-JniTest/jni_test.cc +++ b/test/004-JniTest/jni_test.cc @@ -14,23 +14,22 @@ * limitations under the License. */ -#include #include #include #include #include +#include "art_method-inl.h" +#include "base/logging.h" #include "jni.h" -#if defined(NDEBUG) -#error test code compiled without NDEBUG -#endif +namespace art { static JavaVM* jvm = nullptr; extern "C" JNIEXPORT jint JNI_OnLoad(JavaVM *vm, void*) { - assert(vm != nullptr); - assert(jvm == nullptr); + CHECK(vm != nullptr); + CHECK(jvm == nullptr); jvm = vm; std::cout << "JNI_OnLoad called" << std::endl; return JNI_VERSION_1_6; @@ -39,24 +38,24 @@ extern "C" JNIEXPORT jint JNI_OnLoad(JavaVM *vm, void*) { extern "C" JNIEXPORT void JNI_OnUnload(JavaVM*, void*) { // std::cout since LOG(INFO) adds extra stuff like pid. std::cout << "JNI_OnUnload called" << std::endl; - // Clear jvm for assert in test 004-JniTest. + // Clear jvm for CHECK in test 004-JniTest. jvm = nullptr; } static void* AttachHelper(void* arg) { - assert(jvm != nullptr); + CHECK(jvm != nullptr); JNIEnv* env = nullptr; JavaVMAttachArgs args = { JNI_VERSION_1_6, __FUNCTION__, nullptr }; int attach_result = jvm->AttachCurrentThread(&env, &args); - assert(attach_result == 0); + CHECK_EQ(attach_result, 0); typedef void (*Fn)(JNIEnv*); Fn fn = reinterpret_cast(arg); fn(env); int detach_result = jvm->DetachCurrentThread(); - assert(detach_result == 0); + CHECK_EQ(detach_result, 0); return nullptr; } @@ -64,19 +63,19 @@ static void PthreadHelper(void (*fn)(JNIEnv*)) { pthread_t pthread; int pthread_create_result = pthread_create(&pthread, nullptr, AttachHelper, reinterpret_cast(fn)); - assert(pthread_create_result == 0); + CHECK_EQ(pthread_create_result, 0); int pthread_join_result = pthread_join(pthread, nullptr); - assert(pthread_join_result == 0); + CHECK_EQ(pthread_join_result, 0); } static void testFindClassOnAttachedNativeThread(JNIEnv* env) { jclass clazz = env->FindClass("Main"); - assert(clazz != nullptr); - assert(!env->ExceptionCheck()); + CHECK(clazz != nullptr); + CHECK(!env->ExceptionCheck()); jobjectArray array = env->NewObjectArray(0, clazz, nullptr); - assert(array != nullptr); - assert(!env->ExceptionCheck()); + CHECK(array != nullptr); + CHECK(!env->ExceptionCheck()); } // http://b/10994325 @@ -86,12 +85,12 @@ extern "C" JNIEXPORT void JNICALL Java_Main_testFindClassOnAttachedNativeThread( static void testFindFieldOnAttachedNativeThread(JNIEnv* env) { jclass clazz = env->FindClass("Main"); - assert(clazz != nullptr); - assert(!env->ExceptionCheck()); + CHECK(clazz != nullptr); + CHECK(!env->ExceptionCheck()); jfieldID field = env->GetStaticFieldID(clazz, "testFindFieldOnAttachedNativeThreadField", "Z"); - assert(field != nullptr); - assert(!env->ExceptionCheck()); + CHECK(field != nullptr); + CHECK(!env->ExceptionCheck()); env->SetStaticBooleanField(clazz, field, JNI_TRUE); } @@ -103,38 +102,38 @@ extern "C" JNIEXPORT void JNICALL Java_Main_testFindFieldOnAttachedNativeThreadN static void testReflectFieldGetFromAttachedNativeThread(JNIEnv* env) { jclass clazz = env->FindClass("Main"); - assert(clazz != nullptr); - assert(!env->ExceptionCheck()); + CHECK(clazz != nullptr); + CHECK(!env->ExceptionCheck()); jclass class_clazz = env->FindClass("java/lang/Class"); - assert(class_clazz != nullptr); - assert(!env->ExceptionCheck()); + CHECK(class_clazz != nullptr); + CHECK(!env->ExceptionCheck()); jmethodID getFieldMetodId = env->GetMethodID(class_clazz, "getField", "(Ljava/lang/String;)Ljava/lang/reflect/Field;"); - assert(getFieldMetodId != nullptr); - assert(!env->ExceptionCheck()); + CHECK(getFieldMetodId != nullptr); + CHECK(!env->ExceptionCheck()); jstring field_name = env->NewStringUTF("testReflectFieldGetFromAttachedNativeThreadField"); - assert(field_name != nullptr); - assert(!env->ExceptionCheck()); + CHECK(field_name != nullptr); + CHECK(!env->ExceptionCheck()); jobject field = env->CallObjectMethod(clazz, getFieldMetodId, field_name); - assert(field != nullptr); - assert(!env->ExceptionCheck()); + CHECK(field != nullptr); + CHECK(!env->ExceptionCheck()); jclass field_clazz = env->FindClass("java/lang/reflect/Field"); - assert(field_clazz != nullptr); - assert(!env->ExceptionCheck()); + CHECK(field_clazz != nullptr); + CHECK(!env->ExceptionCheck()); jmethodID getBooleanMetodId = env->GetMethodID(field_clazz, "getBoolean", "(Ljava/lang/Object;)Z"); - assert(getBooleanMetodId != nullptr); - assert(!env->ExceptionCheck()); + CHECK(getBooleanMetodId != nullptr); + CHECK(!env->ExceptionCheck()); jboolean value = env->CallBooleanMethod(field, getBooleanMetodId, /* ignored */ clazz); - assert(value == false); - assert(!env->ExceptionCheck()); + CHECK(value == false); + CHECK(!env->ExceptionCheck()); } // http://b/15539150 @@ -148,22 +147,22 @@ extern "C" JNIEXPORT void JNICALL Java_Main_testReflectFieldGetFromAttachedNativ extern "C" JNIEXPORT void JNICALL Java_Main_testCallStaticVoidMethodOnSubClassNative(JNIEnv* env, jclass) { jclass super_class = env->FindClass("Main$testCallStaticVoidMethodOnSubClass_SuperClass"); - assert(super_class != nullptr); + CHECK(super_class != nullptr); jmethodID execute = env->GetStaticMethodID(super_class, "execute", "()V"); - assert(execute != nullptr); + CHECK(execute != nullptr); jclass sub_class = env->FindClass("Main$testCallStaticVoidMethodOnSubClass_SubClass"); - assert(sub_class != nullptr); + CHECK(sub_class != nullptr); env->CallStaticVoidMethod(sub_class, execute); } extern "C" JNIEXPORT jobject JNICALL Java_Main_testGetMirandaMethodNative(JNIEnv* env, jclass) { jclass abstract_class = env->FindClass("Main$testGetMirandaMethod_MirandaAbstract"); - assert(abstract_class != nullptr); + CHECK(abstract_class != nullptr); jmethodID miranda_method = env->GetMethodID(abstract_class, "inInterface", "()Z"); - assert(miranda_method != nullptr); + CHECK(miranda_method != nullptr); return env->ToReflectedMethod(abstract_class, miranda_method, JNI_FALSE); } @@ -171,11 +170,11 @@ extern "C" JNIEXPORT jobject JNICALL Java_Main_testGetMirandaMethodNative(JNIEnv extern "C" void JNICALL Java_Main_testZeroLengthByteBuffers(JNIEnv* env, jclass) { std::vector buffer(1); jobject byte_buffer = env->NewDirectByteBuffer(&buffer[0], 0); - assert(byte_buffer != nullptr); - assert(!env->ExceptionCheck()); + CHECK(byte_buffer != nullptr); + CHECK(!env->ExceptionCheck()); - assert(env->GetDirectBufferAddress(byte_buffer) == &buffer[0]); - assert(env->GetDirectBufferCapacity(byte_buffer) == 0); + CHECK_EQ(env->GetDirectBufferAddress(byte_buffer), &buffer[0]); + CHECK_EQ(env->GetDirectBufferCapacity(byte_buffer), 0); } constexpr size_t kByteReturnSize = 7; @@ -185,18 +184,18 @@ extern "C" jbyte JNICALL Java_Main_byteMethod(JNIEnv*, jclass, jbyte b1, jbyte b jbyte b3, jbyte b4, jbyte b5, jbyte b6, jbyte b7, jbyte b8, jbyte b9, jbyte b10) { // We use b1 to drive the output. - assert(b2 == 2); - assert(b3 == -3); - assert(b4 == 4); - assert(b5 == -5); - assert(b6 == 6); - assert(b7 == -7); - assert(b8 == 8); - assert(b9 == -9); - assert(b10 == 10); - - assert(0 <= b1); - assert(b1 < static_cast(kByteReturnSize)); + CHECK_EQ(b2, 2); + CHECK_EQ(b3, -3); + CHECK_EQ(b4, 4); + CHECK_EQ(b5, -5); + CHECK_EQ(b6, 6); + CHECK_EQ(b7, -7); + CHECK_EQ(b8, 8); + CHECK_EQ(b9, -9); + CHECK_EQ(b10, 10); + + CHECK_LE(0, b1); + CHECK_LT(b1, static_cast(kByteReturnSize)); return byte_returns[b1]; } @@ -210,18 +209,18 @@ extern "C" jshort JNICALL Java_Main_shortMethod(JNIEnv*, jclass, jshort s1, jsho jshort s3, jshort s4, jshort s5, jshort s6, jshort s7, jshort s8, jshort s9, jshort s10) { // We use s1 to drive the output. - assert(s2 == 2); - assert(s3 == -3); - assert(s4 == 4); - assert(s5 == -5); - assert(s6 == 6); - assert(s7 == -7); - assert(s8 == 8); - assert(s9 == -9); - assert(s10 == 10); - - assert(0 <= s1); - assert(s1 < static_cast(kShortReturnSize)); + CHECK_EQ(s2, 2); + CHECK_EQ(s3, -3); + CHECK_EQ(s4, 4); + CHECK_EQ(s5, -5); + CHECK_EQ(s6, 6); + CHECK_EQ(s7, -7); + CHECK_EQ(s8, 8); + CHECK_EQ(s9, -9); + CHECK_EQ(s10, 10); + + CHECK_LE(0, s1); + CHECK_LT(s1, static_cast(kShortReturnSize)); return short_returns[s1]; } @@ -231,17 +230,17 @@ extern "C" jboolean JNICALL Java_Main_booleanMethod(JNIEnv*, jclass, jboolean b1 jboolean b5, jboolean b6, jboolean b7, jboolean b8, jboolean b9, jboolean b10) { // We use b1 to drive the output. - assert(b2 == JNI_TRUE); - assert(b3 == JNI_FALSE); - assert(b4 == JNI_TRUE); - assert(b5 == JNI_FALSE); - assert(b6 == JNI_TRUE); - assert(b7 == JNI_FALSE); - assert(b8 == JNI_TRUE); - assert(b9 == JNI_FALSE); - assert(b10 == JNI_TRUE); - - assert(b1 == JNI_TRUE || b1 == JNI_FALSE); + CHECK_EQ(b2, JNI_TRUE); + CHECK_EQ(b3, JNI_FALSE); + CHECK_EQ(b4, JNI_TRUE); + CHECK_EQ(b5, JNI_FALSE); + CHECK_EQ(b6, JNI_TRUE); + CHECK_EQ(b7, JNI_FALSE); + CHECK_EQ(b8, JNI_TRUE); + CHECK_EQ(b9, JNI_FALSE); + CHECK_EQ(b10, JNI_TRUE); + + CHECK(b1 == JNI_TRUE || b1 == JNI_FALSE); return b1; } @@ -252,17 +251,17 @@ extern "C" jchar JNICALL Java_Main_charMethod(JNIEnv*, jclass, jchar c1, jchar c jchar c3, jchar c4, jchar c5, jchar c6, jchar c7, jchar c8, jchar c9, jchar c10) { // We use c1 to drive the output. - assert(c2 == 'a'); - assert(c3 == 'b'); - assert(c4 == 'c'); - assert(c5 == '0'); - assert(c6 == '1'); - assert(c7 == '2'); - assert(c8 == 1234); - assert(c9 == 2345); - assert(c10 == 3456); - - assert(c1 < static_cast(kCharReturnSize)); + CHECK_EQ(c2, 'a'); + CHECK_EQ(c3, 'b'); + CHECK_EQ(c4, 'c'); + CHECK_EQ(c5, '0'); + CHECK_EQ(c6, '1'); + CHECK_EQ(c7, '2'); + CHECK_EQ(c8, 1234); + CHECK_EQ(c9, 2345); + CHECK_EQ(c10, 3456); + + CHECK_LT(c1, static_cast(kCharReturnSize)); return char_returns[c1]; } @@ -281,39 +280,39 @@ static void testShallowGetCallingClassLoader(JNIEnv* env) { // Test direct call. { jclass vmstack_clazz = env->FindClass("dalvik/system/VMStack"); - assert(vmstack_clazz != nullptr); - assert(!env->ExceptionCheck()); + CHECK(vmstack_clazz != nullptr); + CHECK(!env->ExceptionCheck()); jmethodID getCallingClassLoaderMethodId = env->GetStaticMethodID(vmstack_clazz, "getCallingClassLoader", "()Ljava/lang/ClassLoader;"); - assert(getCallingClassLoaderMethodId != nullptr); - assert(!env->ExceptionCheck()); + CHECK(getCallingClassLoaderMethodId != nullptr); + CHECK(!env->ExceptionCheck()); jobject class_loader = env->CallStaticObjectMethod(vmstack_clazz, getCallingClassLoaderMethodId); - assert(class_loader == nullptr); - assert(!env->ExceptionCheck()); + CHECK(class_loader == nullptr); + CHECK(!env->ExceptionCheck()); } // Test one-level call. Use System.loadLibrary(). { jclass system_clazz = env->FindClass("java/lang/System"); - assert(system_clazz != nullptr); - assert(!env->ExceptionCheck()); + CHECK(system_clazz != nullptr); + CHECK(!env->ExceptionCheck()); jmethodID loadLibraryMethodId = env->GetStaticMethodID(system_clazz, "loadLibrary", "(Ljava/lang/String;)V"); - assert(loadLibraryMethodId != nullptr); - assert(!env->ExceptionCheck()); + CHECK(loadLibraryMethodId != nullptr); + CHECK(!env->ExceptionCheck()); // Create a string object. jobject library_string = env->NewStringUTF("non_existing_library"); - assert(library_string != nullptr); - assert(!env->ExceptionCheck()); + CHECK(library_string != nullptr); + CHECK(!env->ExceptionCheck()); env->CallStaticVoidMethod(system_clazz, loadLibraryMethodId, library_string); - assert(env->ExceptionCheck()); + CHECK(env->ExceptionCheck()); // We expect UnsatisfiedLinkError. jthrowable thrown = env->ExceptionOccurred(); @@ -321,7 +320,7 @@ static void testShallowGetCallingClassLoader(JNIEnv* env) { jclass unsatisfied_link_error_clazz = env->FindClass("java/lang/UnsatisfiedLinkError"); jclass thrown_class = env->GetObjectClass(thrown); - assert(env->IsSameObject(unsatisfied_link_error_clazz, thrown_class)); + CHECK(env->IsSameObject(unsatisfied_link_error_clazz, thrown_class)); } } @@ -333,31 +332,31 @@ extern "C" JNIEXPORT void JNICALL Java_Main_nativeTestShallowGetCallingClassLoad static void testShallowGetStackClass2(JNIEnv* env) { jclass vmstack_clazz = env->FindClass("dalvik/system/VMStack"); - assert(vmstack_clazz != nullptr); - assert(!env->ExceptionCheck()); + CHECK(vmstack_clazz != nullptr); + CHECK(!env->ExceptionCheck()); // Test direct call. { jmethodID getStackClass2MethodId = env->GetStaticMethodID(vmstack_clazz, "getStackClass2", "()Ljava/lang/Class;"); - assert(getStackClass2MethodId != nullptr); - assert(!env->ExceptionCheck()); + CHECK(getStackClass2MethodId != nullptr); + CHECK(!env->ExceptionCheck()); jobject caller_class = env->CallStaticObjectMethod(vmstack_clazz, getStackClass2MethodId); - assert(caller_class == nullptr); - assert(!env->ExceptionCheck()); + CHECK(caller_class == nullptr); + CHECK(!env->ExceptionCheck()); } // Test one-level call. Use VMStack.getStackClass1(). { jmethodID getStackClass1MethodId = env->GetStaticMethodID(vmstack_clazz, "getStackClass1", "()Ljava/lang/Class;"); - assert(getStackClass1MethodId != nullptr); - assert(!env->ExceptionCheck()); + CHECK(getStackClass1MethodId != nullptr); + CHECK(!env->ExceptionCheck()); jobject caller_class = env->CallStaticObjectMethod(vmstack_clazz, getStackClass1MethodId); - assert(caller_class == nullptr); - assert(!env->ExceptionCheck()); + CHECK(caller_class == nullptr); + CHECK(!env->ExceptionCheck()); } // For better testing we would need to compile against libcore and have a two-deep stack @@ -416,8 +415,8 @@ class JniCallNonvirtualVoidMethodTest { env_->ExceptionDescribe(); env_->FatalError(__FUNCTION__); } - assert(!env_->ExceptionCheck()); - assert(c != nullptr); + CHECK(!env_->ExceptionCheck()); + CHECK(c != nullptr); return c; } @@ -429,7 +428,7 @@ class JniCallNonvirtualVoidMethodTest { env_->ExceptionDescribe(); env_->FatalError(__FUNCTION__); } - assert(m != nullptr); + CHECK(m != nullptr); return m; } @@ -439,7 +438,7 @@ class JniCallNonvirtualVoidMethodTest { env_->ExceptionDescribe(); env_->FatalError(__FUNCTION__); } - assert(o != nullptr); + CHECK(o != nullptr); return o; } @@ -467,7 +466,7 @@ class JniCallNonvirtualVoidMethodTest { env_->ExceptionDescribe(); env_->FatalError(__FUNCTION__); } - assert(m != nullptr); + CHECK(m != nullptr); return m; } @@ -508,21 +507,21 @@ class JniCallNonvirtualVoidMethodTest { jobject sub_super = CallConstructor(sub_, super_constructor_); jobject sub_sub = CallConstructor(sub_, sub_constructor_); - assert(env_->IsInstanceOf(super_super, super_)); - assert(!env_->IsInstanceOf(super_super, sub_)); + CHECK(env_->IsInstanceOf(super_super, super_)); + CHECK(!env_->IsInstanceOf(super_super, sub_)); // Note that even though we called (and ran) the subclass // constructor, we are not the subclass. - assert(env_->IsInstanceOf(super_sub, super_)); - assert(!env_->IsInstanceOf(super_sub, sub_)); + CHECK(env_->IsInstanceOf(super_sub, super_)); + CHECK(!env_->IsInstanceOf(super_sub, sub_)); // Note that even though we called the superclass constructor, we // are still the subclass. - assert(env_->IsInstanceOf(sub_super, super_)); - assert(env_->IsInstanceOf(sub_super, sub_)); + CHECK(env_->IsInstanceOf(sub_super, super_)); + CHECK(env_->IsInstanceOf(sub_super, sub_)); - assert(env_->IsInstanceOf(sub_sub, super_)); - assert(env_->IsInstanceOf(sub_sub, sub_)); + CHECK(env_->IsInstanceOf(sub_sub, super_)); + CHECK(env_->IsInstanceOf(sub_sub, sub_)); } void TestnonstaticCallNonvirtualMethod(bool super_object, bool super_class, bool super_method, const char* test_case) { @@ -542,8 +541,8 @@ class JniCallNonvirtualVoidMethodTest { CallMethod(o, c, m, true, test_case); jboolean super_field = GetBooleanField(o, super_field_); jboolean sub_field = GetBooleanField(o, sub_field_); - assert(super_field == super_method); - assert(sub_field != super_method); + CHECK_EQ(super_field, super_method); + CHECK_NE(sub_field, super_method); } void TestnonstaticCallNonvirtualMethod() { @@ -565,20 +564,20 @@ extern "C" void JNICALL Java_Main_testCallNonvirtual(JNIEnv* env, jclass) { extern "C" JNIEXPORT void JNICALL Java_Main_testNewStringObject(JNIEnv* env, jclass) { jclass c = env->FindClass("java/lang/String"); - assert(c != nullptr); + CHECK(c != nullptr); jmethodID mid1 = env->GetMethodID(c, "", "()V"); - assert(mid1 != nullptr); - assert(!env->ExceptionCheck()); + CHECK(mid1 != nullptr); + CHECK(!env->ExceptionCheck()); jmethodID mid2 = env->GetMethodID(c, "", "([B)V"); - assert(mid2 != nullptr); - assert(!env->ExceptionCheck()); + CHECK(mid2 != nullptr); + CHECK(!env->ExceptionCheck()); jmethodID mid3 = env->GetMethodID(c, "", "([C)V"); - assert(mid3 != nullptr); - assert(!env->ExceptionCheck()); + CHECK(mid3 != nullptr); + CHECK(!env->ExceptionCheck()); jmethodID mid4 = env->GetMethodID(c, "", "(Ljava/lang/String;)V"); - assert(mid4 != nullptr); - assert(!env->ExceptionCheck()); + CHECK(mid4 != nullptr); + CHECK(!env->ExceptionCheck()); const char* test_array = "Test"; int byte_array_length = strlen(test_array); @@ -587,22 +586,22 @@ extern "C" JNIEXPORT void JNICALL Java_Main_testNewStringObject(JNIEnv* env, jcl // Test NewObject jstring s = reinterpret_cast(env->NewObject(c, mid2, byte_array)); - assert(s != nullptr); - assert(env->GetStringLength(s) == byte_array_length); - assert(env->GetStringUTFLength(s) == byte_array_length); + CHECK(s != nullptr); + CHECK_EQ(env->GetStringLength(s), byte_array_length); + CHECK_EQ(env->GetStringUTFLength(s), byte_array_length); const char* chars = env->GetStringUTFChars(s, nullptr); - assert(strcmp(test_array, chars) == 0); + CHECK_EQ(strcmp(test_array, chars), 0); env->ReleaseStringUTFChars(s, chars); // Test AllocObject and Call(Nonvirtual)VoidMethod jstring s1 = reinterpret_cast(env->AllocObject(c)); - assert(s1 != nullptr); + CHECK(s1 != nullptr); jstring s2 = reinterpret_cast(env->AllocObject(c)); - assert(s2 != nullptr); + CHECK(s2 != nullptr); jstring s3 = reinterpret_cast(env->AllocObject(c)); - assert(s3 != nullptr); + CHECK(s3 != nullptr); jstring s4 = reinterpret_cast(env->AllocObject(c)); - assert(s4 != nullptr); + CHECK(s4 != nullptr); jcharArray char_array = env->NewCharArray(5); jstring string_arg = env->NewStringUTF("helloworld"); @@ -621,18 +620,18 @@ extern "C" JNIEXPORT void JNICALL Java_Main_testNewStringObject(JNIEnv* env, jcl // Test with global and weak global references jstring s5 = reinterpret_cast(env->AllocObject(c)); - assert(s5 != nullptr); + CHECK(s5 != nullptr); s5 = reinterpret_cast(env->NewGlobalRef(s5)); jstring s6 = reinterpret_cast(env->AllocObject(c)); - assert(s6 != nullptr); + CHECK(s6 != nullptr); s6 = reinterpret_cast(env->NewWeakGlobalRef(s6)); env->CallVoidMethod(s5, mid1); env->CallNonvirtualVoidMethod(s6, c, mid2, byte_array); - assert(env->GetStringLength(s5) == 0); - assert(env->GetStringLength(s6) == byte_array_length); + CHECK_EQ(env->GetStringLength(s5), 0); + CHECK_EQ(env->GetStringLength(s6), byte_array_length); const char* chars6 = env->GetStringUTFChars(s6, nullptr); - assert(strcmp(test_array, chars6) == 0); + CHECK_EQ(strcmp(test_array, chars6), 0); env->ReleaseStringUTFChars(s6, chars6); } @@ -664,8 +663,8 @@ class JniCallDefaultMethodsTest { public: explicit JniCallDefaultMethodsTest(JNIEnv* env) : env_(env), concrete_class_(env_->FindClass("ConcreteClass")) { - assert(!env_->ExceptionCheck()); - assert(concrete_class_ != nullptr); + CHECK(!env_->ExceptionCheck()); + CHECK(concrete_class_ != nullptr); } void Test() { @@ -688,14 +687,14 @@ class JniCallDefaultMethodsTest { void TestCalls(const char* declaring_class, std::vector methods) { jmethodID new_method = env_->GetMethodID(concrete_class_, "", "()V"); jobject obj = env_->NewObject(concrete_class_, new_method); - assert(!env_->ExceptionCheck()); - assert(obj != nullptr); + CHECK(!env_->ExceptionCheck()); + CHECK(obj != nullptr); jclass decl_class = env_->FindClass(declaring_class); - assert(!env_->ExceptionCheck()); - assert(decl_class != nullptr); + CHECK(!env_->ExceptionCheck()); + CHECK(decl_class != nullptr); for (const char* method : methods) { jmethodID method_id = env_->GetMethodID(decl_class, method, "()V"); - assert(!env_->ExceptionCheck()); + CHECK(!env_->ExceptionCheck()); printf("Calling method %s->%s on object of type ConcreteClass\n", declaring_class, method); env_->CallVoidMethod(obj, method_id); if (env_->ExceptionCheck()) { @@ -704,10 +703,10 @@ class JniCallDefaultMethodsTest { jmethodID to_string = env_->GetMethodID( env_->FindClass("java/lang/Object"), "toString", "()Ljava/lang/String;"); jstring exception_string = (jstring) env_->CallObjectMethod(thrown, to_string); - assert(!env_->ExceptionCheck()); + CHECK(!env_->ExceptionCheck()); const char* exception_string_utf8 = env_->GetStringUTFChars(exception_string, nullptr); - assert(!env_->ExceptionCheck()); - assert(exception_string_utf8 != nullptr); + CHECK(!env_->ExceptionCheck()); + CHECK(exception_string_utf8 != nullptr); printf("EXCEPTION OCCURED: %s\n", exception_string_utf8); env_->ReleaseStringUTFChars(exception_string, exception_string_utf8); } @@ -724,12 +723,12 @@ extern "C" JNIEXPORT void JNICALL Java_Main_testCallDefaultMethods(JNIEnv* env) static void InvokeSpecificMethod(JNIEnv* env, jobject obj, const char* method) { jclass lambda_class = env->FindClass("LambdaInterface"); - assert(!env->ExceptionCheck()); - assert(lambda_class != nullptr); + CHECK(!env->ExceptionCheck()); + CHECK(lambda_class != nullptr); jmethodID method_id = env->GetMethodID(lambda_class, method, "()V"); - assert(!env->ExceptionCheck()); + CHECK(!env->ExceptionCheck()); env->CallVoidMethod(obj, method_id); - assert(!env->ExceptionCheck()); + CHECK(!env->ExceptionCheck()); } extern "C" JNIEXPORT void JNICALL Java_Main_testInvokeLambdaDefaultMethod( @@ -740,3 +739,6 @@ extern "C" JNIEXPORT void JNICALL Java_Main_testInvokeLambdaDefaultMethod( extern "C" JNIEXPORT void JNICALL Java_Main_testInvokeLambdaMethod(JNIEnv* e, jclass, jobject l) { InvokeSpecificMethod(e, l, "sayHi"); } + +} // namespace art + diff --git a/test/004-ReferenceMap/stack_walk_refmap_jni.cc b/test/004-ReferenceMap/stack_walk_refmap_jni.cc index 284e5544f..5304590ad 100644 --- a/test/004-ReferenceMap/stack_walk_refmap_jni.cc +++ b/test/004-ReferenceMap/stack_walk_refmap_jni.cc @@ -14,6 +14,7 @@ * limitations under the License. */ +#include "art_method-inl.h" #include "check_reference_map_visitor.h" #include "jni.h" diff --git a/test/004-StackWalk/stack_walk_jni.cc b/test/004-StackWalk/stack_walk_jni.cc index 51bb68f24..420224dd2 100644 --- a/test/004-StackWalk/stack_walk_jni.cc +++ b/test/004-StackWalk/stack_walk_jni.cc @@ -14,6 +14,7 @@ * limitations under the License. */ +#include "art_method-inl.h" #include "check_reference_map_visitor.h" #include "jni.h" diff --git a/test/136-daemon-jni-shutdown/daemon_jni_shutdown.cc b/test/136-daemon-jni-shutdown/daemon_jni_shutdown.cc index 074c9b189..c9110a905 100644 --- a/test/136-daemon-jni-shutdown/daemon_jni_shutdown.cc +++ b/test/136-daemon-jni-shutdown/daemon_jni_shutdown.cc @@ -48,7 +48,8 @@ extern "C" JNIEXPORT void JNICALL Java_Main_destroyJavaVMAndExit(JNIEnv* env, jc vm->DetachCurrentThread(); // Open ourself again to make sure the native library does not get unloaded from // underneath us due to DestroyJavaVM. b/28406866 - dlopen(kIsDebugBuild ? "libarttestd.so" : "libarttest.so", RTLD_NOW); + void* handle = dlopen(kIsDebugBuild ? "libarttestd.so" : "libarttest.so", RTLD_NOW); + CHECK(handle != nullptr); vm->DestroyJavaVM(); vm_was_shutdown.store(true); // Give threads some time to get stuck in ExceptionCheck. diff --git a/test/570-checker-osr/osr.cc b/test/570-checker-osr/osr.cc index bd8f0a952..2fa5800e5 100644 --- a/test/570-checker-osr/osr.cc +++ b/test/570-checker-osr/osr.cc @@ -14,7 +14,7 @@ * limitations under the License. */ -#include "art_method.h" +#include "art_method-inl.h" #include "jit/jit.h" #include "jit/jit_code_cache.h" #include "jit/profiling_info.h" diff --git a/test/595-profile-saving/profile-saving.cc b/test/595-profile-saving/profile-saving.cc index a7e6f8ba8..0d26f454c 100644 --- a/test/595-profile-saving/profile-saving.cc +++ b/test/595-profile-saving/profile-saving.cc @@ -16,6 +16,7 @@ #include "dex_file.h" +#include "art_method-inl.h" #include "jit/offline_profiling_info.h" #include "jit/profile_saver.h" #include "jni.h" diff --git a/test/596-app-images/app_images.cc b/test/596-app-images/app_images.cc index 11c0f424b..a5bbf5fba 100644 --- a/test/596-app-images/app_images.cc +++ b/test/596-app-images/app_images.cc @@ -14,7 +14,6 @@ * limitations under the License. */ -#include #include #include #include diff --git a/test/Android.libarttest.mk b/test/Android.libarttest.mk index 1550cc440..21f8141c6 100644 --- a/test/Android.libarttest.mk +++ b/test/Android.libarttest.mk @@ -93,7 +93,12 @@ define build-libarttest include $(BUILD_SHARED_LIBRARY) else # host LOCAL_CLANG := $(ART_HOST_CLANG) - LOCAL_CFLAGS := $(ART_HOST_CFLAGS) $(ART_HOST_DEBUG_CFLAGS) + LOCAL_CFLAGS := $(ART_HOST_CFLAGS) + ifeq ($$(suffix),d) + LOCAL_CFLAGS += $(ART_HOST_DEBUG_CFLAGS) + else + LOCAL_CFLAGS += $(ART_HOST_NON_DEBUG_CFLAGS) + endif LOCAL_ASFLAGS := $(ART_HOST_ASFLAGS) LOCAL_LDLIBS := $(ART_HOST_LDLIBS) -ldl -lpthread LOCAL_IS_HOST_MODULE := true -- 2.11.0