/*
* Class: org_mahu_proto_jnitest_nativewrapper_HelloJNI
* Method: testErrorCase1
* Signature: (I)I
*/
JNIEXPORT jint JNICALL Java_org_mahu_proto_jnitest_nativewrapper_HelloJNI_testErrorCase1
(JNIEnv *env, jobject obj, jint test) {
try
{
return Java_org_mahu_proto_jnitest_nativewrapper_HelloJNI_testErrorCase1_helper(env,obj, test);
}
catch(const std::exception& ex)
{
std::cerr << "Error occurred: " << ex.what() << std::endl;
ThrowJavaRuntimeException jex(env, ex.what());
}
catch(...)
{
// catch any other errors (that we have no information about)
std::cerr << "Unknown failure occured. Possible memory corruption" << std::endl;
ThrowJavaRuntimeException jex(env, "unknown");
}
return 1;
}
JNIEXPORT void JNICALL Java_org_mahu_proto_jnitest_nativewrapper_HelloJNI_processDataClass1
(JNIEnv *env, jobject obj, jobject dataClass1Obj) {
try
{
Java_org_mahu_proto_jnitest_nativewrapper_HelloJNI_processDataClass1_b(env,obj,dataClass1Obj);
}
catch(const std::exception& ex)
{
std::cerr << "Error occurred: " << ex.what() << std::endl;
ThrowJavaRuntimeException jex(env, ex.what());
}
catch(...)
{
// catch any other errors (that we have no information about)
std::cerr << "Unknown failure occured. Possible memory corruption" << std::endl;
ThrowJavaRuntimeException jex(env, "unknown");
}
}
bool jexcheck(JNIEnv *env)
{
jhthrowable jex(env->ExceptionOccurred());
if (!jex)
return true;
jmethodID mid = get_method_id(env, jex, "getMessage", "()Ljava/lang/String;");
scope_c_ptr_t<const char> s(jcast<const char *>((jstring)env->CallObjectMethod(jex.get(), mid)));
ERR("java exception: %s", s.get());
env->ExceptionDescribe();
env->ExceptionClear();
errno = EFAULT;
return false;
}
jint JNICALL Java_org_mahu_proto_jnitest_nativewrapper_HelloJNI_testErrorCase1_helper
(JNIEnv *env, jobject obj, jint test)
{
printf("### Java_org_mahu_proto_jnitest_nativewrapper_HelloJNI_testErrorCase1, test %i\n",test);
switch(test) {
case 0: // unknown class
{
env->FindClass("org/unknown/notExistingClass");
return 1;
}
case 1: // unknown method
{
JavaClass dataClass(env,"org/mahu/proto/jnitest/nativewrapper/DataClass");
dataClass.getMethodID("someUnknownMethod", "()V");
return 1;
}
case 2: // unknown field
{
JavaClass dataClass(env,"org/mahu/proto/jnitest/nativewrapper/DataClass");
dataClass.getFieldID("unknownField", "I");
return 1;
}
case 3: // invalid class as argument
{
JavaClass dataClass(env,"org/mahu/proto/jnitest/nativewrapper/DataClass");
jmethodID setStringValueMethod = dataClass.getMethodID("setStringValue", "(Ljava/lang/String;)V");
jobject dataClassObj = dataClass.newInstance();
if (dataClassObj==NULL) {
printf("Failed to create object DataClass\n");
return 1;
}
printf("Assiging DataClass object to a setStringValue(String). Exception expected\n");
// Bug in OpenJdk, nothing goes wrong
// DataClass: setStringValue, s.class: org.mahu.proto.jnitest.nativewrapper.DataClass
env->CallVoidMethod(dataClassObj, setStringValueMethod, dataClassObj);
return 1;
}
case 4: // throw exception
// This test results in a core dump on OpenJDK.
{
throw std::runtime_error("Throwing cpp exception");
return 1;
}
case 5: // catch throw C++ exception
{
try {
throw std::runtime_error("Throwing cpp exception");
return -1;
}
catch (...) {
printf("5: caught thrown exception\n");
return 1;
}
}
case 6: // throw Java Exception
{
ThrowJavaRuntimeException ex(env, "c++ error message");
return 1;
}
case 7:
case 8:
case 9:
{
try
{
if (test==7) {
throw std::runtime_error("cpp exception");
}
if (test==8) {
throw MyException("cpp MyException");
}
if (test==9) {
char *ptr = 0;
ptr[0]=0;
}
}
catch(const std::runtime_error& re)
{
// specific handling for runtime_error
std::cerr << "Runtime error: " << re.what() << std::endl;
ThrowJavaRuntimeException jex(env, re.what());
}
catch(const std::exception& ex)
{
// speciffic handling for all exceptions extending std::exception, except
// std::runtime_error which is handled explicitly
std::cerr << "Error occurred: " << ex.what() << std::endl;
ThrowJavaRuntimeException jex(env, ex.what());
}
catch(...)
{
// catch any other errors (that we have no information about)
std::cerr << "Unknown failure occured. Possible memory corruption" << std::endl;
ThrowJavaRuntimeException jex(env, "unknown");
}
break;
}
case 10: // CatchException unknown class
{
printf("CatchException unknown class\n");
try {
FinallyClass fc;
env->FindClass("org/unknown/notExistingClass");
return -1;
}
catch (...) {
printf("10: default exception\n");
return 1;
}
}
case 11: // JNI_assert because of null classname
{
try
{
JavaClass noClassName(env, (jclass)0);
}
catch(const std::exception& ex)
{
std::cerr << "Error occurred: " << ex.what() << std::endl;
ThrowJavaRuntimeException jex(env, ex.what());
}
catch(...)
{
// catch any other errors (that we have no information about)
std::cerr << "Unknown failure occured. Possible memory corruption" << std::endl;
ThrowJavaRuntimeException jex(env, "unknown");
}
break;
}
default: // unexpected
return -1;
}
return 0;
}
