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::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);
}
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()));;
}
}