int
ClientApp::run(int, char*[])
{
#ifndef _WIN32
//
// Check SIGPIPE is now SIG_IGN
//
struct sigaction action;
sigaction(SIGPIPE, 0, &action);
test(action.sa_handler == SIG_IGN);
#endif
//
// Create OA and servants
//
Ice::ObjectAdapterPtr oa = communicator()->createObjectAdapterWithEndpoints("MyOA", "tcp -h localhost");
Ice::ObjectPtr servant = ICE_MAKE_SHARED(MyObjectI);
InterceptorIPtr interceptor = ICE_MAKE_SHARED(InterceptorI, servant);
AMDInterceptorIPtr amdInterceptor = ICE_MAKE_SHARED(AMDInterceptorI, servant);
Test::MyObjectPrxPtr prx = ICE_UNCHECKED_CAST(Test::MyObjectPrx, oa->addWithUUID(interceptor));
Test::MyObjectPrxPtr prxForAMD = ICE_UNCHECKED_CAST(Test::MyObjectPrx, oa->addWithUUID(amdInterceptor));
cout << "Collocation optimization on" << endl;
int rs = run(prx, interceptor);
if(rs != 0)
{
return rs;
}
cout << "Now with AMD" << endl;
rs = runAmd(prxForAMD, amdInterceptor);
if(rs != 0)
{
return rs;
}
oa->activate(); // Only necessary for non-collocation optimized tests
cout << "Collocation optimization off" << endl;
interceptor->clear();
prx = ICE_UNCHECKED_CAST(Test::MyObjectPrx, prx->ice_collocationOptimized(false));
rs = run(prx, interceptor);
if(rs != 0)
{
return rs;
}
cout << "Now with AMD" << endl;
amdInterceptor->clear();
prxForAMD = ICE_UNCHECKED_CAST(Test::MyObjectPrx, prxForAMD->ice_collocationOptimized(false));
rs = runAmd(prxForAMD, amdInterceptor);
return rs;
}
CHdwIce::CHdwIce( Ice::ObjectAdapterPtr adapter )
: Hdw::CHdw()
{
m_camCtrl = new CCamCtrl();
m_motoCtrl = new CMotoCtrl();
m_cam = new CCamIce( m_camCtrl );
m_moto = new CMotoIce( m_motoCtrl );
m_camPrx = Hdw::CCamPrx::uncheckedCast( adapter->addWithUUID( m_cam ) );
m_motoPrx = Hdw::CMotoPrx::uncheckedCast( adapter->addWithUUID( m_moto ) );
}
int
HelloClient::run(int argc, char* argv[])
{
Ice::StringSeq args = Ice::argsToStringSeq(argc, argv);
args = communicator()->getProperties()->parseCommandLineOptions("Discover", args);
Ice::ObjectAdapterPtr adapter = communicator()->createObjectAdapter("DiscoverReply");
DiscoverReplyIPtr replyI = new DiscoverReplyI;
DiscoverReplyPrx reply = DiscoverReplyPrx::uncheckedCast(adapter->addWithUUID(replyI));
adapter->activate();
DiscoverPrx discover = DiscoverPrx::uncheckedCast(
communicator()->propertyToProxy("Discover.Proxy")->ice_datagram());
discover->lookup(reply);
Ice::ObjectPrx base = replyI->waitReply(IceUtil::Time::seconds(2));
if(!base)
{
cerr << argv[0] << ": no replies" << endl;
return EXIT_FAILURE;
}
HelloPrx hello = HelloPrx::checkedCast(base);
if(!hello)
{
cerr << argv[0] << ": invalid reply" << endl;
return EXIT_FAILURE;
}
hello->sayHello();
return EXIT_SUCCESS;
}
int
Client::run(int, char*[])
{
#ifndef _WIN32
//
// Check SIGPIPE is now SIG_IGN
//
struct sigaction action;
sigaction(SIGPIPE, 0, &action);
test(action.sa_handler == SIG_IGN);
#endif
//
// Create OA and servants
//
Ice::ObjectAdapterPtr oa = communicator()->createObjectAdapterWithEndpoints("MyOA", "tcp -h localhost");
Ice::ObjectPtr servant = new MyObjectI;
InterceptorIPtr interceptor = new InterceptorI(servant);
Test::MyObjectPrx prx = Test::MyObjectPrx::uncheckedCast(oa->addWithUUID(interceptor));
oa->activate();
cout << "Collocation optimization on" << endl;
int rs = run(prx, interceptor);
if(rs == 0)
{
cout << "Collocation optimization off" << endl;
interceptor->clear();
prx = Test::MyObjectPrx::uncheckedCast(prx->ice_collocationOptimized(false));
rs = run(prx, interceptor);
if(rs == 0)
{
cout << "Now with AMD" << endl;
AMDInterceptorIPtr amdInterceptor = new AMDInterceptorI(servant);
prx = Test::MyObjectPrx::uncheckedCast(oa->addWithUUID(amdInterceptor));
prx = Test::MyObjectPrx::uncheckedCast(prx->ice_collocationOptimized(false));
rs = runAmd(prx, amdInterceptor);
}
}
return rs;
}
Glacier2::FilterManager::FilterManager(const InstancePtr& instance, const Glacier2::StringSetIPtr& categories,
const Glacier2::StringSetIPtr& adapters,
const Glacier2::IdentitySetIPtr& identities) :
_categories(categories),
_adapters(adapters),
_identities(identities),
_instance(instance)
{
try
{
Ice::ObjectAdapterPtr adapter = _instance->serverObjectAdapter();
if(adapter)
{
_categoriesPrx = Glacier2::StringSetPrx::uncheckedCast(adapter->addWithUUID(_categories));
_adapterIdsPrx = Glacier2::StringSetPrx::uncheckedCast(adapter->addWithUUID(_adapters));
_identitiesPrx = Glacier2::IdentitySetPrx::uncheckedCast(adapter->addWithUUID(_identities));
}
}
catch(...)
{
destroy();
throw;
}
}
IceGrid::LocatorPrx
RegistryI::setupLocator(const Ice::ObjectAdapterPtr& clientAdapter,
const Ice::ObjectAdapterPtr& registryAdapter,
const Ice::LocatorRegistryPrx& locatorRegistry,
const RegistryPrx& registry,
const QueryPrx& query)
{
LocatorPtr locator = new LocatorI(_communicator, _database, locatorRegistry, registry, query);
Identity locatorId;
locatorId.category = _instanceName;
locatorId.name = "Locator";
clientAdapter->add(locator, locatorId);
locatorId.name = "Locator-" + _replicaName;
clientAdapter->add(locator, locatorId);
return LocatorPrx::uncheckedCast(registryAdapter->addWithUUID(locator));
}
virtual int run(int argc, char* argv[])
{
ClientOrServer::run(argc, argv);
// Register a new object adapter
Ice::ObjectAdapterPtr adapter = communicator()->createObjectAdapter("SonarEventListener.Subscriber");
// Subscribe to the event
IceStorm::QoS qos;
Ice::ObjectPrx subscriber = adapter->addWithUUID(new SonarEventPrinter);
sonarTopic->subscribe(qos, subscriber);
// Start the adapter and keep going until the program is killed
adapter->activate();
shutdownOnInterrupt();
communicator()->waitForShutdown();
sonarTopic->unsubscribe(subscriber);
return EXIT_SUCCESS;
}
int
HelloServer::run(int argc, char* argv[])
{
Ice::StringSeq args = Ice::argsToStringSeq(argc, argv);
args = communicator()->getProperties()->parseCommandLineOptions("Discover", args);
for( auto arg : args) {
std::cout << arg << std::endl;
};
Ice::ObjectAdapterPtr adapter = communicator()->createObjectAdapter("Hello");
Ice::ObjectAdapterPtr discoverAdapter = communicator()->createObjectAdapter("Discover");
Ice::ObjectPrx hello = adapter->addWithUUID(new HelloI);
DiscoverPtr d = new DiscoverI(hello);
discoverAdapter->add(d, communicator()->stringToIdentity("discover"));
discoverAdapter->activate();
adapter->activate();
communicator()->waitForShutdown();
return EXIT_SUCCESS;
}
NodeObserverTopic::NodeObserverTopic(const IceStorm::TopicManagerPrx& topicManager,
const Ice::ObjectAdapterPtr& adapter) :
ObserverTopic(topicManager, "NodeObserver")
{
_publishers = getPublishers<NodeObserverPrx>();
try
{
const_cast<NodeObserverPrx&>(_externalPublisher) = NodeObserverPrx::uncheckedCast(adapter->addWithUUID(this));
}
catch(const Ice::LocalException&)
{
}
}
int
Client::run(int argc, char* argv[])
{
if(argc > 1)
{
cerr << appName() << ": too many arguments" << endl;
return EXIT_FAILURE;
}
Ice::PropertiesPtr properties = communicator()->getProperties();
const string proxyProperty = "Counter.Proxy";
string proxy = properties->getProperty(proxyProperty);
if(proxy.empty())
{
cerr << appName() << ": property `" << proxyProperty << "' not set" << endl;
return EXIT_FAILURE;
}
CounterPrx counter = CounterPrx::uncheckedCast(communicator()->stringToProxy(proxy));
if(!counter)
{
cerr << appName() << ": invalid proxy" << endl;
return EXIT_FAILURE;
}
MTPrinterPtr printer = new MTPrinter();
Ice::ObjectAdapterPtr adapter = communicator()->createObjectAdapterWithEndpoints("Observer", "tcp");
CounterObserverPrx observer =
CounterObserverPrx::uncheckedCast(adapter->addWithUUID(new CounterObserverI(printer)));
adapter->activate();
counter->subscribe(observer);
menu(printer);
char c;
do
{
try
{
printer->print("==> ");
cin >> c;
if(c == 'i')
{
counter->inc(1);
}
else if(c == 'd')
{
counter->inc(-1);
}
else if(c == 'x')
{
// Nothing to do
}
else if(c == '?')
{
menu(printer);
}
else
{
cout << "unknown command `" << c << "'" << endl;
menu(printer);
}
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
}
}
while(cin.good() && c != 'x');
counter->unsubscribe(observer);
return EXIT_SUCCESS;
}
int
InterceptorTestApplication::run(int argc, char* argv[])
{
Ice::InitializationData initData;
initData.properties = Ice::createProperties();
loadConfig(initData.properties);
initData.properties->setProperty("Ice.Warn.Dispatch", "0");
initData.logger = getLogger();
setCommunicator(Ice::initialize(argc, argv, initData));
//
// Create OA and servants
//
Ice::ObjectAdapterPtr oa = communicator()->createObjectAdapterWithEndpoints("MyOA", "tcp -h localhost");
Ice::ObjectPtr servant = new MyObjectI;
InterceptorIPtr interceptor = new InterceptorI(servant);
Test::MyObjectPrx prx = Test::MyObjectPrx::uncheckedCast(oa->addWithUUID(interceptor));
oa->activate();
tprintf("testing simple interceptor... ");
test(interceptor->getLastOperation().empty());
prx->ice_ping();
test(interceptor->getLastOperation() == "ice_ping");
test(interceptor->getLastStatus() == Ice::DispatchOK);
string typeId = prx->ice_id();
test(interceptor->getLastOperation() == "ice_id");
test(interceptor->getLastStatus() == Ice::DispatchOK);
test(prx->ice_isA(typeId));
test(interceptor->getLastOperation() == "ice_isA");
test(interceptor->getLastStatus() == Ice::DispatchOK);
test(prx->add(33, 12) == 45);
test(interceptor->getLastOperation() == "add");
test(interceptor->getLastStatus() == Ice::DispatchOK);
tprintf("ok\n");
tprintf("testing retry... ");
test(prx->addWithRetry(33, 12) == 45);
test(interceptor->getLastOperation() == "addWithRetry");
test(interceptor->getLastStatus() == Ice::DispatchOK);
tprintf("ok\n");
tprintf("testing user exception... ");
try
{
prx->badAdd(33, 12);
test(false);
}
catch(const Test::InvalidInputException&)
{
// expected
}
test(interceptor->getLastOperation() == "badAdd");
test(interceptor->getLastStatus() == Ice::DispatchUserException);
tprintf("ok\n");
tprintf("testing ONE... ");
interceptor->clear();
try
{
prx->notExistAdd(33, 12);
test(false);
}
catch(const Ice::ObjectNotExistException&)
{
// expected
}
test(interceptor->getLastOperation() == "notExistAdd");
tprintf("ok\n");
tprintf("testing system exception... ");
interceptor->clear();
try
{
prx->badSystemAdd(33, 12);
test(false);
}
catch(const Ice::UnknownLocalException&)
{
}
catch(...)
{
test(false);
}
test(interceptor->getLastOperation() == "badSystemAdd");
tprintf("ok\n");
return 0;
}
TimeoutPrxPtr
allTests(const Ice::CommunicatorPtr& communicator)
{
string sref = "timeout:" + getTestEndpoint(communicator, 0);
Ice::ObjectPrxPtr obj = communicator->stringToProxy(sref);
test(obj);
TimeoutPrxPtr timeout = ICE_CHECKED_CAST(TimeoutPrx, obj);
test(timeout);
cout << "testing connect timeout... " << flush;
{
//
// Expect ConnectTimeoutException.
//
TimeoutPrxPtr to = ICE_UNCHECKED_CAST(TimeoutPrx, obj->ice_timeout(100));
timeout->holdAdapter(500);
try
{
to->op();
test(false);
}
catch(const Ice::ConnectTimeoutException&)
{
// Expected.
}
}
{
//
// Expect success.
//
timeout->op(); // Ensure adapter is active.
TimeoutPrxPtr to = ICE_UNCHECKED_CAST(TimeoutPrx, obj->ice_timeout(1000));
timeout->holdAdapter(500);
try
{
to->op();
}
catch(const Ice::ConnectTimeoutException&)
{
test(false);
}
}
cout << "ok" << endl;
// The sequence needs to be large enough to fill the write/recv buffers
ByteSeq seq(2000000);
cout << "testing connection timeout... " << flush;
{
//
// Expect TimeoutException.
//
TimeoutPrxPtr to = ICE_UNCHECKED_CAST(TimeoutPrx, obj->ice_timeout(100));
timeout->holdAdapter(500);
try
{
to->sendData(seq);
test(false);
}
catch(const Ice::TimeoutException&)
{
// Expected.
}
}
{
//
// Expect success.
//
timeout->op(); // Ensure adapter is active.
TimeoutPrxPtr to = ICE_UNCHECKED_CAST(TimeoutPrx, obj->ice_timeout(1000));
timeout->holdAdapter(500);
try
{
ByteSeq seq(1000000);
to->sendData(seq);
}
catch(const Ice::TimeoutException&)
{
test(false);
}
}
cout << "ok" << endl;
cout << "testing invocation timeout... " << flush;
{
Ice::ConnectionPtr connection = obj->ice_getConnection();
TimeoutPrxPtr to = ICE_UNCHECKED_CAST(TimeoutPrx, obj->ice_invocationTimeout(100));
test(connection == to->ice_getConnection());
try
{
to->sleep(750);
test(false);
}
catch(const Ice::InvocationTimeoutException&)
{
}
obj->ice_ping();
to = ICE_CHECKED_CAST(TimeoutPrx, obj->ice_invocationTimeout(500));
test(connection == to->ice_getConnection());
try
{
to->sleep(250);
}
catch(const Ice::InvocationTimeoutException&)
{
test(false);
}
test(connection == to->ice_getConnection());
}
{
//
// Expect InvocationTimeoutException.
//
TimeoutPrxPtr to = ICE_UNCHECKED_CAST(TimeoutPrx, obj->ice_invocationTimeout(100));
#ifdef ICE_CPP11_MAPPING
auto f = to->sleep_async(750);
try
{
f.get();
test(false);
}
catch(const Ice::InvocationTimeoutException&)
{
}
catch(...)
{
test(false);
}
#else
CallbackPtr cb = new Callback();
to->begin_sleep(750, newCallback_Timeout_sleep(cb, &Callback::responseEx, &Callback::exceptionEx));
cb->check();
#endif
obj->ice_ping();
}
{
//
// Expect success.
//
TimeoutPrxPtr to = ICE_UNCHECKED_CAST(TimeoutPrx, obj->ice_invocationTimeout(500));
#ifdef ICE_CPP11_MAPPING
auto f = to->sleep_async(250);
try
{
f.get();
}
catch(...)
{
test(false);
}
#else
CallbackPtr cb = new Callback();
to->begin_sleep(250, newCallback_Timeout_sleep(cb, &Callback::response, &Callback::exception));
cb->check();
#endif
}
{
//
// Backward compatible connection timeouts
//
TimeoutPrxPtr to = ICE_UNCHECKED_CAST(TimeoutPrx, obj->ice_invocationTimeout(-2)->ice_timeout(250));
Ice::ConnectionPtr con;
try
{
con = to->ice_getConnection();
to->sleep(750);
test(false);
}
catch(const Ice::TimeoutException&)
{
try
{
con->getInfo();
test(false);
}
catch(const Ice::TimeoutException&)
{
// Connection got closed as well.
}
}
obj->ice_ping();
try
{
con = to->ice_getConnection();
#ifdef ICE_CPP11_MAPPING
to->sleep_async(750).get();
#else
to->end_sleep(to->begin_sleep(750));
#endif
test(false);
}
catch(const Ice::TimeoutException&)
{
try
{
con->getInfo();
test(false);
}
catch(const Ice::TimeoutException&)
{
// Connection got closed as well.
}
}
obj->ice_ping();
}
cout << "ok" << endl;
cout << "testing close timeout... " << flush;
{
TimeoutPrxPtr to = ICE_CHECKED_CAST(TimeoutPrx, obj->ice_timeout(250));
Ice::ConnectionPtr connection = to->ice_getConnection();
timeout->holdAdapter(600);
connection->close(false);
try
{
connection->getInfo(); // getInfo() doesn't throw in the closing state.
}
catch(const Ice::LocalException&)
{
test(false);
}
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(650));
try
{
connection->getInfo();
test(false);
}
catch(const Ice::CloseConnectionException&)
{
// Expected.
}
timeout->op(); // Ensure adapter is active.
}
cout << "ok" << endl;
cout << "testing timeout overrides... " << flush;
{
//
// Test Ice.Override.Timeout. This property overrides all
// endpoint timeouts.
//
Ice::InitializationData initData;
initData.properties = communicator->getProperties()->clone();
initData.properties->setProperty("Ice.Override.Timeout", "250");
Ice::CommunicatorPtr comm = Ice::initialize(initData);
TimeoutPrxPtr to = ICE_CHECKED_CAST(TimeoutPrx, comm->stringToProxy(sref));
timeout->holdAdapter(700);
try
{
to->sendData(seq);
test(false);
}
catch(const Ice::TimeoutException&)
{
// Expected.
}
//
// Calling ice_timeout() should have no effect.
//
timeout->op(); // Ensure adapter is active.
to = ICE_CHECKED_CAST(TimeoutPrx, to->ice_timeout(1000));
timeout->holdAdapter(500);
try
{
to->sendData(seq);
test(false);
}
catch(const Ice::TimeoutException&)
{
// Expected.
}
comm->destroy();
}
{
//
// Test Ice.Override.ConnectTimeout.
//
Ice::InitializationData initData;
initData.properties = communicator->getProperties()->clone();
initData.properties->setProperty("Ice.Override.ConnectTimeout", "250");
Ice::CommunicatorPtr comm = Ice::initialize(initData);
timeout->holdAdapter(750);
TimeoutPrxPtr to = ICE_UNCHECKED_CAST(TimeoutPrx, comm->stringToProxy(sref));
try
{
to->op();
test(false);
}
catch(const Ice::ConnectTimeoutException&)
{
// Expected.
}
//
// Calling ice_timeout() should have no effect on the connect timeout.
//
timeout->op(); // Ensure adapter is active.
timeout->holdAdapter(750);
to = ICE_UNCHECKED_CAST(TimeoutPrx, to->ice_timeout(1000));
try
{
to->op();
test(false);
}
catch(const Ice::ConnectTimeoutException&)
{
// Expected.
}
//
// Verify that timeout set via ice_timeout() is still used for requests.
//
timeout->op(); // Ensure adapter is active.
to = ICE_UNCHECKED_CAST(TimeoutPrx, to->ice_timeout(250));
to->ice_getConnection(); // Establish connection
timeout->holdAdapter(750);
try
{
to->sendData(seq);
test(false);
}
catch(const Ice::TimeoutException&)
{
// Expected.
}
comm->destroy();
}
{
//
// Test Ice.Override.CloseTimeout.
//
Ice::InitializationData initData;
initData.properties = communicator->getProperties()->clone();
initData.properties->setProperty("Ice.Override.CloseTimeout", "250");
Ice::CommunicatorPtr comm = Ice::initialize(initData);
Ice::ConnectionPtr connection = comm->stringToProxy(sref)->ice_getConnection();
timeout->holdAdapter(500);
IceUtil::Time now = IceUtil::Time::now();
comm->destroy();
test(IceUtil::Time::now() - now < IceUtil::Time::milliSeconds(400));
}
cout << "ok" << endl;
cout << "testing invocation timeouts with collocated calls... " << flush;
{
communicator->getProperties()->setProperty("TimeoutCollocated.AdapterId", "timeoutAdapter");
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TimeoutCollocated");
adapter->activate();
TimeoutPrxPtr timeout = ICE_UNCHECKED_CAST(TimeoutPrx, adapter->addWithUUID(ICE_MAKE_SHARED(TimeoutI)));
timeout = timeout->ice_invocationTimeout(100);
try
{
timeout->sleep(300);
test(false);
}
catch(const Ice::InvocationTimeoutException&)
{
}
try
{
#ifdef ICE_CPP11_MAPPING
timeout->sleep_async(300).get();
#else
timeout->end_sleep(timeout->begin_sleep(300));
#endif
test(false);
}
catch(const Ice::InvocationTimeoutException&)
{
}
TimeoutPrxPtr batchTimeout = timeout->ice_batchOneway();
batchTimeout->ice_ping();
batchTimeout->ice_ping();
batchTimeout->ice_ping();
// Keep the server thread pool busy.
#ifdef ICE_CPP11_MAPPING
timeout->ice_invocationTimeout(-1)->sleep_async(300);
#else
timeout->ice_invocationTimeout(-1)->begin_sleep(300);
#endif
try
{
batchTimeout->ice_flushBatchRequests();
test(false);
}
catch(const Ice::InvocationTimeoutException&)
{
}
batchTimeout->ice_ping();
batchTimeout->ice_ping();
batchTimeout->ice_ping();
// Keep the server thread pool busy.
#ifdef ICE_CPP11_MAPPING
timeout->ice_invocationTimeout(-1)->sleep_async(300);
#else
timeout->ice_invocationTimeout(-1)->begin_sleep(300);
#endif
try
{
#ifdef ICE_CPP11_MAPPING
batchTimeout->ice_flushBatchRequests_async().get();
#else
batchTimeout->end_ice_flushBatchRequests(batchTimeout->begin_ice_flushBatchRequests());
#endif
test(false);
}
catch(const Ice::InvocationTimeoutException&)
{
}
adapter->destroy();
}
cout << "ok" << endl;
return timeout;
}
TestIntfPrxPtr
allTests(const Ice::CommunicatorPtr& communicator)
{
Ice::ObjectPrxPtr obj = communicator->stringToProxy("Test:" + getTestEndpoint(communicator, 0));
TestIntfPrxPtr test = ICE_CHECKED_CAST(TestIntfPrx, obj);
cout << "base... " << flush;
{
try
{
test->baseAsBase();
test(false);
}
catch(const Base& b)
{
test(b.b == "Base.b");
test(b.ice_id() == "::Test::Base");
}
catch(...)
{
test(false);
}
}
cout << "ok" << endl;
cout << "base (AMI)... " << flush;
{
#ifdef ICE_CPP11_MAPPING
auto result = test->baseAsBase_async();
try
{
result.get();
test(false);
}
catch(const Base& b)
{
test(b.b == "Base.b");
test(b.ice_id() == "::Test::Base");
}
catch(...)
{
test(false);
}
#else
CallbackPtr cb = new Callback;
test->begin_baseAsBase(
newCallback_TestIntf_baseAsBase(cb, &Callback::response, &Callback::exception_baseAsBase));
cb->check();
#endif
}
cout << "ok" << endl;
cout << "slicing of unknown derived... " << flush;
{
try
{
test->unknownDerivedAsBase();
test(false);
}
catch(const Base& b)
{
test(b.b == "UnknownDerived.b");
test(b.ice_id() == "::Test::Base");
}
catch(...)
{
test(false);
}
}
cout << "ok" << endl;
cout << "slicing of unknown derived (AMI)... " << flush;
{
#ifdef ICE_CPP11_MAPPING
auto result = test->unknownDerivedAsBase_async();
try
{
result.get();
test(false);
}
catch(const Base& b)
{
test(b.b == "UnknownDerived.b");
test(b.ice_id() == "::Test::Base");
}
catch(...)
{
test(false);
}
#else
CallbackPtr cb = new Callback;
test->begin_unknownDerivedAsBase(
newCallback_TestIntf_unknownDerivedAsBase(cb, &Callback::response,
&Callback::exception_unknownDerivedAsBase));
cb->check();
#endif
}
cout << "ok" << endl;
cout << "non-slicing of known derived as base... " << flush;
{
try
{
test->knownDerivedAsBase();
test(false);
}
catch(const KnownDerived& k)
{
test(k.b == "KnownDerived.b");
test(k.kd == "KnownDerived.kd");
test(k.ice_id() == "::Test::KnownDerived");
}
catch(...)
{
test(false);
}
}
cout << "ok" << endl;
cout << "non-slicing of known derived as base (AMI)... " << flush;
{
#ifdef ICE_CPP11_MAPPING
auto result = test->knownDerivedAsBase_async();
try
{
result.get();
test(false);
}
catch(const KnownDerived& k)
{
test(k.b == "KnownDerived.b");
test(k.kd == "KnownDerived.kd");
test(k.ice_id() == "::Test::KnownDerived");
}
catch(...)
{
test(false);
}
#else
CallbackPtr cb = new Callback;
test->begin_knownDerivedAsBase(
newCallback_TestIntf_knownDerivedAsBase(cb, &Callback::response, &Callback::exception_knownDerivedAsBase));
cb->check();
#endif
}
cout << "ok" << endl;
cout << "non-slicing of known derived as derived... " << flush;
{
try
{
test->knownDerivedAsKnownDerived();
test(false);
}
catch(const KnownDerived& k)
{
test(k.b == "KnownDerived.b");
test(k.kd == "KnownDerived.kd");
test(k.ice_id() == "::Test::KnownDerived");
}
catch(...)
{
test(false);
}
}
cout << "ok" << endl;
cout << "non-slicing of known derived as derived (AMI)... " << flush;
{
#ifdef ICE_CPP11_MAPPING
auto result = test->knownDerivedAsKnownDerived_async();
try
{
result.get();
}
catch(const KnownDerived& k)
{
test(k.b == "KnownDerived.b");
test(k.kd == "KnownDerived.kd");
test(k.ice_id() == "::Test::KnownDerived");
}
catch(...)
{
test(false);
}
#else
CallbackPtr cb = new Callback;
test->begin_knownDerivedAsKnownDerived(
newCallback_TestIntf_knownDerivedAsKnownDerived(cb, &Callback::response,
&Callback::exception_knownDerivedAsKnownDerived));
cb->check();
#endif
}
cout << "ok" << endl;
cout << "slicing of unknown intermediate as base... " << flush;
{
try
{
test->unknownIntermediateAsBase();
test(false);
}
catch(const Base& b)
{
test(b.b == "UnknownIntermediate.b");
test(b.ice_id() == "::Test::Base");
}
catch(...)
{
test(false);
}
}
cout << "ok" << endl;
cout << "slicing of unknown intermediate as base (AMI)... " << flush;
{
#ifdef ICE_CPP11_MAPPING
auto result = test->unknownIntermediateAsBase_async();
try
{
result.get();
test(false);
}
catch(const Base& b)
{
test(b.b == "UnknownIntermediate.b");
test(b.ice_id() == "::Test::Base");
}
catch(...)
{
test(false);
}
#else
CallbackPtr cb = new Callback;
test->begin_unknownIntermediateAsBase(
newCallback_TestIntf_unknownIntermediateAsBase(cb, &Callback::response,
&Callback::exception_unknownIntermediateAsBase));
cb->check();
#endif
}
cout << "ok" << endl;
cout << "slicing of known intermediate as base... " << flush;
{
try
{
test->knownIntermediateAsBase();
test(false);
}
catch(const KnownIntermediate& ki)
{
test(ki.b == "KnownIntermediate.b");
test(ki.ki == "KnownIntermediate.ki");
test(ki.ice_id() == "::Test::KnownIntermediate");
}
catch(...)
{
test(false);
}
}
cout << "ok" << endl;
cout << "slicing of known intermediate as base (AMI)... " << flush;
{
#ifdef ICE_CPP11_MAPPING
auto result = test->knownIntermediateAsBase_async();
try
{
result.get();
test(false);
}
catch(const KnownIntermediate& ki)
{
test(ki.b == "KnownIntermediate.b");
test(ki.ki == "KnownIntermediate.ki");
test(ki.ice_id() == "::Test::KnownIntermediate");
}
catch(...)
{
test(false);
}
#else
CallbackPtr cb = new Callback;
test->begin_knownIntermediateAsBase(
newCallback_TestIntf_knownIntermediateAsBase(cb, &Callback::response,
&Callback::exception_knownIntermediateAsBase));
cb->check();
#endif
}
cout << "ok" << endl;
cout << "slicing of known most derived as base... " << flush;
{
try
{
test->knownMostDerivedAsBase();
test(false);
}
catch(const KnownMostDerived& kmd)
{
test(kmd.b == "KnownMostDerived.b");
test(kmd.ki == "KnownMostDerived.ki");
test(kmd.kmd == "KnownMostDerived.kmd");
test(kmd.ice_id() == "::Test::KnownMostDerived");
}
catch(...)
{
test(false);
}
}
cout << "ok" << endl;
cout << "slicing of known most derived as base (AMI)... " << flush;
{
#ifdef ICE_CPP11_MAPPING
auto result = test->knownMostDerivedAsBase_async();
try
{
result.get();
test(false);
}
catch(const KnownMostDerived& kmd)
{
test(kmd.b == "KnownMostDerived.b");
test(kmd.ki == "KnownMostDerived.ki");
test(kmd.kmd == "KnownMostDerived.kmd");
test(kmd.ice_id() == "::Test::KnownMostDerived");
}
catch(...)
{
test(false);
}
#else
CallbackPtr cb = new Callback;
test->begin_knownMostDerivedAsBase(
newCallback_TestIntf_knownMostDerivedAsBase(cb, &Callback::response,
&Callback::exception_knownMostDerivedAsBase));
cb->check();
#endif
}
cout << "ok" << endl;
cout << "non-slicing of known intermediate as intermediate... " << flush;
{
try
{
test->knownIntermediateAsKnownIntermediate();
test(false);
}
catch(const KnownIntermediate& ki)
{
test(ki.b == "KnownIntermediate.b");
test(ki.ki == "KnownIntermediate.ki");
test(ki.ice_id() == "::Test::KnownIntermediate");
}
catch(...)
{
test(false);
}
}
cout << "ok" << endl;
cout << "non-slicing of known intermediate as intermediate (AMI)... " << flush;
{
#ifdef ICE_CPP11_MAPPING
auto result = test->knownIntermediateAsKnownIntermediate_async();
try
{
result.get();
test(false);
}
catch(const KnownIntermediate& ki)
{
test(ki.b == "KnownIntermediate.b");
test(ki.ki == "KnownIntermediate.ki");
test(ki.ice_id() == "::Test::KnownIntermediate");
}
catch(...)
{
test(false);
}
#else
CallbackPtr cb = new Callback;
test->begin_knownIntermediateAsKnownIntermediate(
newCallback_TestIntf_knownIntermediateAsKnownIntermediate(cb, &Callback::response,
&Callback::exception_knownIntermediateAsKnownIntermediate));
cb->check();
#endif
}
cout << "ok" << endl;
cout << "non-slicing of known most derived exception as intermediate... " << flush;
{
try
{
test->knownMostDerivedAsKnownIntermediate();
test(false);
}
catch(const KnownMostDerived& kmd)
{
test(kmd.b == "KnownMostDerived.b");
test(kmd.ki == "KnownMostDerived.ki");
test(kmd.kmd == "KnownMostDerived.kmd");
test(kmd.ice_id() == "::Test::KnownMostDerived");
}
catch(...)
{
test(false);
}
}
cout << "ok" << endl;
cout << "non-slicing of known most derived as intermediate (AMI)... " << flush;
{
#ifdef ICE_CPP11_MAPPING
auto result = test->knownMostDerivedAsKnownIntermediate_async();
try
{
result.get();
test(false);
}
catch(const KnownMostDerived& kmd)
{
test(kmd.b == "KnownMostDerived.b");
test(kmd.ki == "KnownMostDerived.ki");
test(kmd.kmd == "KnownMostDerived.kmd");
test(kmd.ice_id() == "::Test::KnownMostDerived");
}
catch(...)
{
test(false);
}
#else
CallbackPtr cb = new Callback;
test->begin_knownMostDerivedAsKnownIntermediate(
newCallback_TestIntf_knownMostDerivedAsKnownIntermediate(cb, &Callback::response,
&Callback::exception_knownMostDerivedAsKnownIntermediate));
cb->check();
#endif
}
cout << "ok" << endl;
cout << "non-slicing of known most derived as most derived... " << flush;
{
try
{
test->knownMostDerivedAsKnownMostDerived();
test(false);
}
catch(const KnownMostDerived& kmd)
{
test(kmd.b == "KnownMostDerived.b");
test(kmd.ki == "KnownMostDerived.ki");
test(kmd.kmd == "KnownMostDerived.kmd");
test(kmd.ice_id() == "::Test::KnownMostDerived");
}
catch(...)
{
test(false);
}
}
cout << "ok" << endl;
cout << "non-slicing of known most derived as most derived (AMI)... " << flush;
{
#ifdef ICE_CPP11_MAPPING
auto result = test->knownMostDerivedAsKnownMostDerived_async();
try
{
result.get();
test(false);
}
catch(const KnownMostDerived& kmd)
{
test(kmd.b == "KnownMostDerived.b");
test(kmd.ki == "KnownMostDerived.ki");
test(kmd.kmd == "KnownMostDerived.kmd");
test(kmd.ice_id() == "::Test::KnownMostDerived");
}
catch(...)
{
test(false);
}
#else
CallbackPtr cb = new Callback;
test->begin_knownMostDerivedAsKnownMostDerived(
newCallback_TestIntf_knownMostDerivedAsKnownMostDerived(cb, &Callback::response,
&Callback::exception_knownMostDerivedAsKnownMostDerived));
cb->check();
#endif
}
cout << "ok" << endl;
cout << "slicing of unknown most derived, known intermediate as base... " << flush;
{
try
{
test->unknownMostDerived1AsBase();
test(false);
}
catch(const KnownIntermediate& ki)
{
test(ki.b == "UnknownMostDerived1.b");
test(ki.ki == "UnknownMostDerived1.ki");
test(ki.ice_id() == "::Test::KnownIntermediate");
}
catch(...)
{
test(false);
}
}
cout << "ok" << endl;
cout << "slicing of unknown most derived, known intermediate as base (AMI)... " << flush;
{
#ifdef ICE_CPP11_MAPPING
auto result = test->unknownMostDerived1AsBase_async();
try
{
result.get();
test(false);
}
catch(const KnownIntermediate& ki)
{
test(ki.b == "UnknownMostDerived1.b");
test(ki.ki == "UnknownMostDerived1.ki");
test(ki.ice_id() == "::Test::KnownIntermediate");
}
catch(...)
{
test(false);
}
#else
CallbackPtr cb = new Callback;
test->begin_unknownMostDerived1AsBase(
newCallback_TestIntf_unknownMostDerived1AsBase(cb, &Callback::response,
&Callback::exception_unknownMostDerived1AsBase));
cb->check();
#endif
}
cout << "ok" << endl;
cout << "slicing of unknown most derived, known intermediate as intermediate... " << flush;
{
try
{
test->unknownMostDerived1AsKnownIntermediate();
test(false);
}
catch(const KnownIntermediate& ki)
{
test(ki.b == "UnknownMostDerived1.b");
test(ki.ki == "UnknownMostDerived1.ki");
test(ki.ice_id() == "::Test::KnownIntermediate");
}
catch(...)
{
test(false);
}
}
cout << "ok" << endl;
cout << "slicing of unknown most derived, known intermediate as intermediate (AMI)... " << flush;
{
#ifdef ICE_CPP11_MAPPING
auto result = test->unknownMostDerived1AsKnownIntermediate_async();
try
{
result.get();
test(false);
}
catch(const KnownIntermediate& ki)
{
test(ki.b == "UnknownMostDerived1.b");
test(ki.ki == "UnknownMostDerived1.ki");
test(ki.ice_id() == "::Test::KnownIntermediate");
}
catch(...)
{
test(false);
}
#else
CallbackPtr cb = new Callback;
test->begin_unknownMostDerived1AsKnownIntermediate(
newCallback_TestIntf_unknownMostDerived1AsKnownIntermediate(cb, &Callback::response,
&Callback::exception_unknownMostDerived1AsKnownIntermediate));
cb->check();
#endif
}
cout << "ok" << endl;
cout << "slicing of unknown most derived, unknown intermediate as base... " << flush;
{
try
{
test->unknownMostDerived2AsBase();
test(false);
}
catch(const Base& b)
{
test(b.b == "UnknownMostDerived2.b");
test(b.ice_id() == "::Test::Base");
}
catch(...)
{
test(false);
}
}
cout << "ok" << endl;
cout << "slicing of unknown most derived, unknown intermediate as base (AMI)... " << flush;
{
#ifdef ICE_CPP11_MAPPING
auto result = test->unknownMostDerived2AsBase_async();
try
{
result.get();
test(false);
}
catch(const Base& b)
{
test(b.b == "UnknownMostDerived2.b");
test(b.ice_id() == "::Test::Base");
}
catch(...)
{
test(false);
}
#else
CallbackPtr cb = new Callback;
test->begin_unknownMostDerived2AsBase(
newCallback_TestIntf_unknownMostDerived2AsBase(cb, &Callback::response,
&Callback::exception_unknownMostDerived2AsBase));
cb->check();
#endif
}
cout << "ok" << endl;
cout << "unknown most derived in compact format... " << flush;
{
try
{
test->unknownMostDerived2AsBaseCompact();
test(false);
}
catch(const Base&)
{
//
// For the 1.0 encoding, the unknown exception is sliced to Base.
//
test(test->ice_getEncodingVersion() == Ice::Encoding_1_0);
}
catch(const Ice::UnknownUserException&)
{
//
// An UnknownUserException is raised for the compact format because the
// most-derived type is unknown and the exception cannot be sliced.
//
test(test->ice_getEncodingVersion() != Ice::Encoding_1_0);
}
catch(const Ice::OperationNotExistException&)
{
}
catch(...)
{
test(false);
}
}
cout << "ok" << endl;
cout << "preserved exceptions... " << flush;
string localOAEndpoint;
{
ostringstream ostr;
if(communicator->getProperties()->getProperty("Ice.Default.Protocol") == "bt")
{
ostr << "default -a *";
}
else
{
ostr << "default -h *";
}
localOAEndpoint = ostr.str();
}
{
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapterWithEndpoints("Relay", localOAEndpoint);
RelayPrxPtr relay = ICE_UNCHECKED_CAST(RelayPrx, adapter->addWithUUID(ICE_MAKE_SHARED(RelayI)));
adapter->activate();
try
{
test->relayKnownPreservedAsBase(relay);
test(false);
}
catch(const KnownPreservedDerived& ex)
{
test(ex.b == "base");
test(ex.kp == "preserved");
test(ex.kpd == "derived");
}
catch(const Ice::OperationNotExistException&)
{
}
catch(const Ice::LocalException& ex)
{
cout << endl << "** OOPS" << endl << ex << endl;
test(false);
}
catch(...)
{
test(false);
}
try
{
test->relayKnownPreservedAsKnownPreserved(relay);
test(false);
}
catch(const KnownPreservedDerived& ex)
{
test(ex.b == "base");
test(ex.kp == "preserved");
test(ex.kpd == "derived");
}
catch(const Ice::OperationNotExistException&)
{
}
catch(...)
{
test(false);
}
try
{
test->relayUnknownPreservedAsBase(relay);
test(false);
}
catch(const Preserved2& ex)
{
test(ex.b == "base");
test(ex.kp == "preserved");
test(ex.kpd == "derived");
test(ex.p1->ice_id() == PreservedClass::ice_staticId());
PreservedClassPtr pc = ICE_DYNAMIC_CAST(PreservedClass, ex.p1);
test(pc->bc == "bc");
test(pc->pc == "pc");
test(ex.p2 == ex.p1);
}
catch(const Ice::OperationNotExistException&)
{
}
catch(const KnownPreservedDerived& ex)
{
//
// For the 1.0 encoding, the unknown exception is sliced to KnownPreserved.
//
test(test->ice_getEncodingVersion() == Ice::Encoding_1_0);
test(ex.b == "base");
test(ex.kp == "preserved");
test(ex.kpd == "derived");
}
catch(...)
{
test(false);
}
try
{
test->relayUnknownPreservedAsKnownPreserved(relay);
test(false);
}
catch(const Ice::OperationNotExistException&)
{
}
catch(const Preserved2& ex)
{
test(ex.b == "base");
test(ex.kp == "preserved");
test(ex.kpd == "derived");
test(ex.p1->ice_id() == PreservedClass::ice_staticId());
PreservedClassPtr pc = ICE_DYNAMIC_CAST(PreservedClass, ex.p1);
test(pc->bc == "bc");
test(pc->pc == "pc");
test(ex.p2 == ex.p1);
}
catch(const KnownPreservedDerived& ex)
{
//
// For the 1.0 encoding, the unknown exception is sliced to KnownPreserved.
//
test(test->ice_getEncodingVersion() == Ice::Encoding_1_0);
test(ex.b == "base");
test(ex.kp == "preserved");
test(ex.kpd == "derived");
}
catch(...)
{
test(false);
}
adapter->destroy();
}
cout << "ok" << endl;
return test;
}
void
allTests(const Ice::CommunicatorPtr& communicator)
{
{
cout << "Testing Glacier2 stub... " << flush;
char** argv = 0;
int argc = 0;
SessionHelperClient client;
client.run(argc, argv);
cout << "ok" << endl;
}
{
cout << "Testing IceStorm stub... " << flush;
IceStorm::TopicManagerPrxPtr manager =
ICE_UNCHECKED_CAST(IceStorm::TopicManagerPrx, communicator->stringToProxy("test:default -p 12010"));
IceStorm::QoS qos;
IceStorm::TopicPrxPtr topic;
string topicName = "time";
try
{
topic = manager->retrieve(topicName);
test(false);
}
catch(const IceStorm::NoSuchTopic&)
{
test(false);
}
catch(const Ice::LocalException&)
{
}
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapterWithEndpoints("subscriber" ,"tcp");
Ice::ObjectPrxPtr subscriber = adapter->addWithUUID(ICE_MAKE_SHARED(ClockI));
adapter->activate();
#ifdef ICE_CPP11_MAPPING
assert(!topic);
#else
try
{
topic->subscribeAndGetPublisher(qos, subscriber);
test(false);
}
catch(const IceStorm::AlreadySubscribed&)
{
test(false);
}
catch(const IceUtil::NullHandleException&)
{
}
#endif
cout << "ok" << endl;
}
{
cout << "Testing IceGrid stub... " << flush;
Ice::ObjectPrxPtr base = communicator->stringToProxy("test:default -p 12010");
IceGrid::RegistryPrxPtr registry = ICE_UNCHECKED_CAST(IceGrid::RegistryPrx, base);
IceGrid::AdminSessionPrxPtr session;
IceGrid::AdminPrxPtr admin;
try
{
session = registry->createAdminSession("username", "password");
test(false);
}
catch(const IceGrid::PermissionDeniedException&)
{
test(false);
}
catch(const Ice::LocalException&)
{
}
#ifdef ICE_CPP11_MAPPING
assert(!admin);
#else
try
{
admin = session->getAdmin();
test(false);
}
catch(const IceUtil::NullHandleException&)
{
}
#endif
cout << "ok" << endl;
}
}
void
allTests(const CommunicatorPtr& communicator)
{
communicator->getProperties()->setProperty("ReplyAdapter.Endpoints", "udp -p 12030");
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("ReplyAdapter");
PingReplyIPtr replyI = new PingReplyI;
PingReplyPrx reply = PingReplyPrx::uncheckedCast(adapter->addWithUUID(replyI))->ice_datagram();
adapter->activate();
cout << "testing udp... " << flush;
ObjectPrx base = communicator->stringToProxy("test -d:udp -p 12010");
TestIntfPrx obj = TestIntfPrx::uncheckedCast(base);
int nRetry = 5;
bool ret;
while(nRetry-- > 0)
{
replyI->reset();
obj->ping(reply);
obj->ping(reply);
obj->ping(reply);
ret = replyI->waitReply(3, IceUtil::Time::seconds(2));
if(ret)
{
break; // Success
}
// If the 3 datagrams were not received within the 2 seconds, we try again to
// receive 3 new datagrams using a new object. We give up after 5 retries.
replyI = new PingReplyI;
reply = PingReplyPrx::uncheckedCast(adapter->addWithUUID(replyI))->ice_datagram();
}
test(ret);
if(communicator->getProperties()->getPropertyAsInt("Ice.Override.Compress") == 0)
{
//
// Only run this test if compression is disabled, the test expect fixed message size
// to be sent over the wire.
//
Test::ByteSeq seq;
try
{
seq.resize(1024);
while(true)
{
seq.resize(seq.size() * 2 + 10);
replyI->reset();
obj->sendByteSeq(seq, reply);
replyI->waitReply(1, IceUtil::Time::seconds(10));
}
}
catch(const DatagramLimitException&)
{
test(seq.size() > 16384);
}
obj->ice_getConnection()->close(false);
communicator->getProperties()->setProperty("Ice.UDP.SndSize", "64000");
seq.resize(50000);
try
{
replyI->reset();
obj->sendByteSeq(seq, reply);
test(!replyI->waitReply(1, IceUtil::Time::milliSeconds(500)));
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
}
cout << "ok" << endl;
string endpoint;
if(communicator->getProperties()->getProperty("Ice.IPv6") == "1")
{
#ifdef __APPLE__
endpoint = "udp -h \"ff15::1:1\" -p 12020 --interface \"::1\"";
#else
endpoint = "udp -h \"ff15::1:1\" -p 12020";
#endif
}
else
{
endpoint = "udp -h 239.255.1.1 -p 12020";
}
base = communicator->stringToProxy("test -d:" + endpoint);
TestIntfPrx objMcast = TestIntfPrx::uncheckedCast(base);
#if !defined(ICE_OS_WINRT) && (!defined(__APPLE__) || (defined(__APPLE__) && !TARGET_OS_IPHONE))
cout << "testing udp multicast... " << flush;
nRetry = 5;
while(nRetry-- > 0)
{
replyI->reset();
objMcast->ping(reply);
ret = replyI->waitReply(5, IceUtil::Time::seconds(2));
if(ret)
{
break; // Success
}
replyI = new PingReplyI;
reply = PingReplyPrx::uncheckedCast(adapter->addWithUUID(replyI))->ice_datagram();
}
if(!ret)
{
cout << "failed (is a firewall enabled?)" << endl;
}
else
{
cout << "ok" << endl;
}
#endif
cout << "testing udp bi-dir connection... " << flush;
obj->ice_getConnection()->setAdapter(adapter);
objMcast->ice_getConnection()->setAdapter(adapter);
nRetry = 5;
while(nRetry-- > 0)
{
replyI->reset();
obj->pingBiDir(reply->ice_getIdentity());
obj->pingBiDir(reply->ice_getIdentity());
obj->pingBiDir(reply->ice_getIdentity());
ret = replyI->waitReply(3, IceUtil::Time::seconds(2));
if(ret)
{
break; // Success
}
// If the 3 datagrams were not received within the 2 seconds, we try again to
// receive 3 new datagrams using a new object. We give up after 5 retries.
replyI = new PingReplyI;
reply = PingReplyPrx::uncheckedCast(adapter->addWithUUID(replyI))->ice_datagram();
}
test(ret);
cout << "ok" << endl;
//
// Sending the replies back on the multicast UDP connection doesn't work for most
// platform (it works for OS X Leopard but not Snow Leopard, doesn't work on SLES,
// Windows...). For Windows, see UdpTransceiver constructor for the details. So
// we don't run this test.
//
// cout << "testing udp bi-dir connection... " << flush;
// nRetry = 5;
// while(nRetry-- > 0)
// {
// replyI->reset();
// objMcast->pingBiDir(reply->ice_getIdentity());
// ret = replyI->waitReply(5, IceUtil::Time::seconds(2));
// if(ret)
// {
// break; // Success
// }
// replyI = new PingReplyI;
// reply = PingReplyPrx::uncheckedCast(adapter->addWithUUID(replyI))->ice_datagram();
// }
// if(!ret)
// {
// cout << "failed (is a firewall enabled?)" << endl;
// }
// else
// {
// cout << "ok" << endl;
// }
}
void
allTests(const Ice::CommunicatorPtr& communicator)
{
{
cout << "Testing Glacier2 stub... " << flush;
char** argv = 0;
int argc = 0;
SessionHelperClient client;
client.run(argc, argv);
cout << "ok" << endl;
}
{
cout << "Testing IceStorm stub... " << flush;
IceStorm::TopicManagerPrx manager =
IceStorm::TopicManagerPrx::uncheckedCast(communicator->stringToProxy("test:default -p 12010"));
IceStorm::QoS qos;
IceStorm::TopicPrx topic;
string topicName = "time";
try
{
topic = manager->retrieve(topicName);
test(false);
}
catch(const IceStorm::NoSuchTopic&)
{
test(false);
}
catch(const Ice::LocalException&)
{
}
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapterWithEndpoints("subscriber" ,"tcp");
Ice::ObjectPrx subscriber = adapter->addWithUUID(new ClockI);
adapter->activate();
try
{
topic->subscribeAndGetPublisher(qos, subscriber);
test(false);
}
catch(const IceStorm::AlreadySubscribed&)
{
test(false);
}
catch(const IceUtil::NullHandleException&)
{
}
cout << "ok" << endl;
}
{
cout << "Testing IceGrid stub... " << flush;
Ice::ObjectPrx base = communicator->stringToProxy("test:default -p 12010");
IceGrid::RegistryPrx registry = IceGrid::RegistryPrx::uncheckedCast(base);
IceGrid::AdminSessionPrx session;
IceGrid::AdminPrx admin;
try
{
session = registry->createAdminSession("username", "password");
test(false);
}
catch(const IceGrid::PermissionDeniedException&)
{
test(false);
}
catch(const Ice::LocalException&)
{
}
try
{
admin = session->getAdmin();
test(false);
}
catch(const IceUtil::NullHandleException&)
{
}
cout << "ok" << endl;
}
}