//==========helper functions================= void doTestAll(const char* soFile) { ClassLoader *loader = new ClassLoader(soFile); void *test; TS_ASSERT_THROWS_NOTHING((TestInterface *)loader->createInstance("TestReader", test)); TS_ASSERT(test != NULL); if(test) ((TestInterface *)test)->hello(); delete test; TS_ASSERT_THROWS_NOTHING((TestInterface *)loader->createInstance("TestWriter", test)); TS_ASSERT(test != NULL); if(test) ((TestInterface *)test)->hello(); delete test; TS_ASSERT_THROWS_NOTHING((TestInterface *)loader->createInstance("TestTemplate<int>", test)); TS_ASSERT(test != NULL); if(test) ((TestInterface *)test)->hello(); delete test; TS_ASSERT_THROWS_NOTHING((TestInterface *)loader->createInstance("TestTemplate<float>", test)); TS_ASSERT(test != NULL); if(test) ((TestInterface *)test)->hello(); delete test; TS_ASSERT_THROWS((TestInterface *)loader->createInstance("TestXXX", test),ClassLoaderError); delete loader; }
void ClassLoaderTest::testClassLoader3() { std::string path = "TestLibrary"; path.append(SharedLibrary::suffix()); ClassLoader<TestPlugin> cl; cl.loadLibrary(path); cl.loadLibrary(path); cl.unloadLibrary(path); assert (cl.manifestFor(path).size() == 3); ClassLoader<TestPlugin>::Iterator it = cl.begin(); assert (it != cl.end()); assert (it->first == path); assert (it->second->size() == 3); ++it; assert (it == cl.end()); cl.unloadLibrary(path); assertNullPtr (cl.findManifest(path)); }
void ClassLoaderTest::testClassLoader1() { std::string path = "TestLibrary"; path.append(SharedLibrary::suffix()); ClassLoader<TestPlugin> cl; assert (cl.begin() == cl.end()); assertNullPtr (cl.findClass("PluginA")); assertNullPtr (cl.findManifest(path)); assert (!cl.isLibraryLoaded(path)); try { const ClassLoader<TestPlugin>::Meta& meta = cl.classFor("PluginA"); fail("not found - must throw exception"); } catch (NotFoundException&) { } catch (...) { failmsg("wrong exception"); } try { const ClassLoader<TestPlugin>::Manif& manif = cl.manifestFor(path); fail("not found - must throw exception"); } catch (NotFoundException&) { } catch (...) { failmsg("wrong exception"); } }
void ClassLoaderTest::testClassLoader2() { std::string path = "TestLibrary"; path.append(SharedLibrary::suffix()); ClassLoader<TestPlugin> cl; cl.loadLibrary(path); assert (cl.begin() != cl.end()); assertNotNullPtr (cl.findClass("PluginA")); assertNotNullPtr (cl.findClass("PluginB")); assertNotNullPtr (cl.findClass("PluginC")); assertNotNullPtr (cl.findManifest(path)); assert (cl.isLibraryLoaded(path)); assert (cl.manifestFor(path).size() == 3); ClassLoader<TestPlugin>::Iterator it = cl.begin(); assert (it != cl.end()); assert (it->first == path); assert (it->second->size() == 3); ++it; assert (it == cl.end()); TestPlugin* pPluginA = cl.classFor("PluginA").create(); assert (pPluginA->name() == "PluginA"); assert (!cl.classFor("PluginA").isAutoDelete(pPluginA)); delete pPluginA; TestPlugin* pPluginB = cl.classFor("PluginB").create(); assert (pPluginB->name() == "PluginB"); delete pPluginB; pPluginB = cl.create("PluginB"); assert (pPluginB->name() == "PluginB"); delete pPluginB; assert (cl.canCreate("PluginA")); assert (cl.canCreate("PluginB")); assert (!cl.canCreate("PluginC")); TestPlugin& pluginC = cl.instance("PluginC"); assert (pluginC.name() == "PluginC"); try { TestPlugin& plgB = cl.instance("PluginB"); fail("not a singleton - must throw"); } catch (InvalidAccessException&) { } try { TestPlugin* pPluginC = cl.create("PluginC"); fail("cannot create a singleton - must throw"); } catch (InvalidAccessException&) { } try { const AbstractMetaObject<TestPlugin>& meta = cl.classFor("PluginC"); meta.autoDelete(&(meta.instance())); fail("cannot take ownership of a singleton - must throw"); } catch (InvalidAccessException&) { } const AbstractMetaObject<TestPlugin>& meta1 = cl.classFor("PluginC"); assert (meta1.isAutoDelete(&(meta1.instance()))); // the following must not produce memory leaks const AbstractMetaObject<TestPlugin>& meta2 = cl.classFor("PluginA"); meta2.autoDelete(meta2.create()); meta2.autoDelete(meta2.create()); TestPlugin* pPlugin = meta2.create(); meta2.autoDelete(pPlugin); assert (meta2.isAutoDelete(pPlugin)); meta2.destroy(pPlugin); assert (!meta2.isAutoDelete(pPlugin)); cl.unloadLibrary(path); }
/* * Class: java_lang_VMClassRegistry * Method: getSystemPackages * Signature: (I)[[Ljava/lang/String; */ JNIEXPORT jobjectArray JNICALL Java_java_lang_VMClassRegistry_getSystemPackages (JNIEnv *jenv, jclass, jint len) { Global_Env* genv = VM_Global_State::loader_env; ClassLoader* cl = static_cast<ClassLoader*> (genv->bootstrap_class_loader); Package_Table* ptab = cl->getPackageTable(); cl->Lock(); unsigned p_num = (unsigned)ptab->size(); if (p_num == (unsigned)len) { cl->Unlock(); return NULL; } const char ** pkgs = (const char **)STD_MALLOC(p_num * 2 * sizeof(char*)); size_t buf_len = 0; unsigned index = 0; for (Package_Table::const_iterator it = ptab->begin(), end = ptab->end(); it != end; ++it) { const char* name = pkgs[index++] = (*it).first->bytes; pkgs[index++] = (*it).second->get_jar(); size_t name_len = (*it).first->len; if (name_len > buf_len) { buf_len = name_len; } } cl->Unlock(); jclass string_class = struct_Class_to_java_lang_Class_Handle(genv->JavaLangString_Class); static Class* aos = genv->LoadCoreClass("[Ljava/lang/String;"); jclass string_array_class = struct_Class_to_java_lang_Class_Handle(aos); assert(string_class); assert(string_array_class); jobjectArray result = NewObjectArray(jenv, p_num, string_array_class, NULL); if (result) { char* buf = (char*)STD_MALLOC(buf_len + 1); p_num *= 2; for (index = 0; index < p_num; ) { jobjectArray pair = NewObjectArray(jenv, 2, string_class, NULL); if (!pair) { break; } SetObjectArrayElement(jenv, result, index/2, pair); char* name = strcpy(buf, pkgs[index++]); for (char* c = name; *c != '\0'; ++c) { if (*c == '/') { *c = '.'; } } jstring jname = NewStringUTF(jenv, name); if (!jname) { break; } SetObjectArrayElement(jenv, pair, 0, jname); const char * jar = pkgs[index++]; if (jar) { jstring js = NewStringUTF(jenv, jar); if (!js) break; SetObjectArrayElement(jenv, pair, 1, js); } } STD_FREE(buf); } STD_FREE(pkgs); assert(result || exn_raised()); return result; }
JNIEXPORT void JNICALL Java_java_lang_ClassLoader_registerInitiatedClass(JNIEnv* env, jobject loader, jclass clazz) { ClassLoader* cl = class_loader_lookup(loader); Class* clss = jclass_to_struct_Class(clazz); cl->InsertInitiatedClass(clss); }
Object AbstractContextI::lookupObjectFactory(const String& name, bool& createdbyfactory, String& redirectedname) const throw (NamingException) { try { redirectedname = name; createdbyfactory = false; Object object = lookupWithSyntaxCheck(name, false); StringAnything referencelink; if (object->instanceOf(referencelink)) { if (isBound(referencelink->toString())) { object = lookupURL(referencelink->toString()); redirectedname = referencelink->toString(); } } MapAnything objectfactory; if (object->instanceOf(objectfactory)) { if (objectfactory->containsKey(L"class") && objectfactory->containsKey(L"library")) { bool load = true; if (objectfactory->containsKey(L"load")) load = objectfactory->get(L"load"); if (load) { ClassLoader classloader; String clazzname = objectfactory->get(L"class"); Anything library = objectfactory->get(L"library"); if (Anything::ANY_STRING == library->type()) { StringBuffer buf = library->toString(); if (0 == buf->indexOf(L"http://")) { classloader = new URLClassLoaderI(); } else { classloader = new ClassLoaderI(); } classloader->loadLibrary(library); } else { if (Anything::ANY_LIST == library->type()) { classloader = new URLClassLoaderI(); Iterator<Anything> i = library->iterator(); while (i->hasNext()) { String library = i->next(); classloader->loadLibrary(library); } } } object = classloader->loadClass(clazzname)->newInstance(); const_cast<AbstractContextI*>(this)->rebind(name, object); createdbyfactory = true; const_cast<AbstractContextI*>(this)->bind( name + L"/" + name->toMD5(), new StringAnythingI(redirectedname)); } } } else { createdbyfactory = isBound(name + L"/" + name->toMD5()); if (createdbyfactory) redirectedname = lookup(name + L"/" + name->toMD5())->toString(); } return object; } catch (const NamingException&) { throw; } catch (const Exception& e) { throw NamingException(WITHDETAILS(e->toString()));; } }