void
Collocated::run(int argc, char** argv)
{
Ice::CommunicatorHolder communicator = initialize(argc, argv);
communicator->getProperties()->setProperty("TestAdapter.Endpoints", getTestEndpoint());
//
// 2 threads are necessary to dispatch the collocated transient() call with AMI
//
communicator->getProperties()->setProperty("TestAdapter.ThreadPool.Size", "2");
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter");
ServantLocatorPtr locator = ICE_MAKE_SHARED(ServantLocatorI);
adapter->addServantLocator(locator, "");
TestIntfPrxPtr allTests(TestHelper*);
allTests(this);
adapter->waitForDeactivate();
}
int
TestServer::run(int argc, char* argv[])
{
communicator()->getProperties()->setProperty("TestAdapter.Endpoints", "default -p 12010");
Ice::ObjectAdapterPtr adapter = communicator()->createObjectAdapter("TestAdapter");
adapter->addServantLocator(new ServantLocatorI(""), "");
adapter->addServantLocator(new ServantLocatorI("category"), "category");
adapter->add(new TestI, communicator()->stringToIdentity("asm"));
adapter->add(new TestActivationI, communicator()->stringToIdentity("test/activation"));
Test::TestIntfPrx allTests(const CommunicatorPtr&, bool);
allTests(communicator(), true);
return EXIT_SUCCESS;
}
int
TestServer::run(int argc, char* argv[])
{
communicator()->getProperties()->setProperty("TestAdapter.Endpoints", "default -p 12010 -t 10000:udp");
communicator()->getProperties()->setProperty("Ice.Warn.Dispatch", "0");
Ice::ObjectAdapterPtr adapter = communicator()->createObjectAdapter("TestAdapter");
adapter->addServantLocator(new ServantLocatorI(""), "");
adapter->addServantLocator(new ServantLocatorI("category"), "category");
adapter->add(new TestI, communicator()->stringToIdentity("asm"));
adapter->activate();
adapter->waitForDeactivate();
return EXIT_SUCCESS;
}
int
run(int argc, char* argv[], const Ice::CommunicatorPtr& communicator)
{
IceUtilInternal::Options opts;
opts.addOpt("", "array");
opts.addOpt("", "async");
vector<string> args;
try
{
args = opts.parse(argc, (const char**)argv);
}
catch(const IceUtilInternal::BadOptException& e)
{
cout << argv[0] << ": " << e.reason << endl;
return false;
}
bool array = opts.isSet("array");
bool async = opts.isSet("async");
communicator->getProperties()->setProperty("TestAdapter.Endpoints", getTestEndpoint(communicator, 0));
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter");
adapter->addServantLocator(ICE_MAKE_SHARED(ServantLocatorI, array, async), "");
adapter->activate();
TEST_READY
communicator->waitForShutdown();
return EXIT_SUCCESS;
}
int
run(int, char**, const Ice::CommunicatorPtr& communicator)
{
communicator->getProperties()->setProperty("TestAdapter.Endpoints", getTestEndpoint(communicator, 0) + ":udp");
communicator->getProperties()->setProperty("Ice.Warn.Dispatch", "0");
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter");
adapter->addServantLocator(ICE_MAKE_SHARED(ServantLocatorAMDI, ""), "");
adapter->addServantLocator(ICE_MAKE_SHARED(ServantLocatorAMDI, "category"), "category");
adapter->add(ICE_MAKE_SHARED(TestAMDI), communicator->stringToIdentity("asm"));
adapter->add(ICE_MAKE_SHARED(TestActivationI), communicator->stringToIdentity("test/activation"));
adapter->activate();
TEST_READY
adapter->waitForDeactivate();
return EXIT_SUCCESS;
}
int
run(int, char**, const Ice::CommunicatorPtr& communicator)
{
communicator->getProperties()->setProperty("TestAdapter.Endpoints", "default -p 12010:udp");
communicator->getProperties()->setProperty("Ice.Warn.Dispatch", "0");
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter");
adapter->addServantLocator(new ServantLocatorAMDI(""), "");
adapter->addServantLocator(new ServantLocatorAMDI("category"), "category");
adapter->add(new TestAMDI, communicator->stringToIdentity("asm"));
adapter->add(new TestActivationI, communicator->stringToIdentity("test/activation"));
adapter->activate();
TEST_READY
adapter->waitForDeactivate();
return EXIT_SUCCESS;
}
int
run(int, char**, const Ice::CommunicatorPtr& communicator)
{
communicator->getProperties()->setProperty("Ice.Warn.Dispatch", "0");
communicator->getProperties()->setProperty("TestAdapter.Endpoints", getTestEndpoint(communicator, 0));
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter");
adapter->addServantLocator(ICE_MAKE_SHARED(ServantLocatorI, ""), "");
adapter->addServantLocator(ICE_MAKE_SHARED(ServantLocatorI, "category"), "category");
adapter->add(ICE_MAKE_SHARED(TestI), communicator->stringToIdentity("asm"));
adapter->add(ICE_MAKE_SHARED(TestActivationI), communicator->stringToIdentity("test/activation"));
Test::TestIntfPrxPtr allTests(const CommunicatorPtr&);
allTests(communicator);
return EXIT_SUCCESS;
}
int
HRServer::run(int argc, char* argv[])
{
const string username = communicator()->getProperties()->getPropertyWithDefault("Oracle.Username", "scott");
const string password = communicator()->getProperties()->getPropertyWithDefault("Oracle.Password", "password");
const string connectString = communicator()->getProperties()->getProperty("Oracle.ConnectString");
//
// We use a single servant locator and a single category for all Emp and Dept objects
//
const string category = "OCCI";
Environment* env = 0;
StatelessConnectionPool* pool = 0;
try
{
env = Environment::createEnvironment(Environment::Mode(Environment::THREADED_MUTEXED | Environment::OBJECT));
DbTypesMap(env);
pool = env->createStatelessConnectionPool(username, password, connectString, 5, 2, 1,
StatelessConnectionPool::HOMOGENEOUS);
Ice::ObjectAdapterPtr adapter = communicator()->createObjectAdapter("HR");
DeptFactoryIPtr factory = new DeptFactoryI(env, pool, category);
adapter->addServantLocator(new OCCIServantLocator(factory), category);
adapter->add(factory, communicator()->stringToIdentity("DeptFactory"));
adapter->activate();
communicator()->waitForShutdown();
}
catch(...)
{
if(pool != 0)
{
env->terminateStatelessConnectionPool(pool);
}
if(env != 0)
{
Environment::terminateEnvironment(env);
}
throw;
}
if(pool != 0)
{
env->terminateStatelessConnectionPool(pool);
}
if(env != 0)
{
Environment::terminateEnvironment(env);
}
return EXIT_SUCCESS;
}
Ice::ObjectAdapterPtr
RegistryI::setupAdminSessionFactory(const Ice::ObjectAdapterPtr& registryAdapter,
const Ice::ObjectPtr& router,
const IceGrid::LocatorPrx& locator)
{
Ice::PropertiesPtr properties = _communicator->getProperties();
Ice::ObjectAdapterPtr adapter;
SessionServantManagerPtr servantManager;
if(!properties->getProperty("IceGrid.Registry.AdminSessionManager.Endpoints").empty())
{
adapter = _communicator->createObjectAdapter("IceGrid.Registry.AdminSessionManager");
servantManager = new SessionServantManager(adapter, _instanceName, false, getServerAdminCategory(), router, 0);
adapter->addServantLocator(servantManager, "");
}
assert(_reaper);
_adminSessionFactory = new AdminSessionFactory(servantManager, _database, _reaper, this);
if(servantManager)
{
Identity sessionMgrId;
sessionMgrId.category = _instanceName;
sessionMgrId.name = "AdminSessionManager";
Identity sslSessionMgrId;
sslSessionMgrId.category = _instanceName;
sslSessionMgrId.name = "AdminSSLSessionManager";
if(!_master)
{
sessionMgrId.name += "-" + _replicaName;
sslSessionMgrId.name += "-" + _replicaName;
}
adapter->add(new AdminSessionManagerI(_adminSessionFactory), sessionMgrId);
adapter->add(new AdminSSLSessionManagerI(_adminSessionFactory), sslSessionMgrId);
_wellKnownObjects->add(adapter->createProxy(sessionMgrId), Glacier2::SessionManager::ice_staticId());
_wellKnownObjects->add(adapter->createProxy(sslSessionMgrId), Glacier2::SSLSessionManager::ice_staticId());
}
if(adapter)
{
Ice::Identity dummy;
dummy.name = "dummy";
_wellKnownObjects->addEndpoint("AdminSessionManager", adapter->createDirectProxy(dummy));
}
_adminVerifier = getPermissionsVerifier(registryAdapter,
locator,
"IceGrid.Registry.AdminPermissionsVerifier",
properties->getProperty("IceGrid.Registry.AdminCryptPasswords"));
_sslAdminVerifier = getSSLPermissionsVerifier(locator, "IceGrid.Registry.AdminSSLPermissionsVerifier");
return adapter;
}
int
run(int, char**, const Ice::CommunicatorPtr& communicator)
{
communicator->getProperties()->setProperty("TestAdapter.Endpoints", "default -p 12010:udp");
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter");
ServantLocatorPtr locator = new ServantLocatorI;
adapter->addServantLocator(locator, "");
adapter->activate();
TEST_READY
adapter->waitForDeactivate();
return EXIT_SUCCESS;
}
int
LibraryServer::run(int argc, char*[])
{
if(argc > 1)
{
cerr << appName() << ": too many arguments" << endl;
return EXIT_FAILURE;
}
Ice::PropertiesPtr properties = communicator()->getProperties();
//
// Create an object adapter
//
Ice::ObjectAdapterPtr adapter = communicator()->createObjectAdapter("Library");
//
// Create an evictor for books.
//
Freeze::EvictorPtr evictor = Freeze::createBackgroundSaveEvictor(adapter, _envName, "books");
Ice::Int evictorSize = properties->getPropertyAsInt("EvictorSize");
if(evictorSize > 0)
{
evictor->setSize(evictorSize);
}
//
// Use the evictor as servant Locator.
//
adapter->addServantLocator(evictor, "book");
//
// Create the library, and add it to the object adapter.
//
LibraryIPtr library = new LibraryI(communicator(), _envName, "authors", evictor);
adapter->add(library, Ice::stringToIdentity("library"));
//
// Create and install a factory for books.
//
Ice::ValueFactoryPtr bookFactory = new BookFactory(library);
communicator()->getValueFactoryManager()->add(bookFactory, Demo::Book::ice_staticId());
//
// Everything ok, let's go.
//
shutdownOnInterrupt();
adapter->activate();
communicator()->waitForShutdown();
ignoreInterrupt();
return EXIT_SUCCESS;
}
int
TestServer::run(int argc, char* argv[])
{
communicator()->getProperties()->setProperty("TestAdapter.Endpoints", "default -p 12010 -t 10000");
Ice::ObjectAdapterPtr adapter = communicator()->createObjectAdapter("TestAdapter");
ServantLocatorPtr locator = new ServantLocatorI;
adapter->addServantLocator(locator, "");
TestIntfPrx allTests(const CommunicatorPtr&);
allTests(communicator());
adapter->waitForDeactivate();
return EXIT_SUCCESS;
}
Ice::ObjectAdapterPtr
RegistryI::setupClientSessionFactory(const Ice::ObjectAdapterPtr& registryAdapter, const IceGrid::LocatorPrx& locator)
{
Ice::PropertiesPtr properties = _communicator->getProperties();
Ice::ObjectAdapterPtr adapter;
SessionServantManagerPtr servantManager;
if(!properties->getProperty("IceGrid.Registry.SessionManager.Endpoints").empty())
{
adapter = _communicator->createObjectAdapter("IceGrid.Registry.SessionManager");
servantManager = new SessionServantManager(adapter, _instanceName, false, "", 0, 0);
adapter->addServantLocator(servantManager, "");
}
assert(_reaper);
_timer = new IceUtil::Timer(); // Used for for session allocation timeout.
_clientSessionFactory = new ClientSessionFactory(servantManager, _database, _timer, _reaper);
if(servantManager && _master) // Slaves don't support client session manager objects.
{
Identity sessionMgrId;
sessionMgrId.category = _instanceName;
sessionMgrId.name = "SessionManager";
Identity sslSessionMgrId;
sslSessionMgrId.category = _instanceName;
sslSessionMgrId.name = "SSLSessionManager";
adapter->add(new ClientSessionManagerI(_clientSessionFactory), sessionMgrId);
adapter->add(new ClientSSLSessionManagerI(_clientSessionFactory), sslSessionMgrId);
_wellKnownObjects->add(adapter->createProxy(sessionMgrId), Glacier2::SessionManager::ice_staticId());
_wellKnownObjects->add(adapter->createProxy(sslSessionMgrId), Glacier2::SSLSessionManager::ice_staticId());
}
if(adapter)
{
Ice::Identity dummy;
dummy.name = "dummy";
_wellKnownObjects->addEndpoint("SessionManager", adapter->createDirectProxy(dummy));
}
_clientVerifier = getPermissionsVerifier(registryAdapter,
locator,
"IceGrid.Registry.PermissionsVerifier",
properties->getProperty("IceGrid.Registry.CryptPasswords"));
_sslClientVerifier = getSSLPermissionsVerifier(locator, "IceGrid.Registry.SSLPermissionsVerifier");
return adapter;
}
ThrowerPrx
allTests(const Ice::CommunicatorPtr& communicator)
{
cout << "testing ice_print()/what()... " << flush;
{
A a;
string aMsg = "Test::A";
Ice::UnknownLocalException ule("thisFile", 99);
string uleMsg = "thisFile:99: Ice::UnknownLocalException:\nunknown local exception";
//
// Test ice_print().
//
{
stringstream str;
a.ice_print(str);
test(str.str() == aMsg);
}
{
stringstream str;
ule.ice_print(str);
test(str.str() == uleMsg);
}
//
// Test operator<<().
//
{
stringstream str;
str << a;
test(str.str() == aMsg);
}
{
stringstream str;
str << ule;
test(str.str() == uleMsg);
}
//
// Test what(). (Called twice because of lazy initialization in what().)
//
test(aMsg == a.what());
test(aMsg == a.what());
test(uleMsg == ule.what());
test(uleMsg == ule.what());
{
E ex("E");
ostringstream os;
ex.ice_print(os);
test(os.str() == "Test::E");
test(ex.data == "E");
}
//
// Test custom ice_print
//
{
F ex("F");
ostringstream os;
ex.ice_print(os);
test(os.str() == "Test::F data:'F'");
test(ex.data == "F");
}
{
G ex(__FILE__, __LINE__, "G");
ostringstream os;
ex.ice_print(os);
test(endsWith(os.str(), "Test::G"));
test(ex.data == "G");
}
{
H ex(__FILE__, __LINE__, "H");
ostringstream os;
ex.ice_print(os);
test(endsWith(os.str(), "Test::H data:'H'"));
test(ex.data == "H");
}
}
cout << "ok" << endl;
cout << "testing object adapter registration exceptions... " << flush;
{
Ice::ObjectAdapterPtr first;
try
{
first = communicator->createObjectAdapter("TestAdapter0");
test(false);
}
catch(const Ice::InitializationException& ex)
{
if(printException)
{
Ice::Print printer(communicator->getLogger());
printer << ex;
}
// Expected
}
string host = communicator->getProperties()->getPropertyAsIntWithDefault("Ice.IPv6", 0) == 0 ?
"127.0.0.1" : "\"0:0:0:0:0:0:0:1\"";
communicator->getProperties()->setProperty("TestAdapter0.Endpoints", "default -h " + host);
first = communicator->createObjectAdapter("TestAdapter0");
try
{
Ice::ObjectAdapterPtr second = communicator->createObjectAdapter("TestAdapter0");
test(false);
}
catch(const Ice::AlreadyRegisteredException& ex)
{
if(printException)
{
Ice::Print printer(communicator->getLogger());
printer << ex;
}
// Expected
}
try
{
Ice::ObjectAdapterPtr second =
communicator->createObjectAdapterWithEndpoints("TestAdapter0", "ssl -h foo -p 12011");
test(false);
}
catch(const Ice::AlreadyRegisteredException& ex)
{
if(printException)
{
Ice::Print printer(communicator->getLogger());
printer << ex;
}
// Expected.
}
first->deactivate();
}
cout << "ok" << endl;
cout << "testing servant registration exceptions... " << flush;
{
string host = communicator->getProperties()->getPropertyAsIntWithDefault("Ice.IPv6", 0) == 0 ?
"127.0.0.1" : "\"0:0:0:0:0:0:0:1\"";
communicator->getProperties()->setProperty("TestAdapter1.Endpoints", "default -h " + host);
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter1");
Ice::ObjectPtr obj = new EmptyI;
adapter->add(obj, communicator->stringToIdentity("x"));
try
{
adapter->add(obj, communicator->stringToIdentity("x"));
test(false);
}
catch(const Ice::AlreadyRegisteredException& ex)
{
if(printException)
{
Ice::Print printer(communicator->getLogger());
printer << ex;
}
}
try
{
adapter->add(obj, communicator->stringToIdentity(""));
}
catch(const Ice::IllegalIdentityException& ex)
{
test(ex.id.name == "");
if(printException)
{
Ice::Print printer(communicator->getLogger());
printer << ex;
}
}
try
{
adapter->add(0, communicator->stringToIdentity("x"));
}
catch(const Ice::IllegalServantException& ex)
{
if(printException)
{
Ice::Print printer(communicator->getLogger());
printer << ex;
}
}
adapter->remove(communicator->stringToIdentity("x"));
try
{
adapter->remove(communicator->stringToIdentity("x"));
test(false);
}
catch(const Ice::NotRegisteredException& ex)
{
if(printException)
{
Ice::Print printer(communicator->getLogger());
printer << ex;
}
}
adapter->deactivate();
}
cout << "ok" << endl;
cout << "testing servant locator registrations exceptions... " << flush;
{
string host = communicator->getProperties()->getPropertyAsIntWithDefault("Ice.IPv6", 0) == 0 ?
"127.0.0.1" : "\"0:0:0:0:0:0:0:1\"";
communicator->getProperties()->setProperty("TestAdapter2.Endpoints", "default -h " + host);
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter2");
Ice::ServantLocatorPtr loc = new ServantLocatorI;
adapter->addServantLocator(loc, "x");
try
{
adapter->addServantLocator(loc, "x");
test(false);
}
catch(const Ice::AlreadyRegisteredException&)
{
}
adapter->deactivate();
}
cout << "ok" << endl;
cout << "testing object factory registration exception... " << flush;
{
Ice::ObjectFactoryPtr of = new ObjectFactoryI;
communicator->addObjectFactory(of, "x");
try
{
communicator->addObjectFactory(of, "x");
test(false);
}
catch(const Ice::AlreadyRegisteredException&)
{
}
}
cout << "ok" << endl;
cout << "testing stringToProxy... " << flush;
string ref = "thrower:default -p 12010";
Ice::ObjectPrx base = communicator->stringToProxy(ref);
test(base);
cout << "ok" << endl;
cout << "testing checked cast... " << flush;
ThrowerPrx thrower = ThrowerPrx::checkedCast(base);
test(thrower);
test(thrower == base);
cout << "ok" << endl;
cout << "catching exact types... " << flush;
try
{
thrower->throwAasA(1);
test(false);
}
catch(const A& ex)
{
test(ex.aMem == 1);
}
catch(const Ice::Exception& ex)
{
cout << ex << endl;
test(false);
}
catch(...)
{
test(false);
}
try
{
thrower->throwAorDasAorD(1);
test(false);
}
catch(const A& ex)
{
test(ex.aMem == 1);
}
catch(...)
{
test(false);
}
try
{
thrower->throwAorDasAorD(-1);
test(false);
}
catch(const D& ex)
{
test(ex.dMem == -1);
}
catch(...)
{
test(false);
}
try
{
thrower->throwBasB(1, 2);
test(false);
}
catch(const B& ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
}
catch(...)
{
test(false);
}
try
{
thrower->throwCasC(1, 2, 3);
test(false);
}
catch(const C& ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
test(ex.cMem == 3);
}
catch(...)
{
test(false);
}
try
{
thrower->throwModA(1, 2);
test(false);
}
catch(const Mod::A& ex)
{
test(ex.aMem == 1);
test(ex.a2Mem == 2);
}
catch(const Ice::OperationNotExistException&)
{
//
// This operation is not supported in Java.
//
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
cout << "catching base types... " << flush;
try
{
thrower->throwBasB(1, 2);
test(false);
}
catch(const A& ex)
{
test(ex.aMem == 1);
}
catch(...)
{
test(false);
}
try
{
thrower->throwCasC(1, 2, 3);
test(false);
}
catch(const B& ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
}
catch(...)
{
test(false);
}
try
{
thrower->throwModA(1, 2);
test(false);
}
catch(const A& ex)
{
test(ex.aMem == 1);
}
catch(const Ice::OperationNotExistException&)
{
//
// This operation is not supported in Java.
//
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
cout << "catching derived types... " << flush;
try
{
thrower->throwBasA(1, 2);
test(false);
}
catch(const B& ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
}
catch(...)
{
test(false);
}
try
{
thrower->throwCasA(1, 2, 3);
test(false);
}
catch(const C& ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
test(ex.cMem == 3);
}
catch(...)
{
test(false);
}
try
{
thrower->throwCasB(1, 2, 3);
test(false);
}
catch(const C& ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
test(ex.cMem == 3);
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
if(thrower->supportsUndeclaredExceptions())
{
cout << "catching unknown user exception... " << flush;
try
{
thrower->throwUndeclaredA(1);
test(false);
}
catch(const Ice::UnknownUserException&)
{
}
catch(const Ice::Exception& ex)
{
cout << ex << endl;
cout << ex.ice_stackTrace() << endl;
test(false);
}
catch(...)
{
test(false);
}
try
{
thrower->throwUndeclaredB(1, 2);
test(false);
}
catch(const Ice::UnknownUserException&)
{
}
catch(...)
{
test(false);
}
try
{
thrower->throwUndeclaredC(1, 2, 3);
test(false);
}
catch(const Ice::UnknownUserException&)
{
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
}
if(thrower->ice_getConnection())
{
cout << "testing memory limit marshal exception..." << flush;
try
{
thrower->throwMemoryLimitException(Ice::ByteSeq());
test(false);
}
catch(const Ice::MemoryLimitException&)
{
}
catch(...)
{
test(false);
}
try
{
thrower->throwMemoryLimitException(Ice::ByteSeq(20 * 1024)); // 20KB
test(false);
}
catch(const Ice::ConnectionLostException&)
{
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
ThrowerPrx thrower2 = ThrowerPrx::uncheckedCast(communicator->stringToProxy("thrower:default -p 12011"));
try
{
thrower2->throwMemoryLimitException(Ice::ByteSeq(2 * 1024 * 1024)); // 2MB (no limits)
}
catch(const Ice::MemoryLimitException&)
{
}
ThrowerPrx thrower3 = ThrowerPrx::uncheckedCast(communicator->stringToProxy("thrower:default -p 12012"));
try
{
thrower3->throwMemoryLimitException(Ice::ByteSeq(1024)); // 1KB limit
test(false);
}
catch(const Ice::ConnectionLostException&)
{
}
cout << "ok" << endl;
}
cout << "catching object not exist exception... " << flush;
Ice::Identity id = communicator->stringToIdentity("does not exist");
try
{
ThrowerPrx thrower2 = ThrowerPrx::uncheckedCast(thrower->ice_identity(id));
thrower2->throwAasA(1);
// thrower2->ice_ping();
test(false);
}
catch(const Ice::ObjectNotExistException& ex)
{
test(ex.id == id);
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
cout << "catching facet not exist exception... " << flush;
try
{
ThrowerPrx thrower2 = ThrowerPrx::uncheckedCast(thrower, "no such facet");
try
{
thrower2->ice_ping();
test(false);
}
catch(const Ice::FacetNotExistException& ex)
{
test(ex.facet == "no such facet");
}
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
cout << "catching operation not exist exception... " << flush;
try
{
WrongOperationPrx thrower2 = WrongOperationPrx::uncheckedCast(thrower);
thrower2->noSuchOperation();
test(false);
}
catch(const Ice::OperationNotExistException& ex)
{
test(ex.operation == "noSuchOperation");
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
cout << "catching unknown local exception... " << flush;
try
{
thrower->throwLocalException();
test(false);
}
catch(const Ice::UnknownLocalException&)
{
}
catch(...)
{
test(false);
}
try
{
thrower->throwLocalExceptionIdempotent();
test(false);
}
catch(const Ice::UnknownLocalException&)
{
}
catch(const Ice::OperationNotExistException&)
{
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
cout << "catching unknown non-Ice exception... " << flush;
try
{
thrower->throwNonIceException();
test(false);
}
catch(const Ice::UnknownException&)
{
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
cout << "testing asynchronous exceptions... " << flush;
try
{
thrower->throwAfterResponse();
}
catch(...)
{
test(false);
}
try
{
thrower->throwAfterException();
}
catch(const A&)
{
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
cout << "catching exact types with new AMI mapping... " << flush;
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwAasAPtr callback =
newCallback_Thrower_throwAasA(cb, &Callback::response, &Callback::exception_AasA);
thrower->begin_throwAasA(1, callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwAorDasAorDPtr callback =
newCallback_Thrower_throwAorDasAorD(cb, &Callback::response, &Callback::exception_AorDasAorD);
thrower->begin_throwAorDasAorD(1, callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwAorDasAorDPtr callback =
newCallback_Thrower_throwAorDasAorD(cb, &Callback::response, &Callback::exception_AorDasAorD);
thrower->begin_throwAorDasAorD(-1, callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwBasBPtr callback =
newCallback_Thrower_throwBasB(cb, &Callback::response, &Callback::exception_BasB);
thrower->begin_throwBasB(1, 2, callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwCasCPtr callback =
newCallback_Thrower_throwCasC(cb, &Callback::response, &Callback::exception_CasC);
thrower->begin_throwCasC(1, 2, 3, callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwModAPtr callback =
newCallback_Thrower_throwModA(cb, &Callback::response, &Callback::exception_ModA);
thrower->begin_throwModA(1, 2, callback);
cb->check();
}
cout << "ok" << endl;
cout << "catching derived types with new AMI mapping... " << flush;
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwBasAPtr callback =
newCallback_Thrower_throwBasA(cb, &Callback::response, &Callback::exception_BasA);
thrower->begin_throwBasA(1, 2, callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwCasAPtr callback =
newCallback_Thrower_throwCasA(cb, &Callback::response, &Callback::exception_CasA);
thrower->begin_throwCasA(1, 2, 3, callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwCasBPtr callback =
newCallback_Thrower_throwCasB(cb, &Callback::response, &Callback::exception_CasB);
thrower->begin_throwCasB(1, 2, 3, callback);
cb->check();
}
cout << "ok" << endl;
if(thrower->supportsUndeclaredExceptions())
{
cout << "catching unknown user exception with new AMI mapping... " << flush;
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwUndeclaredAPtr callback =
newCallback_Thrower_throwUndeclaredA(cb, &Callback::response, &Callback::exception_UndeclaredA);
thrower->begin_throwUndeclaredA(1, callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwUndeclaredBPtr callback =
newCallback_Thrower_throwUndeclaredB(cb, &Callback::response, &Callback::exception_UndeclaredB);
thrower->begin_throwUndeclaredB(1, 2, callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwUndeclaredCPtr callback =
newCallback_Thrower_throwUndeclaredC(cb, &Callback::response, &Callback::exception_UndeclaredC);
thrower->begin_throwUndeclaredC(1, 2, 3, callback);
cb->check();
}
cout << "ok" << endl;
}
cout << "catching object not exist exception with new AMI mapping... " << flush;
{
id = communicator->stringToIdentity("does not exist");
ThrowerPrx thrower2 = ThrowerPrx::uncheckedCast(thrower->ice_identity(id));
CallbackPtr cb = new Callback(communicator);
Callback_Thrower_throwAasAPtr callback =
newCallback_Thrower_throwAasA(cb, &Callback::response, &Callback::exception_AasAObjectNotExist);
thrower2->begin_throwAasA(1, callback);
cb->check();
}
cout << "ok" << endl;
cout << "catching facet not exist exception with new AMI mapping... " << flush;
{
ThrowerPrx thrower2 = ThrowerPrx::uncheckedCast(thrower, "no such facet");
CallbackPtr cb = new Callback;
Callback_Thrower_throwAasAPtr callback =
newCallback_Thrower_throwAasA(cb, &Callback::response, &Callback::exception_AasAFacetNotExist);
thrower2->begin_throwAasA(1, callback);
cb->check();
}
cout << "ok" << endl;
cout << "catching operation not exist exception with new AMI mapping... " << flush;
{
CallbackPtr cb = new Callback;
Callback_WrongOperation_noSuchOperationPtr callback =
newCallback_WrongOperation_noSuchOperation(cb, &Callback::response,
&Callback::exception_noSuchOperation);
WrongOperationPrx thrower4 = WrongOperationPrx::uncheckedCast(thrower);
thrower4->begin_noSuchOperation(callback);
cb->check();
}
cout << "ok" << endl;
cout << "catching unknown local exception with new AMI mapping... " << flush;
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwLocalExceptionPtr callback =
newCallback_Thrower_throwLocalException(cb, &Callback::response, &Callback::exception_LocalException);
thrower->begin_throwLocalException(callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwLocalExceptionIdempotentPtr callback =
newCallback_Thrower_throwLocalExceptionIdempotent(cb, &Callback::response,
&Callback::exception_LocalException);
thrower->begin_throwLocalExceptionIdempotent(callback);
cb->check();
}
cout << "ok" << endl;
cout << "catching unknown non-Ice exception with new AMI mapping... " << flush;
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwNonIceExceptionPtr callback =
newCallback_Thrower_throwNonIceException(cb, &Callback::response, &Callback::exception_NonIceException);
thrower->begin_throwNonIceException(callback);
cb->check();
}
cout << "ok" << endl;
return thrower;
}
ThrowerPrxPtr
allTests(const Ice::CommunicatorPtr& communicator)
{
cout << "testing ice_print()/what()... " << flush;
{
A a;
string aMsg = "Test::A";
Ice::UnknownLocalException ule("thisFile", 99);
string uleMsg = "thisFile:99: Ice::UnknownLocalException:\nunknown local exception";
//
// Test ice_print().
//
{
stringstream str;
a.ice_print(str);
test(str.str() == aMsg);
}
{
stringstream str;
ule.ice_print(str);
test(str.str() == uleMsg);
}
//
// Test operator<<().
//
{
stringstream str;
str << a;
test(str.str() == aMsg);
}
{
stringstream str;
str << ule;
test(str.str() == uleMsg);
}
//
// Test what(). (Called twice because of lazy initialization in what().)
//
test(aMsg == a.what());
test(aMsg == a.what());
test(uleMsg == ule.what());
test(uleMsg == ule.what());
{
E ex("E");
ostringstream os;
ex.ice_print(os);
test(os.str() == "Test::E");
test(ex.data == "E");
}
//
// Test custom ice_print
//
{
F ex("F");
ostringstream os;
ex.ice_print(os);
test(os.str() == "Test::F data:'F'");
test(ex.data == "F");
}
{
G ex(__FILE__, __LINE__, "G");
ostringstream os;
ex.ice_print(os);
test(endsWith(os.str(), "Test::G"));
test(ex.data == "G");
}
{
H ex(__FILE__, __LINE__, "H");
ostringstream os;
ex.ice_print(os);
test(endsWith(os.str(), "Test::H data:'H'"));
test(ex.data == "H");
}
}
cout << "ok" << endl;
string localOAEndpoint;
{
ostringstream ostr;
if(communicator->getProperties()->getProperty("Ice.Default.Protocol") == "bt")
{
ostr << "default -a *";
}
else
{
ostr << "default -h *";
}
localOAEndpoint = ostr.str();
}
cout << "testing object adapter registration exceptions... " << flush;
{
Ice::ObjectAdapterPtr first;
try
{
first = communicator->createObjectAdapter("TestAdapter0");
test(false);
}
catch(const Ice::InitializationException& ex)
{
if(printException)
{
Ice::Print printer(communicator->getLogger());
printer << ex;
}
// Expected
}
communicator->getProperties()->setProperty("TestAdapter0.Endpoints", localOAEndpoint);
first = communicator->createObjectAdapter("TestAdapter0");
try
{
Ice::ObjectAdapterPtr second = communicator->createObjectAdapter("TestAdapter0");
test(false);
}
catch(const Ice::AlreadyRegisteredException& ex)
{
if(printException)
{
Ice::Print printer(communicator->getLogger());
printer << ex;
}
// Expected
}
try
{
Ice::ObjectAdapterPtr second =
communicator->createObjectAdapterWithEndpoints("TestAdapter0", "ssl -h foo -p 12011");
test(false);
}
catch(const Ice::AlreadyRegisteredException& ex)
{
if(printException)
{
Ice::Print printer(communicator->getLogger());
printer << ex;
}
// Expected.
}
first->deactivate();
}
cout << "ok" << endl;
cout << "testing servant registration exceptions... " << flush;
{
communicator->getProperties()->setProperty("TestAdapter1.Endpoints", localOAEndpoint);
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter1");
Ice::ObjectPtr obj = ICE_MAKE_SHARED(EmptyI);
adapter->add(obj, communicator->stringToIdentity("x"));
try
{
adapter->add(obj, communicator->stringToIdentity("x"));
test(false);
}
catch(const Ice::AlreadyRegisteredException& ex)
{
if(printException)
{
Ice::Print printer(communicator->getLogger());
printer << ex;
}
}
try
{
adapter->add(obj, communicator->stringToIdentity(""));
}
catch(const Ice::IllegalIdentityException& ex)
{
test(ex.id.name == "");
if(printException)
{
Ice::Print printer(communicator->getLogger());
printer << ex;
}
}
try
{
adapter->add(0, communicator->stringToIdentity("x"));
}
catch(const Ice::IllegalServantException& ex)
{
if(printException)
{
Ice::Print printer(communicator->getLogger());
printer << ex;
}
}
adapter->remove(communicator->stringToIdentity("x"));
try
{
adapter->remove(communicator->stringToIdentity("x"));
test(false);
}
catch(const Ice::NotRegisteredException& ex)
{
if(printException)
{
Ice::Print printer(communicator->getLogger());
printer << ex;
}
}
adapter->deactivate();
}
cout << "ok" << endl;
cout << "testing servant locator registrations exceptions... " << flush;
{
communicator->getProperties()->setProperty("TestAdapter2.Endpoints", localOAEndpoint);
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter2");
Ice::ServantLocatorPtr loc = ICE_MAKE_SHARED(ServantLocatorI);
adapter->addServantLocator(loc, "x");
try
{
adapter->addServantLocator(loc, "x");
test(false);
}
catch(const Ice::AlreadyRegisteredException&)
{
}
adapter->deactivate();
}
cout << "ok" << endl;
cout << "testing value factory registration exception... " << flush;
{
#ifdef ICE_CPP11_MAPPING
communicator->addValueFactory(
[](const std::string&)
{
return nullptr;
},
"x");
try
{
communicator->addValueFactory(
[](const std::string&)
{
return nullptr;
},
"x");
test(false);
}
catch(const Ice::AlreadyRegisteredException&)
{
}
#else
Ice::ValueFactoryPtr vf = new ValueFactoryI;
communicator->addValueFactory(vf, "x");
try
{
communicator->addValueFactory(vf, "x");
test(false);
}
catch(const Ice::AlreadyRegisteredException&)
{
}
#endif
}
cout << "ok" << endl;
cout << "testing stringToProxy... " << flush;
string ref = "thrower:" + getTestEndpoint(communicator, 0);
Ice::ObjectPrxPtr base = communicator->stringToProxy(ref);
test(base);
cout << "ok" << endl;
cout << "testing checked cast... " << flush;
ThrowerPrxPtr thrower = ICE_CHECKED_CAST(ThrowerPrx, base);
test(thrower);
#ifdef ICE_CPP11_MAPPING
test(Ice::targetEquals(thrower, base));
#else
test(thrower == base);
#endif
cout << "ok" << endl;
cout << "catching exact types... " << flush;
try
{
thrower->throwAasA(1);
test(false);
}
catch(const A& ex)
{
test(ex.aMem == 1);
}
catch(const Ice::Exception& ex)
{
cout << ex << endl;
test(false);
}
catch(...)
{
test(false);
}
try
{
thrower->throwAorDasAorD(1);
test(false);
}
catch(const A& ex)
{
test(ex.aMem == 1);
}
catch(...)
{
test(false);
}
try
{
thrower->throwAorDasAorD(-1);
test(false);
}
catch(const D& ex)
{
test(ex.dMem == -1);
}
catch(...)
{
test(false);
}
try
{
thrower->throwBasB(1, 2);
test(false);
}
catch(const B& ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
}
catch(...)
{
test(false);
}
try
{
thrower->throwCasC(1, 2, 3);
test(false);
}
catch(const C& ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
test(ex.cMem == 3);
}
catch(...)
{
test(false);
}
try
{
thrower->throwModA(1, 2);
test(false);
}
catch(const Mod::A& ex)
{
test(ex.aMem == 1);
test(ex.a2Mem == 2);
}
catch(const Ice::OperationNotExistException&)
{
//
// This operation is not supported in Java.
//
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
cout << "catching base types... " << flush;
try
{
thrower->throwBasB(1, 2);
test(false);
}
catch(const A& ex)
{
test(ex.aMem == 1);
}
catch(...)
{
test(false);
}
try
{
thrower->throwCasC(1, 2, 3);
test(false);
}
catch(const B& ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
}
catch(...)
{
test(false);
}
try
{
thrower->throwModA(1, 2);
test(false);
}
catch(const A& ex)
{
test(ex.aMem == 1);
}
catch(const Ice::OperationNotExistException&)
{
//
// This operation is not supported in Java.
//
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
cout << "catching derived types... " << flush;
try
{
thrower->throwBasA(1, 2);
test(false);
}
catch(const B& ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
}
catch(...)
{
test(false);
}
try
{
thrower->throwCasA(1, 2, 3);
test(false);
}
catch(const C& ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
test(ex.cMem == 3);
}
catch(...)
{
test(false);
}
try
{
thrower->throwCasB(1, 2, 3);
test(false);
}
catch(const C& ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
test(ex.cMem == 3);
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
if(thrower->supportsUndeclaredExceptions())
{
cout << "catching unknown user exception... " << flush;
try
{
thrower->throwUndeclaredA(1);
test(false);
}
catch(const Ice::UnknownUserException&)
{
}
catch(const Ice::Exception& ex)
{
cout << ex << endl;
cout << ex.ice_stackTrace() << endl;
test(false);
}
catch(...)
{
test(false);
}
try
{
thrower->throwUndeclaredB(1, 2);
test(false);
}
catch(const Ice::UnknownUserException&)
{
}
catch(...)
{
test(false);
}
try
{
thrower->throwUndeclaredC(1, 2, 3);
test(false);
}
catch(const Ice::UnknownUserException&)
{
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
}
if(thrower->ice_getConnection())
{
cout << "testing memory limit marshal exception..." << flush;
try
{
thrower->throwMemoryLimitException(Ice::ByteSeq());
test(false);
}
catch(const Ice::MemoryLimitException&)
{
}
catch(...)
{
test(false);
}
try
{
thrower->throwMemoryLimitException(Ice::ByteSeq(20 * 1024)); // 20KB
test(false);
}
catch(const Ice::ConnectionLostException&)
{
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
ThrowerPrxPtr thrower2 =
ICE_UNCHECKED_CAST(ThrowerPrx, communicator->stringToProxy("thrower:" + getTestEndpoint(communicator, 1)));
try
{
thrower2->throwMemoryLimitException(Ice::ByteSeq(2 * 1024 * 1024)); // 2MB (no limits)
}
catch(const Ice::MemoryLimitException&)
{
}
ThrowerPrxPtr thrower3 =
ICE_UNCHECKED_CAST(ThrowerPrx, communicator->stringToProxy("thrower:" + getTestEndpoint(communicator, 2)));
try
{
thrower3->throwMemoryLimitException(Ice::ByteSeq(1024)); // 1KB limit
test(false);
}
catch(const Ice::ConnectionLostException&)
{
}
cout << "ok" << endl;
}
cout << "catching object not exist exception... " << flush;
Ice::Identity id = communicator->stringToIdentity("does not exist");
try
{
ThrowerPrxPtr thrower2 = ICE_UNCHECKED_CAST(ThrowerPrx, thrower->ice_identity(id));
thrower2->throwAasA(1);
// thrower2->ice_ping();
test(false);
}
catch(const Ice::ObjectNotExistException& ex)
{
test(ex.id == id);
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
cout << "catching facet not exist exception... " << flush;
try
{
#ifdef ICE_CPP11_MAPPING
ThrowerPrxPtr thrower2 = Ice::uncheckedCast<ThrowerPrx>(thrower, "no such facet");
#else
ThrowerPrxPtr thrower2 = ThrowerPrx::uncheckedCast(thrower, "no such facet");
#endif
try
{
thrower2->ice_ping();
test(false);
}
catch(const Ice::FacetNotExistException& ex)
{
test(ex.facet == "no such facet");
}
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
cout << "catching operation not exist exception... " << flush;
try
{
WrongOperationPrxPtr thrower2 = ICE_UNCHECKED_CAST(WrongOperationPrx, thrower);
thrower2->noSuchOperation();
test(false);
}
catch(const Ice::OperationNotExistException& ex)
{
test(ex.operation == "noSuchOperation");
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
cout << "catching unknown local exception... " << flush;
try
{
thrower->throwLocalException();
test(false);
}
catch(const Ice::UnknownLocalException&)
{
}
catch(...)
{
test(false);
}
try
{
thrower->throwLocalExceptionIdempotent();
test(false);
}
catch(const Ice::UnknownLocalException&)
{
}
catch(const Ice::OperationNotExistException&)
{
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
cout << "catching unknown non-Ice exception... " << flush;
try
{
thrower->throwNonIceException();
test(false);
}
catch(const Ice::UnknownException&)
{
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
cout << "testing asynchronous exceptions... " << flush;
try
{
thrower->throwAfterResponse();
}
catch(...)
{
test(false);
}
try
{
thrower->throwAfterException();
}
catch(const A&)
{
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
cout << "catching exact types with new AMI mapping... " << flush;
#ifdef ICE_CPP11_MAPPING
{
auto f = thrower->throwAasA_async(1);
try
{
f.get();
test(false);
}
catch(const A& ex)
{
test(ex.aMem == 1);
}
catch(const Ice::Exception&)
{
test(false);
}
catch(...)
{
test(false);
}
}
{
auto f = thrower->throwAorDasAorD_async(1);
try
{
f.get();
test(false);
}
catch(const A& ex)
{
test(ex.aMem == 1);
}
catch(...)
{
test(false);
}
}
{
auto f = thrower->throwAorDasAorD_async(-1);
try
{
f.get();
test(false);
}
catch(const D& ex)
{
test(ex.dMem == -1);
}
catch(...)
{
test(false);
}
}
{
auto f = thrower->throwBasB_async(1, 2);
try
{
f.get();
test(false);
}
catch(const B& ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
}
catch(...)
{
test(false);
}
}
{
auto f = thrower->throwCasC_async(1, 2, 3);
try
{
f.get();
test(false);
}
catch(const C& ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
test(ex.cMem == 3);
}
catch(...)
{
test(false);
}
}
{
auto f = thrower->throwModA_async(1, 2);
try
{
f.get();
}
catch(const A& ex)
{
test(ex.aMem == 1);
}
catch(const Ice::OperationNotExistException&)
{
//
// This operation is not supported in Java.
//
}
catch(...)
{
test(false);
}
}
//
// repeat with callback API and no exception callback
//
{
promise<bool> sent;
thrower->throwAasA_async(1,
[]()
{
test(false);
},
nullptr,
[&](bool value)
{
sent.set_value(value);
});
sent.get_future().get(); // Wait for sent
}
{
promise<bool> sent;
thrower->throwAorDasAorD_async(1,
[]()
{
test(false);
},
nullptr,
[&](bool value)
{
sent.set_value(value);
});
sent.get_future().get(); // Wait for sent
}
{
promise<bool> sent;
thrower->throwAorDasAorD_async(-1,
[]()
{
test(false);
},
nullptr,
[&](bool value)
{
sent.set_value(value);
});
sent.get_future().get(); // Wait for sent
}
{
promise<bool> sent;
thrower->throwBasB_async(1, 2,
[]()
{
test(false);
},
nullptr,
[&](bool value)
{
sent.set_value(value);
});
sent.get_future().get(); // Wait for sent
}
{
promise<bool> sent;
thrower->throwCasC_async(1, 2, 3,
[]()
{
test(false);
},
nullptr,
[&](bool value)
{
sent.set_value(value);
});
sent.get_future().get(); // Wait for sent
}
{
promise<bool> sent;
thrower->throwModA_async(1, 2,
[]()
{
test(false);
},
nullptr,
[&](bool value)
{
sent.set_value(value);
});
sent.get_future().get(); // Wait for sent
}
#else
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwAasAPtr callback =
newCallback_Thrower_throwAasA(cb, &Callback::response, &Callback::exception_AasA);
thrower->begin_throwAasA(1, callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwAorDasAorDPtr callback =
newCallback_Thrower_throwAorDasAorD(cb, &Callback::response, &Callback::exception_AorDasAorD);
thrower->begin_throwAorDasAorD(1, callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwAorDasAorDPtr callback =
newCallback_Thrower_throwAorDasAorD(cb, &Callback::response, &Callback::exception_AorDasAorD);
thrower->begin_throwAorDasAorD(-1, callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwBasBPtr callback =
newCallback_Thrower_throwBasB(cb, &Callback::response, &Callback::exception_BasB);
thrower->begin_throwBasB(1, 2, callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwCasCPtr callback =
newCallback_Thrower_throwCasC(cb, &Callback::response, &Callback::exception_CasC);
thrower->begin_throwCasC(1, 2, 3, callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwModAPtr callback =
newCallback_Thrower_throwModA(cb, &Callback::response, &Callback::exception_ModA);
thrower->begin_throwModA(1, 2, callback);
cb->check();
}
#endif
cout << "ok" << endl;
cout << "catching derived types with new AMI mapping... " << flush;
#ifdef ICE_CPP11_MAPPING
{
auto f = thrower->throwBasA_async(1, 2);
try
{
f.get();
}
catch(const B& ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
}
catch(...)
{
test(false);
}
}
{
auto f = thrower->throwCasA_async(1, 2, 3);
try
{
f.get();
}
catch(const C& ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
test(ex.cMem == 3);
}
catch(...)
{
test(false);
}
}
{
auto f = thrower->throwCasB_async(1, 2, 3);
try
{
f.get();
}
catch(const C& ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
test(ex.cMem == 3);
}
catch(...)
{
test(false);
}
}
#else
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwBasAPtr callback =
newCallback_Thrower_throwBasA(cb, &Callback::response, &Callback::exception_BasA);
thrower->begin_throwBasA(1, 2, callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwCasAPtr callback =
newCallback_Thrower_throwCasA(cb, &Callback::response, &Callback::exception_CasA);
thrower->begin_throwCasA(1, 2, 3, callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwCasBPtr callback =
newCallback_Thrower_throwCasB(cb, &Callback::response, &Callback::exception_CasB);
thrower->begin_throwCasB(1, 2, 3, callback);
cb->check();
}
#endif
cout << "ok" << endl;
if(thrower->supportsUndeclaredExceptions())
{
cout << "catching unknown user exception with new AMI mapping... " << flush;
#ifdef ICE_CPP11_MAPPING
{
auto f = thrower->throwUndeclaredA_async(1);
try
{
f.get();
test(false);
}
catch(const Ice::UnknownUserException&)
{
}
catch(const Ice::Exception& ex)
{
cout << ex << endl;
cout << ex.ice_stackTrace() << endl;
test(false);
}
catch(...)
{
test(false);
}
}
{
auto f = thrower->throwUndeclaredB_async(1, 2);
try
{
f.get();
test(false);
}
catch(const Ice::UnknownUserException&)
{
}
catch(...)
{
test(false);
}
}
{
auto f = thrower->throwUndeclaredC_async(1, 2, 3);
try
{
f.get();
}
catch(const Ice::UnknownUserException&)
{
}
catch(...)
{
test(false);
}
}
#else
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwUndeclaredAPtr callback =
newCallback_Thrower_throwUndeclaredA(cb, &Callback::response, &Callback::exception_UndeclaredA);
thrower->begin_throwUndeclaredA(1, callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwUndeclaredBPtr callback =
newCallback_Thrower_throwUndeclaredB(cb, &Callback::response, &Callback::exception_UndeclaredB);
thrower->begin_throwUndeclaredB(1, 2, callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwUndeclaredCPtr callback =
newCallback_Thrower_throwUndeclaredC(cb, &Callback::response, &Callback::exception_UndeclaredC);
thrower->begin_throwUndeclaredC(1, 2, 3, callback);
cb->check();
}
#endif
cout << "ok" << endl;
}
cout << "catching object not exist exception with new AMI mapping... " << flush;
{
#ifdef ICE_CPP11_MAPPING
id = communicator->stringToIdentity("does not exist");
shared_ptr<ThrowerPrx> thrower2 = Ice::uncheckedCast<ThrowerPrx>(thrower->ice_identity(id));
auto f = thrower2->throwAasA_async(1);
try
{
f.get();
}
catch(const Ice::ObjectNotExistException& ex)
{
test(ex.id == id);
}
catch(...)
{
test(false);
}
#else
id = communicator->stringToIdentity("does not exist");
ThrowerPrx thrower2 = ThrowerPrx::uncheckedCast(thrower->ice_identity(id));
CallbackPtr cb = new Callback(communicator);
Callback_Thrower_throwAasAPtr callback =
newCallback_Thrower_throwAasA(cb, &Callback::response, &Callback::exception_AasAObjectNotExist);
thrower2->begin_throwAasA(1, callback);
cb->check();
#endif
}
cout << "ok" << endl;
cout << "catching facet not exist exception with new AMI mapping... " << flush;
{
#ifdef ICE_CPP11_MAPPING
shared_ptr<ThrowerPrx> thrower2 = Ice::uncheckedCast<ThrowerPrx>(thrower, "no such facet");
auto f = thrower2->throwAasA_async(1);
try
{
f.get();
}
catch(const Ice::FacetNotExistException& ex)
{
test(ex.facet == "no such facet");
}
#else
ThrowerPrx thrower2 = ThrowerPrx::uncheckedCast(thrower, "no such facet");
CallbackPtr cb = new Callback;
Callback_Thrower_throwAasAPtr callback =
newCallback_Thrower_throwAasA(cb, &Callback::response, &Callback::exception_AasAFacetNotExist);
thrower2->begin_throwAasA(1, callback);
cb->check();
#endif
}
cout << "ok" << endl;
cout << "catching operation not exist exception with new AMI mapping... " << flush;
{
#ifdef ICE_CPP11_MAPPING
shared_ptr<WrongOperationPrx> thrower4 = Ice::uncheckedCast<WrongOperationPrx>(thrower);
auto f = thrower4->noSuchOperation_async();
try
{
f.get();
}
catch(const Ice::OperationNotExistException& ex)
{
test(ex.operation == "noSuchOperation");
}
catch(...)
{
test(false);
}
#else
CallbackPtr cb = new Callback;
Callback_WrongOperation_noSuchOperationPtr callback =
newCallback_WrongOperation_noSuchOperation(cb, &Callback::response,
&Callback::exception_noSuchOperation);
WrongOperationPrx thrower4 = WrongOperationPrx::uncheckedCast(thrower);
thrower4->begin_noSuchOperation(callback);
cb->check();
#endif
}
cout << "ok" << endl;
cout << "catching unknown local exception with new AMI mapping... " << flush;
#ifdef ICE_CPP11_MAPPING
{
auto f = thrower->throwLocalException_async();
try
{
f.get();
test(false);
}
catch(const Ice::UnknownLocalException&)
{
}
catch(...)
{
test(false);
}
}
{
auto f = thrower->throwLocalExceptionIdempotent_async();
try
{
f.get();
test(false);
}
catch(const Ice::UnknownLocalException&)
{
}
catch(const Ice::OperationNotExistException&)
{
}
catch(...)
{
test(false);
}
}
#else
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwLocalExceptionPtr callback =
newCallback_Thrower_throwLocalException(cb, &Callback::response, &Callback::exception_LocalException);
thrower->begin_throwLocalException(callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwLocalExceptionIdempotentPtr callback =
newCallback_Thrower_throwLocalExceptionIdempotent(cb, &Callback::response,
&Callback::exception_LocalException);
thrower->begin_throwLocalExceptionIdempotent(callback);
cb->check();
}
#endif
cout << "ok" << endl;
cout << "catching unknown non-Ice exception with new AMI mapping... " << flush;
{
#ifdef ICE_CPP11_MAPPING
auto f = thrower->throwNonIceException_async();
try
{
f.get();
test(false);
}
catch(const Ice::UnknownException&)
{
}
catch(...)
{
test(false);
}
#else
CallbackPtr cb = new Callback;
Callback_Thrower_throwNonIceExceptionPtr callback =
newCallback_Thrower_throwNonIceException(cb, &Callback::response, &Callback::exception_NonIceException);
thrower->begin_throwNonIceException(callback);
cb->check();
#endif
}
cout << "ok" << endl;
return thrower;
}
int
PhoneBookCollocated::run(int argc, char* argv[])
{
Ice::PropertiesPtr properties = communicator()->getProperties();
//
// Create and install a factory for contacts.
//
ContactFactoryPtr contactFactory = new ContactFactory();
communicator()->addObjectFactory(contactFactory, Demo::Contact::ice_staticId());
//
// Create the name index.
//
NameIndexPtr index = new NameIndex("name");
vector<Freeze::IndexPtr> indices;
indices.push_back(index);
//
// Create an object adapter, use the evictor as servant locator.
//
Ice::ObjectAdapterPtr adapter = communicator()->createObjectAdapter("PhoneBook");
//
// Create an evictor for contacts.
//
// When Freeze.Evictor.db.contacts.PopulateEmptyIndices is not 0
// and the Name index is empty, Freeze will traverse the database
// to recreate the index during createXXXEvictor(). Therefore the
// factories for the objects stored in evictor (contacts here)
// must be registered before the call to createXXXEvictor().
//
Freeze::EvictorPtr evictor = Freeze::createBackgroundSaveEvictor(adapter, _envName, "contacts", 0, indices);
adapter->addServantLocator(evictor, "contact");
Ice::Int evictorSize = properties->getPropertyAsInt("EvictorSize");
if(evictorSize > 0)
{
evictor->setSize(evictorSize);
}
//
// Completes the initialization of the contact factory. Note that ContactI/
// ContactFactoryI uses this evictor only when a Contact is destroyed,
// which cannot happen during createXXXEvictor().
//
contactFactory->setEvictor(evictor);
//
// Create the phonebook, and add it to the Object Adapter.
//
PhoneBookIPtr phoneBook = new PhoneBookI(evictor, contactFactory, index);
adapter->add(phoneBook, communicator()->stringToIdentity("phonebook"));
//
// Everything ok, let's go.
//
int runParser(int, char*[], const Ice::CommunicatorPtr&);
int status = runParser(argc, argv, communicator());
adapter->destroy();
return status;
}
int
WarehouseServer::run(int argc, char* argv[])
{
bool useSimpleEvictor = argc > 1 && string(argv[1]) == "simple";
if(useSimpleEvictor)
{
cout << "Using SimpleEvictor" << endl;
}
else
{
cout << "Using Evictor implemented with IceUtil::Cache" << endl;
}
Ice::ObjectAdapterPtr adapter = communicator()->createObjectAdapter("Warehouse");
const string envName = "db";
const string dbName = "items";
{
//
// Open our database, a Freeze dictionary.
//
Freeze::ConnectionPtr connection = Freeze::createConnection(communicator(), envName);
Database db(connection, dbName);
if(db.empty())
{
cout << "Creating new database..." << flush;
//
// Populate database with objectCount entries.
//
ItemInfo info;
connection->beginTransaction();
for(int i = 0; i < objectCount; ++i)
{
ostringstream os;
os << "P/N " << i;
string name = os.str();
info.description = "The description of " + name;
info.unitPrice = i + 0.95f;
info.quantityInStock = i;
info.filler = string(5000, 'x');
db.put(Database::value_type(name, info));
}
connection->currentTransaction()->commit();
cout << "done" << endl;
}
}
CurrentDatabase currentDb(communicator(), envName, dbName);
//
// This servant locator (evictor) will intercept all categories.
//
if(useSimpleEvictor)
{
adapter->addServantLocator(new SimpleEvictor(currentDb, evictorSize), "");
}
else
{
adapter->addServantLocator(new Evictor(currentDb, evictorSize), "");
}
adapter->activate();
communicator()->waitForShutdown();
return EXIT_SUCCESS;
}