void
Server::run(int argc, char** argv)
{
#ifdef ICE_STATIC_LIBS
Ice::registerIceDiscovery();
#endif
Ice::CommunicatorHolder communicator = initialize(argc, argv);
Ice::PropertiesPtr properties = communicator->getProperties();
int num = argc == 2 ? atoi(argv[1]) : 0;
properties->setProperty("ControlAdapter.Endpoints", getTestEndpoint(num));
{
ostringstream os;
os << "control" << num;
properties->setProperty("ControlAdapter.AdapterId", os.str());
}
properties->setProperty("ControlAdapter.ThreadPool.Size", "1");
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("ControlAdapter");
{
ostringstream os;
os << "controller" << num;
adapter->add(ICE_MAKE_SHARED(ControllerI), Ice::stringToIdentity(os.str()));
}
adapter->activate();
serverReady();
communicator->waitForShutdown();
}
void
Server::run(int argc, char** argv)
{
Ice::CommunicatorHolder communicator = initialize(argc, argv);
communicator->getProperties()->setProperty("TestAdapter.Endpoints", getTestEndpoint());
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter");
adapter->add(ICE_MAKE_SHARED(TestIntfI), Ice::stringToIdentity("test"));
adapter->activate();
serverReady();
communicator->waitForShutdown();
}
void
Server::run(int argc, char** argv)
{
#ifdef ICE_STATIC_LIBS
Ice::registerPluginFactory("Test", createTestTransport, false);
#endif
Ice::PropertiesPtr properties = createTestProperties(argc, argv);
//
// This test kills connections, so we don't want warnings.
//
properties->setProperty("Ice.Warn.Connections", "0");
properties->setProperty("Ice.MessageSizeMax", "50000");
//
// This test relies on filling the TCP send/recv buffer, so
// we rely on a fixed value for these buffers.
//
properties->setProperty("Ice.TCP.RcvSize", "50000");
//
// Setup the test transport plug-in.
//
properties->setProperty("Ice.Plugin.Test", "TestTransport:createTestTransport");
string defaultProtocol = properties->getPropertyWithDefault("Ice.Default.Protocol", "tcp");
properties->setProperty("Ice.Default.Protocol", "test-" + defaultProtocol);
Ice::CommunicatorHolder communicator = initialize(argc, argv, properties);
communicator->getProperties()->setProperty("TestAdapter.Endpoints", getTestEndpoint(0));
communicator->getProperties()->setProperty("ControllerAdapter.Endpoints", getTestEndpoint(1, "tcp"));
communicator->getProperties()->setProperty("ControllerAdapter.ThreadPool.Size", "1");
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter");
Ice::ObjectAdapterPtr adapter2 = communicator->createObjectAdapter("ControllerAdapter");
#ifdef ICE_CPP11_MAPPING
shared_ptr<PluginI> plugin = dynamic_pointer_cast<PluginI>(communicator->getPluginManager()->getPlugin("Test"));
#else
PluginI* plugin = dynamic_cast<PluginI*>(communicator->getPluginManager()->getPlugin("Test").get());
#endif
assert(plugin);
ConfigurationPtr configuration = plugin->getConfiguration();
BackgroundControllerIPtr backgroundController = ICE_MAKE_SHARED(BackgroundControllerI, adapter, configuration);
adapter->add(ICE_MAKE_SHARED(BackgroundI, backgroundController), Ice::stringToIdentity("background"));
adapter->add(ICE_MAKE_SHARED(LocatorI, backgroundController), Ice::stringToIdentity("locator"));
adapter->add(ICE_MAKE_SHARED(RouterI, backgroundController), Ice::stringToIdentity("router"));
adapter->activate();
adapter2->add(backgroundController, Ice::stringToIdentity("backgroundController"));
adapter2->activate();
communicator->waitForShutdown();
}
void
ServerAMD::run(int argc, char** argv)
{
Ice::PropertiesPtr properties = createTestProperties(argc, argv);
#ifndef ICE_CPP11_MAPPING
properties->setProperty("Ice.CollectObjects", "1");
#endif
Ice::CommunicatorHolder communicator = initialize(argc, argv, properties);
communicator->getProperties()->setProperty("TestAdapter.Endpoints", getTestEndpoint());
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter");
adapter->add(ICE_MAKE_SHARED(InitialI), Ice::stringToIdentity("initial"));
adapter->activate();
serverReady();
communicator->waitForShutdown();
}
void
ServerAMD::run(int argc, char** argv)
{
Ice::PropertiesPtr properties = createTestProperties(argc, argv);
properties->setProperty("Ice.Warn.Connections", "0");
properties->setProperty("Ice.Warn.Dispatch", "0");
Ice::CommunicatorHolder communicator = initialize(argc, argv, properties);
communicator->getProperties()->setProperty("TestAdapter.Endpoints", getTestEndpoint());
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter");
adapter->add(ICE_MAKE_SHARED(MyDerivedClassI), Ice::stringToIdentity("test"));
adapter->activate();
serverReady();
communicator->waitForShutdown();
}
void
Server::run(int argc, char** argv)
{
setProcessStringConverter(ICE_MAKE_SHARED(Test::StringConverterI));
setProcessWstringConverter(ICE_MAKE_SHARED(Test::WstringConverterI));
Ice::CommunicatorHolder communicator = initialize(argc, argv);
communicator->getProperties()->setProperty("TestAdapter.Endpoints", getTestEndpoint());
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter");
adapter->add(ICE_MAKE_SHARED(TestIntfI), Ice::stringToIdentity("TEST"));
adapter->add(ICE_MAKE_SHARED(Test1::WstringClassI), Ice::stringToIdentity("WSTRING1"));
adapter->add(ICE_MAKE_SHARED(Test2::WstringClassI), Ice::stringToIdentity("WSTRING2"));
adapter->activate();
serverReady();
communicator->waitForShutdown();
}
void
ServerAMD::run(int argc, char** argv)
{
Ice::PropertiesPtr properties = createTestProperties(argc, argv);
//
// Its possible to have batch oneway requests dispatched after
// the adapter is deactivated due to thread scheduling so we
// supress this warning.
//
properties->setProperty("Ice.Warn.Dispatch", "0");
Ice::CommunicatorHolder communicator = initialize(argc, argv, properties);
communicator->getProperties()->setProperty("TestAdapter.Endpoints", getTestEndpoint());
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter");
adapter->add(ICE_MAKE_SHARED(MyDerivedClassI), Ice::stringToIdentity("test"));
adapter->activate();
serverReady();
communicator->waitForShutdown();
}
int
main(int argc, char* argv[])
{
#ifdef ICE_STATIC_LIBS
Ice::registerIceSSL();
#endif
try
{
Ice::InitializationData initData;
initData.properties = Ice::createProperties(argc, argv);
Ice::CommunicatorHolder ich = Ice::initialize(argc, argv, initData);
assert(initData.properties != ich->getProperties());
return run(argc, argv, ich.communicator(), initData);
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
return EXIT_FAILURE;
}
}
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();
}
void
Server::run(int argc, char** argv)
{
Ice::CommunicatorHolder communicator = initialize(argc, argv);
Ice::PropertiesPtr properties = communicator->getProperties();
communicator->getProperties()->setProperty("TestAdapter.Endpoints", getTestEndpoint() + " -t 10000");
//
// First try to use an invalid priority.
//
communicator->getProperties()->setProperty("Ice.ThreadPool.Server.ThreadPriority", "1024");
try
{
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter");
test(false);
}
catch(const IceUtil::ThreadSyscallException&)
{
//expected
}
catch(...)
{
test(false);
}
//
// Now set the priority correctly.
//
#ifdef _WIN32
communicator->getProperties()->setProperty("Ice.ThreadPool.Server.ThreadPriority", "1");
#else
communicator->getProperties()->setProperty("Ice.ThreadPool.Server.ThreadPriority", "50");
#endif
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter");
Ice::ObjectPtr object = ICE_MAKE_SHARED(PriorityI, adapter);
adapter->add(object, Ice::stringToIdentity("test"));
adapter->activate();
communicator->waitForShutdown();
}
void
Server::run(int argc, char** argv)
{
Ice::PropertiesPtr properties = createTestProperties(argc, argv);
#if TARGET_OS_IPHONE != 0
//
// COMPILERFIX: Disable connect timeout introduced for
// workaround to iOS device hangs when using SSL
//
properties->setProperty("Ice.Override.ConnectTimeout", "");
#endif
//
// This test kills connections, so we don't want warnings.
//
properties->setProperty("Ice.Warn.Connections", "0");
//
// The client sends large messages to cause the transport
// buffers to fill up.
//
properties->setProperty("Ice.MessageSizeMax", "20000");
//
// Limit the recv buffer size, this test relies on the socket
// send() blocking after sending a given amount of data.
//
properties->setProperty("Ice.TCP.RcvSize", "50000");
Ice::CommunicatorHolder communicator = initialize(argc, argv, properties);
communicator->getProperties()->setProperty("TestAdapter.Endpoints", getTestEndpoint());
communicator->getProperties()->setProperty("ControllerAdapter.Endpoints", getTestEndpoint(1));
communicator->getProperties()->setProperty("ControllerAdapter.ThreadPool.Size", "1");
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter");
adapter->add(ICE_MAKE_SHARED(TimeoutI), Ice::stringToIdentity("timeout"));
adapter->activate();
Ice::ObjectAdapterPtr controllerAdapter = communicator->createObjectAdapter("ControllerAdapter");
controllerAdapter->add(ICE_MAKE_SHARED(ControllerI, adapter), Ice::stringToIdentity("controller"));
controllerAdapter->activate();
serverReady();
communicator->waitForShutdown();
}
void
Client::run(int argc, char** argv)
{
Ice::CommunicatorHolder communicator = initialize(argc, argv);
instance = this;
string protocol = getTestProtocol();
string host = getTestHost();
_initData.properties = Ice::createProperties(argc, argv, communicator->getProperties());
_initData.properties->setProperty("Ice.Default.Router", "Glacier2/router:" + getTestEndpoint(50));
DispatcherPtr dispatcher = new Dispatcher();
dispatcher->start();
#ifdef ICE_CPP11_MAPPING
_initData.dispatcher = [dispatcher](std::function<void()> call, const std::shared_ptr<Ice::Connection>& conn)
{
dispatcher->dispatch(call, conn);
};
#else
_initData.dispatcher = dispatcher;
#endif
_factory = ICE_MAKE_SHARED(Glacier2::SessionFactoryHelper, _initData, ICE_MAKE_SHARED(FailSessionCallback));
//
// Test to create a session with wrong userid/password
//
{
IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
cout << "testing SessionHelper connect with wrong userid/password... " << flush;
_session = _factory->connect("userid", "xxx");
//
// Wait for connectFailed callback
//
_monitor.timedWait(IceUtil::Time::seconds(30));
test(!_session->isConnected());
}
_factory->destroy();
//
// Test to interrupt connection establishment
//
_initData.properties->setProperty("Ice.Default.Router", "");
_factory = ICE_MAKE_SHARED(Glacier2::SessionFactoryHelper, _initData, ICE_MAKE_SHARED(InterruptConnectCallback));
{
IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
cout << "testing SessionHelper connect interrupt... " << flush;
_factory->setRouterHost(host);
_factory->setPort(getTestPort(_initData.properties, 1));
_factory->setProtocol(protocol);
_session = _factory->connect("userid", "abc123");
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(100));
_session->destroy();
//
// Wait for connectFailed callback
//
_monitor.timedWait(IceUtil::Time::seconds(30));
test(!_session->isConnected());
}
_factory->destroy();
_factory = ICE_MAKE_SHARED(Glacier2::SessionFactoryHelper, _initData, ICE_MAKE_SHARED(SuccessSessionCallback));
{
IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
cout << "testing SessionHelper connect... " << flush;
_factory->setRouterHost(host);
_factory->setPort(getTestPort(_initData.properties, 50));
_factory->setProtocol(protocol);
_session = _factory->connect("userid", "abc123");
//
// Wait for connect callback
//
_monitor.timedWait(IceUtil::Time::seconds(30));
cout << "testing SessionHelper isConnected after connect... " << flush;
test(_session->isConnected());
cout << "ok" << endl;
cout << "testing SessionHelper categoryForClient after connect... " << flush;
try
{
test(!_session->categoryForClient().empty());
}
catch(const Glacier2::SessionNotExistException&)
{
test(false);
}
cout << "ok" << endl;
test(!_session->session());
cout << "testing stringToProxy for server object... " << flush;
Ice::ObjectPrxPtr base =
_session->communicator()->stringToProxy("callback:" + getTestEndpoint(_session->communicator()->getProperties()));
cout << "ok" << endl;
cout << "pinging server after session creation... " << flush;
base->ice_ping();
cout << "ok" << endl;
cout << "testing checked cast for server object... " << flush;
CallbackPrxPtr twoway = ICE_CHECKED_CAST(CallbackPrx, base);
test(twoway);
cout << "ok" << endl;
cout << "testing server shutdown... " << flush;
twoway->shutdown();
cout << "ok" << endl;
test(_session->communicator());
cout << "testing SessionHelper destroy... " << flush;
_session->destroy();
//
// Wait for disconnected callback
//
_monitor.wait();
cout << "testing SessionHelper isConnected after destroy... " << flush;
test(_session->isConnected() == false);
cout << "ok" << endl;
cout << "testing SessionHelper categoryForClient after destroy... " << flush;
try
{
test(!_session->categoryForClient().empty());
test(false);
}
catch(const Glacier2::SessionNotExistException&)
{
}
cout << "ok" << endl;
cout << "testing SessionHelper session after destroy... " << flush;
test(_session->session() == ICE_NULLPTR);
cout << "ok" << endl;
cout << "testing SessionHelper communicator after destroy... " << flush;
try
{
test(_session->communicator());
_session->communicator()->stringToProxy("dummy");
test(false);
}
catch(const Ice::CommunicatorDestroyedException&)
{
}
cout << "ok" << endl;
cout << "uninstalling router with communicator... " << flush;
communicator->setDefaultRouter(0);
cout << "ok" << endl;
Ice::ObjectPrxPtr processBase;
{
cout << "testing stringToProxy for process object... " << flush;
processBase = communicator->stringToProxy("Glacier2/admin -f Process:" + getTestEndpoint(51));
cout << "ok" << endl;
}
Ice::ProcessPrxPtr process;
{
cout << "testing checked cast for admin object... " << flush;
process = ICE_CHECKED_CAST(Ice::ProcessPrx, processBase);
test(process != 0);
cout << "ok" << endl;
}
cout << "testing Glacier2 shutdown... " << flush;
process->shutdown();
try
{
process->ice_ping();
test(false);
}
catch(const Ice::LocalException&)
{
cout << "ok" << endl;
}
}
_factory->destroy();
_factory = ICE_MAKE_SHARED(Glacier2::SessionFactoryHelper, _initData, ICE_MAKE_SHARED(AfterShutdownSessionCallback));
//
// Wait a bit to ensure glaci2router has been shutdown.
//
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(100));
{
IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
cout << "testing SessionHelper connect after router shutdown... " << flush;
_factory->setRouterHost(host);
_factory->setPort(getTestPort(_initData.properties, 50));
_factory->setProtocol(protocol);
_session = _factory->connect("userid", "abc123");
//
// Wait for connectFailed callback
//
_monitor.wait();
cout << "testing SessionHelper isConnect after connect failure... " << flush;
test(_session->isConnected() == false);
cout << "ok" << endl;
cout << "testing SessionHelper communicator after connect failure... " << flush;
try
{
test(_session->communicator());
_session->communicator()->stringToProxy("dummy");
test(false);
}
catch(const Ice::CommunicatorDestroyedException&)
{
}
cout << "ok" << endl;
cout << "testing SessionHelper destroy after connect failure... " << flush;
_session->destroy();
cout << "ok" << endl;
}
_factory->destroy();
if(dispatcher)
{
dispatcher->destroy();
dispatcher->getThreadControl().join();
}
}
void
CallbackClient::run(int argc, char** argv)
{
Ice::PropertiesPtr properties = createTestProperties(argc, argv);
properties->setProperty("Ice.Warn.Connections", "0");
properties->setProperty("Ice.ThreadPool.Client.Serialize", "1");
Ice::CommunicatorHolder communicator = initialize(argc, argv, properties);
ObjectPrx routerBase = communicator->stringToProxy("Glacier2/router:" + getTestEndpoint(50));
Glacier2::RouterPrx router = Glacier2::RouterPrx::checkedCast(routerBase);
communicator->setDefaultRouter(router);
ObjectPrx base = communicator->stringToProxy("c/callback:" + getTestEndpoint());
Glacier2::SessionPrx session = router->createSession("userid", "abc123");
base->ice_ping();
CallbackPrx twoway = CallbackPrx::checkedCast(base);
CallbackPrx oneway = twoway->ice_oneway();
CallbackPrx batchOneway = twoway->ice_batchOneway();
communicator->getProperties()->setProperty("Ice.PrintAdapterReady", "0");
ObjectAdapterPtr adapter = communicator->createObjectAdapterWithRouter("CallbackReceiverAdapter", router);
adapter->activate();
string category = router->getCategoryForClient();
CallbackReceiverI* callbackReceiverImpl = new CallbackReceiverI;
ObjectPtr callbackReceiver = callbackReceiverImpl;
Identity callbackReceiverIdent;
callbackReceiverIdent.name = "callbackReceiver";
callbackReceiverIdent.category = category;
CallbackReceiverPrx twowayR =
CallbackReceiverPrx::uncheckedCast(adapter->add(callbackReceiver, callbackReceiverIdent));
CallbackReceiverPrx onewayR = twowayR->ice_oneway();
{
cout << "testing client request override... " << flush;
{
for(int i = 0; i < 5; i++)
{
oneway->initiateCallback(twowayR, 0);
oneway->initiateCallback(twowayR, 0);
callbackReceiverImpl->callbackOK(2, 0);
}
}
{
Ice::Context ctx;
ctx["_ovrd"] = "test";
for(int i = 0; i < 5; i++)
{
oneway->initiateCallback(twowayR, i, ctx);
oneway->initiateCallback(twowayR, i, ctx);
oneway->initiateCallback(twowayR, i, ctx);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(100));
test(callbackReceiverImpl->callbackOK(1, i) < 3);
}
}
cout << "ok" << endl;
}
{
cout << "testing server request override... " << flush;
Ice::Context ctx;
ctx["serverOvrd"] = "test";
for(int i = 0; i < 5; i++)
{
oneway->initiateCallback(onewayR, i, ctx);
oneway->initiateCallback(onewayR, i, ctx);
oneway->initiateCallback(onewayR, i, ctx);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(100));
test(callbackReceiverImpl->callbackOK(1, i) < 3);
}
oneway->initiateCallback(twowayR, 0);
test(callbackReceiverImpl->callbackOK(1, 0) == 0);
int count = 0;
int nRetry = 0;
do
{
callbackReceiverImpl->hold();
oneway->initiateCallbackWithPayload(onewayR, ctx);
oneway->initiateCallbackWithPayload(onewayR, ctx);
oneway->initiateCallbackWithPayload(onewayR, ctx);
oneway->initiateCallbackWithPayload(onewayR, ctx);
oneway->initiateCallbackWithPayload(onewayR, ctx);
oneway->initiateCallbackWithPayload(onewayR, ctx);
oneway->initiateCallbackWithPayload(onewayR, ctx);
oneway->initiateCallbackWithPayload(onewayR, ctx);
oneway->initiateCallbackWithPayload(onewayR, ctx);
oneway->initiateCallbackWithPayload(onewayR, ctx);
oneway->initiateCallback(twowayR, 0);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(200 + nRetry * 200));
callbackReceiverImpl->activate();
test(callbackReceiverImpl->callbackOK(1, 0) == 0);
count = callbackReceiverImpl->callbackWithPayloadOK(0);
callbackReceiverImpl->callbackWithPayloadOK(count);
}
while(count == 10 && nRetry++ < 10);
test(count < 10);
oneway->initiateCallbackWithPayload(twowayR);
oneway->initiateCallbackWithPayload(twowayR);
callbackReceiverImpl->hold();
oneway->initiateCallbackWithPayload(twowayR);
oneway->initiateCallback(onewayR, 0, ctx);
oneway->initiateCallback(onewayR, 0, ctx);
oneway->initiateCallback(onewayR, 0, ctx);
oneway->initiateCallback(onewayR, 0, ctx);
oneway->initiateCallback(onewayR, 0, ctx);
oneway->initiateCallbackWithPayload(twowayR);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(1000));
callbackReceiverImpl->activate();
test(callbackReceiverImpl->callbackWithPayloadOK(4) == 0);
int remainingCallbacks = callbackReceiverImpl->callbackOK(1, 0);
//
// Occasionally, Glacier2 flushes in the middle of our 5
// callbacks, so we get more than 1 callback
// (in theory we could get up to 5 total - more than 1 extra is extremely unlikely)
//
// The sleep above is also important as we want to have enough
// time to receive this (these) extra callback(s).
//
test(remainingCallbacks <= 4);
if(remainingCallbacks > 0)
{
test(callbackReceiverImpl->callbackOK(remainingCallbacks, 0) == 0);
}
ctx["_fwd"] = "O";
oneway->initiateCallbackWithPayload(twowayR);
callbackReceiverImpl->hold();
oneway->initiateCallbackWithPayload(twowayR);
oneway->initiateCallback(onewayR, 0, ctx);
oneway->initiateCallback(onewayR, 0, ctx);
oneway->initiateCallback(onewayR, 0, ctx);
oneway->initiateCallback(onewayR, 0, ctx);
oneway->initiateCallback(onewayR, 0, ctx);
oneway->initiateCallbackWithPayload(twowayR);
IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(200));
callbackReceiverImpl->activate();
test(callbackReceiverImpl->callbackWithPayloadOK(3) == 0);
remainingCallbacks = callbackReceiverImpl->callbackOK(1, 0);
// Unlikely but sometime we get more than just one callback if the flush
// occurs in the middle of our 5 callbacks.
test(remainingCallbacks <= 3);
if(remainingCallbacks > 0)
{
test(callbackReceiverImpl->callbackOK(remainingCallbacks, 0) == 0);
}
cout << "ok" << endl;
}
{
cout << "shutdown... " << flush;
twoway->shutdown();
try
{
router->destroySession();
}
catch(const Ice::LocalException&)
{
test(false);
}
communicator->setDefaultRouter(0);
ObjectPrx processBase = communicator->stringToProxy("Glacier2/admin -f Process:" + getTestEndpoint(51));
Ice::ProcessPrx process = Ice::ProcessPrx::checkedCast(processBase);
process->shutdown();
try
{
process->ice_ping();
test(false);
}
catch(const Ice::LocalException&)
{
cout << "ok" << endl;
}
}
}
int
main(int argc, char* argv[])
{
#ifdef ICE_STATIC_LIBS
Ice::registerIceSSL();
# if defined(__linux)
Ice::registerIceBT();
# endif
#endif
try
{
Ice::InitializationData initData;
initData.properties = Ice::createProperties(argc, argv);
initData.properties->setProperty("Ice.Warn.Connections", "0");
initData.properties->setProperty("Ice.MessageSizeMax", "10"); // 10KB max
Ice::CommunicatorHolder ich = Ice::initialize(argc, argv, initData);
RemoteConfig rc("Ice/exceptions", argc, argv, ich.communicator());
int status = run(argc, argv, ich.communicator());
rc.finished(status);
return status;
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
return EXIT_FAILURE;
}
}
int
main(int argc, char* argv[])
{
try {
// Create Ice communicator
//
Ice::CommunicatorHolder icHolder = Ice::initialize(argc, argv);
// Create a proxy for the root directory
//
auto base = icHolder->stringToProxy("RootDir:default -p 10000");
if (!base)
throw std::runtime_error("Could not create proxy");
// Down-cast the proxy to a Directory proxy
//
auto rootDir = Ice::checkedCast<DirectoryPrx>(base);
if (!rootDir)
throw std::runtime_error("Invalid proxy");
// Recursively list the contents of the root directory
//
cout << "Contents of root directory:" << endl;
listRecursive(rootDir);
} catch(const std::exception& e) {
cerr << e.what() << endl;
return 1;
}
return 0;
}
int
main(int argc, char* argv[])
{
try
{
Ice::InitializationData initData;
initData.properties = Ice::createProperties(argc, argv);
//
// This test kills connections, so we don't want warnings.
//
initData.properties->setProperty("Ice.Warn.Connections", "0");
initData.properties->setProperty("Ice.MessageSizeMax", "50000");
// This test relies on filling the TCP send/recv buffer, so
// we rely on a fixed value for these buffers.
initData.properties->setProperty("Ice.TCP.RcvSize", "50000");
//
// Setup the test transport plug-in.
//
initData.properties->setProperty("Ice.Plugin.Test", "TestTransport:createTestTransport");
string defaultProtocol = initData.properties->getPropertyWithDefault("Ice.Default.Protocol", "tcp");
initData.properties->setProperty("Ice.Default.Protocol", "test-" + defaultProtocol);
Ice::CommunicatorHolder ich = Ice::initialize(argc, argv, initData);
return run(argc, argv, ich.communicator());
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
return EXIT_FAILURE;
}
}
int
main(int argc, char* argv[])
{
#ifdef ICE_STATIC_LIBS
Ice::registerIceSSL();
#endif
try
{
Ice::InitializationData initData;
initData.properties = Ice::createProperties(argc, argv);
//
// Its possible to have batch oneway requests dispatched after
// the adapter is deactivated due to thread scheduling so we
// supress this warning.
//
initData.properties->setProperty("Ice.Warn.Dispatch", "0");
Ice::CommunicatorHolder ich = Ice::initialize(argc, argv, initData);
return run(argc, argv, ich.communicator());
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
return EXIT_FAILURE;
}
}
int
main(int argc, char* argv[])
{
#ifdef ICE_STATIC_LIBS
Ice::registerIceSSL();
#endif
try
{
//
// In this test, we need a longer server idle time, otherwise
// our test servers may time out before they are used in the
// test.
//
Ice::InitializationData initData;
initData.properties = Ice::createProperties(argc, argv);
initData.properties->setProperty("Ice.ServerIdleTime", "120"); // Two minutes.
Ice::CommunicatorHolder ich = Ice::initialize(argc, argv, initData);
return run(argc, argv, ich.communicator());
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
return EXIT_FAILURE;
}
}
void
Client::run(int argc, char** argv)
{
Ice::CommunicatorHolder communicator = initialize(argc, argv);
void allTests(Test::TestHelper*);
allTests(this);
//
// Shutdown the IceBox server.
//
ICE_UNCHECKED_CAST(Ice::ProcessPrx,
communicator->stringToProxy("DemoIceBox/admin -f Process:default -p 9996"))->shutdown();
}
int
main(int argc, char* argv[])
{
try {
Ice::CommunicatorHolder icHolder = Ice::initialize(argc, argv);
auto adapter = icHolder->createObjectAdapterWithEndpoints("SimplePrinterAdapter", "default -p 10000");
auto servant = make_shared<PrinterI>();
adapter->add(servant, Ice::stringToIdentity("SimplePrinter"));
adapter->activate();
icHolder->waitForShutdown();
} catch(const std::exception& e) {
cerr << e.what() << endl;
return 1;
}
return 0;
}
void
Client::run(int argc, char** argv)
{
Ice::CommunicatorHolder communicator = initialize(argc, argv);
ObjectPrx base = communicator->stringToProxy("Test.IceStorm/TopicManager");
IceStorm::TopicManagerPrx manager = IceStorm::TopicManagerPrx::checkedCast(base);
if(!manager)
{
ostringstream os;
os << argv[0] << ": `Test.IceStorm/TopicManager' is not running";
throw invalid_argument(os.str());
}
ObjectAdapterPtr adapter = communicator->createObjectAdapterWithEndpoints("SingleAdapter", "default:udp");
TopicPrx topic = manager->create("single");
//
// Create subscribers with different QoS.
//
SingleIPtr sub = new SingleI;
topic->subscribeAndGetPublisher(IceStorm::QoS(), adapter->addWithUUID(sub));
adapter->activate();
// Ensure that getPublisher & getNonReplicatedPublisher work
// correctly.
Ice::ObjectPrx p1 = topic->getPublisher();
Ice::ObjectPrx p2 = topic->getNonReplicatedPublisher();
test(p1->ice_getAdapterId() == "PublishReplicaGroup");
test(p2->ice_getAdapterId() == "Test.IceStorm1.Publish" ||
p2->ice_getAdapterId() == "Test.IceStorm2.Publish" ||
p2->ice_getAdapterId() == "Test.IceStorm3.Publish");
//
// Get a publisher object, create a twoway proxy and then cast to
// a Single object.
//
SinglePrx single = SinglePrx::uncheckedCast(topic->getPublisher()->ice_twoway());
for(int i = 0; i < 1000; ++i)
{
single->event(i);
}
sub->waitForEvents();
}
int
main(int argc, char* argv[])
{
#ifdef ICE_STATIC_LIBS
Ice::registerIceSSL();
#endif
try
{
Ice::CommunicatorHolder ich = Ice::initialize(argc, argv);
return run(argc, argv, ich.communicator());
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
return EXIT_FAILURE;
}
}
int
main(int argc, char* argv[])
{
try
{
Ice::CommunicatorHolder icHolder = Ice::initialize(argc, argv);
Ice::ObjectAdapterPtr adapter =
icHolder->createObjectAdapterWithEndpoints("SimplePrinterAdapter", "default -h localhost -p 10000");
Ice::ObjectPtr object = new PrinterI;
adapter->add(object, Ice::stringToIdentity("SimplePrinter"));
adapter->activate();
icHolder->waitForShutdown();
}
catch(const std::exception& e)
{
cerr << e.what() << endl;
return 1;
}
return 0;
}
int
main(int argc, char* argv[])
{
#ifdef ICE_STATIC_LIBS
Ice::registerIceSSL();
#endif
try
{
Ice::InitializationData initData;
initData.properties = Ice::createProperties(argc, argv);
initData.properties->setProperty("Ice.Warn.Connections", "0");
initData.properties->setProperty("Ice.ACM.Timeout", "1");
Ice::CommunicatorHolder ich = Ice::initialize(argc, argv, initData);
return run(argc, argv, ich.communicator());
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
return EXIT_FAILURE;
}
}
int
main(int argc, char* argv[])
{
#ifdef ICE_STATIC_LIBS
Ice::registerIceSSL();
#endif
try
{
Ice::InitializationData initData;
initData.properties = Ice::createProperties(argc, argv);
#if TARGET_OS_IPHONE != 0
//
// COMPILERFIX: Disable connect timeout introduced for
// workaround to iOS device hangs when using SSL
//
initData.properties->setProperty("Ice.Override.ConnectTimeout", "");
#endif
//
// This test kills connections, so we don't want warnings.
//
initData.properties->setProperty("Ice.Warn.Connections", "0");
//
// Limit the recv buffer size, this test relies on the socket
// send() blocking after sending a given amount of data.
//
initData.properties->setProperty("Ice.TCP.RcvSize", "50000");
Ice::CommunicatorHolder ich = Ice::initialize(argc, argv, initData);
return run(argc, argv, ich.communicator());
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
return EXIT_FAILURE;
}
}
int
main(int argc, char* argv[])
{
#ifdef ICE_STATIC_LIBS
Ice::registerIceSSL();
#endif
try
{
initCounts();
Ice::InitializationData initData;
initData.properties = Ice::createProperties(argc, argv);
initData.observer = getObserver();
//
// This test kills connections, so we don't want warnings.
//
initData.properties->setProperty("Ice.Warn.Connections", "0");
initData.properties->setProperty("Ice.RetryIntervals", "0 1 10 1");
Ice::CommunicatorHolder ich = Ice::initialize(argc, argv, initData);
//
// Configure a second communicator for the invocation timeout
// + retry test, we need to configure a large retry interval
// to avoid time-sensitive failures.
//
Ice::InitializationData initData2;
initData2.properties = initData.properties->clone();
initData2.properties->setProperty("Ice.RetryIntervals", "0 1 10000");
initData2.observer = getObserver();
Ice::CommunicatorHolder ich2 = Ice::initialize(initData2);
return run(argc, argv, ich.communicator(), ich2.communicator());
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
return EXIT_FAILURE;
}
}
int
main(int argc, char* argv[])
{
#ifdef ICE_STATIC_LIBS
Ice::registerIceSSL();
#endif
int status;
try
{
Ice::InitializationData initData;
initData.properties = Ice::createProperties(argc, argv);
//
// Limit the recv buffer size, this test relies on the socket
// send() blocking after sending a given amount of data.
//
initData.properties->setProperty("Ice.TCP.RcvSize", "50000");
#ifdef ICE_CPP11_MAPPING
Ice::DispatcherPtr dispatcher = new Dispatcher();
initData.dispatcher = [=](function<void ()> call, const shared_ptr<Ice::Connection>& conn)
{
dispatcher->dispatch(new DispatcherCall(call), conn);
};
#else
initData.dispatcher = new Dispatcher();
#endif
Ice::CommunicatorHolder ich = Ice::initialize(argc, argv, initData);
status = run(argc, argv, ich.communicator());
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
status = EXIT_FAILURE;
}
Dispatcher::terminate();
return status;
}
int
main(int argc, char* argv[])
{
#ifdef ICE_STATIC_LIBS
Ice::registerIceSSL();
# if defined(__linux)
Ice::registerIceBT();
# endif
#endif
try
{
Ice::CommunicatorHolder ich = Ice::initialize(argc, argv);
RemoteConfig rc("Ice/proxy", argc, argv, ich.communicator());
int status = run(argc, argv, ich.communicator());
rc.finished(status);
return status;
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
return EXIT_FAILURE;
}
}
void
allTests(const Ice::CommunicatorPtr& communicator)
{
string ref = "communicator:" + getTestEndpoint(communicator, 0);
RemoteCommunicatorPrxPtr com = ICE_UNCHECKED_CAST(RemoteCommunicatorPrx, communicator->stringToProxy(ref));
RandomNumberGenerator rng;
cout << "testing binding with single endpoint... " << flush;
{
RemoteObjectAdapterPrxPtr adapter = com->createObjectAdapter("Adapter", "default");
TestIntfPrxPtr test1 = adapter->getTestIntf();
TestIntfPrxPtr test2 = adapter->getTestIntf();
test(test1->ice_getConnection() == test2->ice_getConnection());
test1->ice_ping();
test2->ice_ping();
com->deactivateObjectAdapter(adapter);
TestIntfPrxPtr test3 = ICE_UNCHECKED_CAST(TestIntfPrx, test1);
test(test3->ice_getConnection() == test1->ice_getConnection());
test(test3->ice_getConnection() == test2->ice_getConnection());
try
{
test3->ice_ping();
test(false);
}
catch(const Ice::ConnectFailedException&)
{
}
}
cout << "ok" << endl;
cout << "testing binding with multiple endpoints... " << flush;
{
vector<RemoteObjectAdapterPrxPtr> adapters;
adapters.push_back(com->createObjectAdapter("Adapter11", "default"));
adapters.push_back(com->createObjectAdapter("Adapter12", "default"));
adapters.push_back(com->createObjectAdapter("Adapter13", "default"));
//
// Ensure that when a connection is opened it's reused for new
// proxies and that all endpoints are eventually tried.
//
set<string> names;
names.insert("Adapter11");
names.insert("Adapter12");
names.insert("Adapter13");
while(!names.empty())
{
vector<RemoteObjectAdapterPrxPtr> adpts = adapters;
TestIntfPrxPtr test1 = createTestIntfPrx(adpts);
random_shuffle(adpts.begin(), adpts.end(), rng);
TestIntfPrxPtr test2 = createTestIntfPrx(adpts);
random_shuffle(adpts.begin(), adpts.end(), rng);
TestIntfPrxPtr test3 = createTestIntfPrx(adpts);
test(test1->ice_getConnection() == test2->ice_getConnection());
test(test2->ice_getConnection() == test3->ice_getConnection());
names.erase(test1->getAdapterName());
test1->ice_getConnection()->close(false);
}
//
// Ensure that the proxy correctly caches the connection (we
// always send the request over the same connection.)
//
{
for(vector<RemoteObjectAdapterPrxPtr>::const_iterator p = adapters.begin(); p != adapters.end(); ++p)
{
(*p)->getTestIntf()->ice_ping();
}
TestIntfPrxPtr test = createTestIntfPrx(adapters);
string name = test->getAdapterName();
const int nRetry = 10;
int i;
for(i = 0; i < nRetry && test->getAdapterName() == name; i++);
test(i == nRetry);
for(vector<RemoteObjectAdapterPrxPtr>::const_iterator q = adapters.begin(); q != adapters.end(); ++q)
{
(*q)->getTestIntf()->ice_getConnection()->close(false);
}
}
//
// Deactivate an adapter and ensure that we can still
// establish the connection to the remaining adapters.
//
com->deactivateObjectAdapter(adapters[0]);
names.insert("Adapter12");
names.insert("Adapter13");
while(!names.empty())
{
vector<RemoteObjectAdapterPrxPtr> adpts = adapters;
TestIntfPrxPtr test1 = createTestIntfPrx(adpts);
random_shuffle(adpts.begin(), adpts.end(), rng);
TestIntfPrxPtr test2 = createTestIntfPrx(adpts);
random_shuffle(adpts.begin(), adpts.end(), rng);
TestIntfPrxPtr test3 = createTestIntfPrx(adpts);
test(test1->ice_getConnection() == test2->ice_getConnection());
test(test2->ice_getConnection() == test3->ice_getConnection());
names.erase(test1->getAdapterName());
test1->ice_getConnection()->close(false);
}
//
// Deactivate an adapter and ensure that we can still
// establish the connection to the remaining adapter.
//
com->deactivateObjectAdapter(adapters[2]);
TestIntfPrxPtr test = createTestIntfPrx(adapters);
test(test->getAdapterName() == "Adapter12");
deactivate(com, adapters);
}
cout << "ok" << endl;
cout << "testing binding with multiple random endpoints... " << flush;
{
vector<RemoteObjectAdapterPrxPtr> adapters;
adapters.push_back(com->createObjectAdapter("AdapterRandom11", "default"));
adapters.push_back(com->createObjectAdapter("AdapterRandom12", "default"));
adapters.push_back(com->createObjectAdapter("AdapterRandom13", "default"));
adapters.push_back(com->createObjectAdapter("AdapterRandom14", "default"));
adapters.push_back(com->createObjectAdapter("AdapterRandom15", "default"));
#ifdef _WIN32
int count = 60;
#else
int count = 20;
#endif
int adapterCount = static_cast<int>(adapters.size());
while(--count > 0)
{
#ifdef _WIN32
if(count == 10)
{
com->deactivateObjectAdapter(adapters[4]);
--adapterCount;
}
vector<TestIntfPrxPtr> proxies;
proxies.resize(10);
#else
if(count < 60 && count % 10 == 0)
{
com->deactivateObjectAdapter(adapters[count / 10 - 1]);
--adapterCount;
}
vector<TestIntfPrxPtr> proxies;
proxies.resize(40);
#endif
unsigned int i;
for(i = 0; i < proxies.size(); ++i)
{
vector<RemoteObjectAdapterPrxPtr> adpts;
adpts.resize(IceUtilInternal::random(static_cast<int>(adapters.size())));
if(adpts.empty())
{
adpts.resize(1);
}
for(vector<RemoteObjectAdapterPrxPtr>::iterator p = adpts.begin(); p != adpts.end(); ++p)
{
*p = adapters[IceUtilInternal::random(static_cast<int>(adapters.size()))];
}
proxies[i] = createTestIntfPrx(adpts);
}
for(i = 0; i < proxies.size(); i++)
{
#ifdef ICE_CPP11_MAPPING
proxies[i]->getAdapterName_async();
#else
proxies[i]->begin_getAdapterName();
#endif
}
for(i = 0; i < proxies.size(); i++)
{
try
{
proxies[i]->ice_ping();
}
catch(const Ice::LocalException&)
{
}
}
set<Ice::ConnectionPtr> connections;
for(i = 0; i < proxies.size(); i++)
{
if(proxies[i]->ice_getCachedConnection())
{
connections.insert(proxies[i]->ice_getCachedConnection());
}
}
test(static_cast<int>(connections.size()) <= adapterCount);
for(vector<RemoteObjectAdapterPrxPtr>::const_iterator q = adapters.begin(); q != adapters.end(); ++q)
{
try
{
(*q)->getTestIntf()->ice_getConnection()->close(false);
}
catch(const Ice::LocalException&)
{
// Expected if adapter is down.
}
}
}
}
cout << "ok" << endl;
cout << "testing binding with multiple endpoints and AMI... " << flush;
{
vector<RemoteObjectAdapterPrxPtr> adapters;
adapters.push_back(com->createObjectAdapter("AdapterAMI11", "default"));
adapters.push_back(com->createObjectAdapter("AdapterAMI12", "default"));
adapters.push_back(com->createObjectAdapter("AdapterAMI13", "default"));
//
// Ensure that when a connection is opened it's reused for new
// proxies and that all endpoints are eventually tried.
//
set<string> names;
names.insert("AdapterAMI11");
names.insert("AdapterAMI12");
names.insert("AdapterAMI13");
while(!names.empty())
{
vector<RemoteObjectAdapterPrxPtr> adpts = adapters;
TestIntfPrxPtr test1 = createTestIntfPrx(adpts);
random_shuffle(adpts.begin(), adpts.end(), rng);
TestIntfPrxPtr test2 = createTestIntfPrx(adpts);
random_shuffle(adpts.begin(), adpts.end(), rng);
TestIntfPrxPtr test3 = createTestIntfPrx(adpts);
test(test1->ice_getConnection() == test2->ice_getConnection());
test(test2->ice_getConnection() == test3->ice_getConnection());
names.erase(getAdapterNameWithAMI(test1));
test1->ice_getConnection()->close(false);
}
//
// Ensure that the proxy correctly caches the connection (we
// always send the request over the same connection.)
//
{
for(vector<RemoteObjectAdapterPrxPtr>::const_iterator p = adapters.begin(); p != adapters.end(); ++p)
{
(*p)->getTestIntf()->ice_ping();
}
TestIntfPrxPtr test = createTestIntfPrx(adapters);
string name = getAdapterNameWithAMI(test);
const int nRetry = 10;
int i;
for(i = 0; i < nRetry && getAdapterNameWithAMI(test) == name; i++);
test(i == nRetry);
for(vector<RemoteObjectAdapterPrxPtr>::const_iterator q = adapters.begin(); q != adapters.end(); ++q)
{
(*q)->getTestIntf()->ice_getConnection()->close(false);
}
}
//
// Deactivate an adapter and ensure that we can still
// establish the connection to the remaining adapters.
//
com->deactivateObjectAdapter(adapters[0]);
names.insert("AdapterAMI12");
names.insert("AdapterAMI13");
while(!names.empty())
{
vector<RemoteObjectAdapterPrxPtr> adpts = adapters;
TestIntfPrxPtr test1 = createTestIntfPrx(adpts);
random_shuffle(adpts.begin(), adpts.end(), rng);
TestIntfPrxPtr test2 = createTestIntfPrx(adpts);
random_shuffle(adpts.begin(), adpts.end(), rng);
TestIntfPrxPtr test3 = createTestIntfPrx(adpts);
test(test1->ice_getConnection() == test2->ice_getConnection());
test(test2->ice_getConnection() == test3->ice_getConnection());
names.erase(test1->getAdapterName());
test1->ice_getConnection()->close(false);
}
//
// Deactivate an adapter and ensure that we can still
// establish the connection to the remaining adapter.
//
com->deactivateObjectAdapter(adapters[2]);
TestIntfPrxPtr test = createTestIntfPrx(adapters);
test(test->getAdapterName() == "AdapterAMI12");
deactivate(com, adapters);
}
cout << "ok" << endl;
cout << "testing random endpoint selection... " << flush;
{
vector<RemoteObjectAdapterPrxPtr> adapters;
adapters.push_back(com->createObjectAdapter("Adapter21", "default"));
adapters.push_back(com->createObjectAdapter("Adapter22", "default"));
adapters.push_back(com->createObjectAdapter("Adapter23", "default"));
TestIntfPrxPtr test = createTestIntfPrx(adapters);
test(test->ice_getEndpointSelection() == Ice::Random);
set<string> names;
names.insert("Adapter21");
names.insert("Adapter22");
names.insert("Adapter23");
while(!names.empty())
{
names.erase(test->getAdapterName());
test->ice_getConnection()->close(false);
}
test = ICE_UNCHECKED_CAST(TestIntfPrx, test->ice_endpointSelection(Ice::Random));
test(test->ice_getEndpointSelection() == Ice::Random);
names.insert("Adapter21");
names.insert("Adapter22");
names.insert("Adapter23");
while(!names.empty())
{
names.erase(test->getAdapterName());
test->ice_getConnection()->close(false);
}
deactivate(com, adapters);
}
cout << "ok" << endl;
cout << "testing ordered endpoint selection... " << flush;
{
vector<RemoteObjectAdapterPrxPtr> adapters;
adapters.push_back(com->createObjectAdapter("Adapter31", "default"));
adapters.push_back(com->createObjectAdapter("Adapter32", "default"));
adapters.push_back(com->createObjectAdapter("Adapter33", "default"));
TestIntfPrxPtr test = createTestIntfPrx(adapters);
test = ICE_UNCHECKED_CAST(TestIntfPrx, test->ice_endpointSelection(Ice::Ordered));
test(test->ice_getEndpointSelection() == Ice::Ordered);
const int nRetry = 5;
int i;
//
// Ensure that endpoints are tried in order by deactiving the adapters
// one after the other.
//
for(i = 0; i < nRetry && test->getAdapterName() == "Adapter31"; i++);
#if TARGET_OS_IPHONE > 0
if(i != nRetry)
{
test->ice_getConnection()->close(false);
for(i = 0; i < nRetry && test->getAdapterName() == "Adapter31"; i++);
}
#endif
test(i == nRetry);
com->deactivateObjectAdapter(adapters[0]);
for(i = 0; i < nRetry && test->getAdapterName() == "Adapter32"; i++);
#if TARGET_OS_IPHONE > 0
if(i != nRetry)
{
test->ice_getConnection()->close(false);
for(i = 0; i < nRetry && test->getAdapterName() == "Adapter32"; i++);
}
#endif
test(i == nRetry);
com->deactivateObjectAdapter(adapters[1]);
for(i = 0; i < nRetry && test->getAdapterName() == "Adapter33"; i++);
#if TARGET_OS_IPHONE > 0
if(i != nRetry)
{
test->ice_getConnection()->close(false);
for(i = 0; i < nRetry && test->getAdapterName() == "Adapter33"; i++);
}
#endif
test(i == nRetry);
com->deactivateObjectAdapter(adapters[2]);
try
{
test->getAdapterName();
}
catch(const Ice::ConnectFailedException&)
{
}
Ice::EndpointSeq endpoints = test->ice_getEndpoints();
adapters.clear();
//
// Now, re-activate the adapters with the same endpoints in the opposite
// order.
//
adapters.push_back(com->createObjectAdapter("Adapter36", endpoints[2]->toString()));
for(i = 0; i < nRetry && test->getAdapterName() == "Adapter36"; i++);
#if TARGET_OS_IPHONE > 0
if(i != nRetry)
{
test->ice_getConnection()->close(false);
for(i = 0; i < nRetry && test->getAdapterName() == "Adapter36"; i++);
}
#endif
test(i == nRetry);
test->ice_getConnection()->close(false);
adapters.push_back(com->createObjectAdapter("Adapter35", endpoints[1]->toString()));
for(i = 0; i < nRetry && test->getAdapterName() == "Adapter35"; i++);
#if TARGET_OS_IPHONE > 0
if(i != nRetry)
{
test->ice_getConnection()->close(false);
for(i = 0; i < nRetry && test->getAdapterName() == "Adapter35"; i++);
}
#endif
test(i == nRetry);
test->ice_getConnection()->close(false);
adapters.push_back(com->createObjectAdapter("Adapter34", endpoints[0]->toString()));
for(i = 0; i < nRetry && test->getAdapterName() == "Adapter34"; i++);
#if TARGET_OS_IPHONE > 0
if(i != nRetry)
{
test->ice_getConnection()->close(false);
for(i = 0; i < nRetry && test->getAdapterName() == "Adapter34"; i++);
}
#endif
test(i == nRetry);
deactivate(com, adapters);
}
cout << "ok" << endl;
cout << "testing per request binding with single endpoint... " << flush;
{
RemoteObjectAdapterPrxPtr adapter = com->createObjectAdapter("Adapter41", "default");
TestIntfPrxPtr test1 = ICE_UNCHECKED_CAST(TestIntfPrx, adapter->getTestIntf()->ice_connectionCached(false));
TestIntfPrxPtr test2 = ICE_UNCHECKED_CAST(TestIntfPrx, adapter->getTestIntf()->ice_connectionCached(false));
test(!test1->ice_isConnectionCached());
test(!test2->ice_isConnectionCached());
test(test1->ice_getConnection() == test2->ice_getConnection());
test1->ice_ping();
com->deactivateObjectAdapter(adapter);
TestIntfPrxPtr test3 = ICE_UNCHECKED_CAST(TestIntfPrx, test1);
try
{
test(test3->ice_getConnection() == test1->ice_getConnection());
test(false);
}
catch(const Ice::ConnectFailedException&)
{
}
}
cout << "ok" << endl;
cout << "testing per request binding with multiple endpoints... " << flush;
{
vector<RemoteObjectAdapterPrxPtr> adapters;
adapters.push_back(com->createObjectAdapter("Adapter51", "default"));
adapters.push_back(com->createObjectAdapter("Adapter52", "default"));
adapters.push_back(com->createObjectAdapter("Adapter53", "default"));
TestIntfPrxPtr test = ICE_UNCHECKED_CAST(TestIntfPrx, createTestIntfPrx(adapters)->ice_connectionCached(false));
test(!test->ice_isConnectionCached());
set<string> names;
names.insert("Adapter51");
names.insert("Adapter52");
names.insert("Adapter53");
while(!names.empty())
{
names.erase(test->getAdapterName());
}
com->deactivateObjectAdapter(adapters[0]);
names.insert("Adapter52");
names.insert("Adapter53");
while(!names.empty())
{
names.erase(test->getAdapterName());
}
com->deactivateObjectAdapter(adapters[2]);
test(test->getAdapterName() == "Adapter52");
deactivate(com, adapters);
}
cout << "ok" << endl;
cout << "testing per request binding with multiple endpoints and AMI... " << flush;
{
vector<RemoteObjectAdapterPrxPtr> adapters;
adapters.push_back(com->createObjectAdapter("AdapterAMI51", "default"));
adapters.push_back(com->createObjectAdapter("AdapterAMI52", "default"));
adapters.push_back(com->createObjectAdapter("AdapterAMI53", "default"));
TestIntfPrxPtr test = ICE_UNCHECKED_CAST(TestIntfPrx, createTestIntfPrx(adapters)->ice_connectionCached(false));
test(!test->ice_isConnectionCached());
set<string> names;
names.insert("AdapterAMI51");
names.insert("AdapterAMI52");
names.insert("AdapterAMI53");
while(!names.empty())
{
names.erase(getAdapterNameWithAMI(test));
}
com->deactivateObjectAdapter(adapters[0]);
names.insert("AdapterAMI52");
names.insert("AdapterAMI53");
while(!names.empty())
{
names.erase(getAdapterNameWithAMI(test));
}
com->deactivateObjectAdapter(adapters[2]);
test(test->getAdapterName() == "AdapterAMI52");
deactivate(com, adapters);
}
cout << "ok" << endl;
cout << "testing per request binding and ordered endpoint selection... " << flush;
{
vector<RemoteObjectAdapterPrxPtr> adapters;
adapters.push_back(com->createObjectAdapter("Adapter61", "default"));
adapters.push_back(com->createObjectAdapter("Adapter62", "default"));
adapters.push_back(com->createObjectAdapter("Adapter63", "default"));
TestIntfPrxPtr test = createTestIntfPrx(adapters);
test = ICE_UNCHECKED_CAST(TestIntfPrx, test->ice_endpointSelection(Ice::Ordered));
test(test->ice_getEndpointSelection() == Ice::Ordered);
test = ICE_UNCHECKED_CAST(TestIntfPrx, test->ice_connectionCached(false));
test(!test->ice_isConnectionCached());
const int nRetry = 5;
int i;
//
// Ensure that endpoints are tried in order by deactiving the adapters
// one after the other.
//
for(i = 0; i < nRetry && test->getAdapterName() == "Adapter61"; i++);
#if TARGET_OS_IPHONE > 0
test(i >= nRetry - 1); // WORKAROUND: for connection establishment hang.
#else
test(i == nRetry);
#endif
com->deactivateObjectAdapter(adapters[0]);
for(i = 0; i < nRetry && test->getAdapterName() == "Adapter62"; i++);
#if TARGET_OS_IPHONE > 0
test(i >= nRetry - 1); // WORKAROUND: for connection establishment hang.
#else
test(i == nRetry);
#endif
com->deactivateObjectAdapter(adapters[1]);
for(i = 0; i < nRetry && test->getAdapterName() == "Adapter63"; i++);
#if TARGET_OS_IPHONE > 0
test(i >= nRetry - 1); // WORKAROUND: for connection establishment hang.
#else
test(i == nRetry);
#endif
com->deactivateObjectAdapter(adapters[2]);
try
{
test->getAdapterName();
}
catch(const Ice::ConnectFailedException&)
{
}
Ice::EndpointSeq endpoints = test->ice_getEndpoints();
adapters.clear();
//
// Now, re-activate the adapters with the same endpoints in the opposite
// order.
//
adapters.push_back(com->createObjectAdapter("Adapter66", endpoints[2]->toString()));
for(i = 0; i < nRetry && test->getAdapterName() == "Adapter66"; i++);
#if TARGET_OS_IPHONE > 0
test(i >= nRetry - 1); // WORKAROUND: for connection establishment hang.
#else
test(i == nRetry);
#endif
adapters.push_back(com->createObjectAdapter("Adapter65", endpoints[1]->toString()));
for(i = 0; i < nRetry && test->getAdapterName() == "Adapter65"; i++);
#if TARGET_OS_IPHONE > 0
test(i >= nRetry - 1); // WORKAROUND: for connection establishment hang.
#else
test(i == nRetry);
#endif
adapters.push_back(com->createObjectAdapter("Adapter64", endpoints[0]->toString()));
for(i = 0; i < nRetry && test->getAdapterName() == "Adapter64"; i++);
#if TARGET_OS_IPHONE > 0
test(i >= nRetry - 1); // WORKAROUND: for connection establishment hang.
#else
test(i == nRetry);
#endif
deactivate(com, adapters);
}
cout << "ok" << endl;
cout << "testing per request binding and ordered endpoint selection and AMI... " << flush;
{
vector<RemoteObjectAdapterPrxPtr> adapters;
adapters.push_back(com->createObjectAdapter("AdapterAMI61", "default"));
adapters.push_back(com->createObjectAdapter("AdapterAMI62", "default"));
adapters.push_back(com->createObjectAdapter("AdapterAMI63", "default"));
TestIntfPrxPtr test = createTestIntfPrx(adapters);
test = ICE_UNCHECKED_CAST(TestIntfPrx, test->ice_endpointSelection(Ice::Ordered));
test(test->ice_getEndpointSelection() == Ice::Ordered);
test = ICE_UNCHECKED_CAST(TestIntfPrx, test->ice_connectionCached(false));
test(!test->ice_isConnectionCached());
const int nRetry = 5;
int i;
//
// Ensure that endpoints are tried in order by deactiving the adapters
// one after the other.
//
for(i = 0; i < nRetry && getAdapterNameWithAMI(test) == "AdapterAMI61"; i++);
#if TARGET_OS_IPHONE > 0
test(i >= nRetry - 1); // WORKAROUND: for connection establishment hang.
#else
test(i == nRetry);
#endif
com->deactivateObjectAdapter(adapters[0]);
for(i = 0; i < nRetry && getAdapterNameWithAMI(test) == "AdapterAMI62"; i++);
#if TARGET_OS_IPHONE > 0
test(i >= nRetry - 1); // WORKAROUND: for connection establishment hang.
#else
test(i == nRetry);
#endif
com->deactivateObjectAdapter(adapters[1]);
for(i = 0; i < nRetry && getAdapterNameWithAMI(test) == "AdapterAMI63"; i++);
#if TARGET_OS_IPHONE > 0
test(i >= nRetry - 1); // WORKAROUND: for connection establishment hang.
#else
test(i == nRetry);
#endif
com->deactivateObjectAdapter(adapters[2]);
try
{
test->getAdapterName();
}
catch(const Ice::ConnectFailedException&)
{
}
Ice::EndpointSeq endpoints = test->ice_getEndpoints();
adapters.clear();
//
// Now, re-activate the adapters with the same endpoints in the opposite
// order.
//
adapters.push_back(com->createObjectAdapter("AdapterAMI66", endpoints[2]->toString()));
for(i = 0; i < nRetry && getAdapterNameWithAMI(test) == "AdapterAMI66"; i++);
#if TARGET_OS_IPHONE > 0
test(i >= nRetry - 1); // WORKAROUND: for connection establishment hang.
#else
test(i == nRetry);
#endif
adapters.push_back(com->createObjectAdapter("AdapterAMI65", endpoints[1]->toString()));
for(i = 0; i < nRetry && getAdapterNameWithAMI(test) == "AdapterAMI65"; i++);
test(i == nRetry);
adapters.push_back(com->createObjectAdapter("AdapterAMI64", endpoints[0]->toString()));
for(i = 0; i < nRetry && getAdapterNameWithAMI(test) == "AdapterAMI64"; i++);
test(i == nRetry);
deactivate(com, adapters);
}
cout << "ok" << endl;
cout << "testing endpoint mode filtering... " << flush;
{
vector<RemoteObjectAdapterPrxPtr> adapters;
adapters.push_back(com->createObjectAdapter("Adapter71", "default"));
adapters.push_back(com->createObjectAdapter("Adapter72", "udp"));
TestIntfPrxPtr test = createTestIntfPrx(adapters);
test(test->getAdapterName() == "Adapter71");
TestIntfPrxPtr testUDP = ICE_UNCHECKED_CAST(TestIntfPrx, test->ice_datagram());
test(test->ice_getConnection() != testUDP->ice_getConnection());
try
{
testUDP->getAdapterName();
}
catch(const Ice::TwowayOnlyException&)
{
}
catch(const IceUtil::IllegalArgumentException&)
{
}
}
cout << "ok" << endl;
if(!communicator->getProperties()->getProperty("Ice.Plugin.IceSSL").empty() &&
communicator->getProperties()->getProperty("Ice.Default.Protocol") == "ssl")
{
cout << "testing unsecure vs. secure endpoints... " << flush;
{
vector<RemoteObjectAdapterPrxPtr> adapters;
adapters.push_back(com->createObjectAdapter("Adapter81", "ssl"));
adapters.push_back(com->createObjectAdapter("Adapter82", "tcp"));
TestIntfPrxPtr test = createTestIntfPrx(adapters);
int i;
for(i = 0; i < 5; i++)
{
test(test->getAdapterName() == "Adapter82");
test->ice_getConnection()->close(false);
}
TestIntfPrxPtr testSecure = ICE_UNCHECKED_CAST(TestIntfPrx, test->ice_secure(true));
test(testSecure->ice_isSecure());
testSecure = ICE_UNCHECKED_CAST(TestIntfPrx, test->ice_secure(false));
test(!testSecure->ice_isSecure());
testSecure = ICE_UNCHECKED_CAST(TestIntfPrx, test->ice_secure(true));
test(testSecure->ice_isSecure());
test(test->ice_getConnection() != testSecure->ice_getConnection());
com->deactivateObjectAdapter(adapters[1]);
for(i = 0; i < 5; i++)
{
test(test->getAdapterName() == "Adapter81");
test->ice_getConnection()->close(false);
}
com->createObjectAdapter("Adapter83", (test->ice_getEndpoints()[1])->toString()); // Reactive tcp OA.
for(i = 0; i < 5; i++)
{
test(test->getAdapterName() == "Adapter83");
test->ice_getConnection()->close(false);
}
com->deactivateObjectAdapter(adapters[0]);
try
{
testSecure->ice_ping();
test(false);
}
catch(const Ice::ConnectFailedException&)
{
}
deactivate(com, adapters);
}
cout << "ok" << endl;
}
{
cout << "testing ipv4 & ipv6 connections... " << flush;
Ice::PropertiesPtr ipv4 = Ice::createProperties();
ipv4->setProperty("Ice.IPv4", "1");
ipv4->setProperty("Ice.IPv6", "0");
ipv4->setProperty("Adapter.Endpoints", "tcp -h localhost");
Ice::PropertiesPtr ipv6 = Ice::createProperties();
ipv6->setProperty("Ice.IPv4", "0");
ipv6->setProperty("Ice.IPv6", "1");
ipv6->setProperty("Adapter.Endpoints", "tcp -h localhost");
Ice::PropertiesPtr bothPreferIPv4 = Ice::createProperties();
bothPreferIPv4->setProperty("Ice.IPv4", "1");
bothPreferIPv4->setProperty("Ice.IPv6", "1");
bothPreferIPv4->setProperty("Ice.PreferIPv6Address", "0");
bothPreferIPv4->setProperty("Adapter.Endpoints", "tcp -h localhost");
Ice::PropertiesPtr bothPreferIPv6 = Ice::createProperties();
bothPreferIPv6->setProperty("Ice.IPv4", "1");
bothPreferIPv6->setProperty("Ice.IPv6", "1");
bothPreferIPv6->setProperty("Ice.PreferIPv6Address", "1");
bothPreferIPv6->setProperty("Adapter.Endpoints", "tcp -h localhost");
vector<Ice::PropertiesPtr> clientProps;
clientProps.push_back(ipv4);
clientProps.push_back(ipv6);
clientProps.push_back(bothPreferIPv4);
clientProps.push_back(bothPreferIPv6);
Ice::PropertiesPtr anyipv4 = ipv4->clone();
anyipv4->setProperty("Adapter.Endpoints", "tcp -p 12012");
anyipv4->setProperty("Adapter.PublishedEndpoints", "tcp -h 127.0.0.1 -p 12012");
Ice::PropertiesPtr anyipv6 = ipv6->clone();
anyipv6->setProperty("Adapter.Endpoints", "tcp -p 12012");
anyipv6->setProperty("Adapter.PublishedEndpoints", "tcp -h \"::1\" -p 12012");
Ice::PropertiesPtr anyboth = Ice::createProperties();
anyboth->setProperty("Ice.IPv4", "1");
anyboth->setProperty("Ice.IPv6", "1");
anyboth->setProperty("Adapter.Endpoints", "tcp -p 12012");
anyboth->setProperty("Adapter.PublishedEndpoints", "tcp -h \"::1\" -p 12012:tcp -h 127.0.0.1 -p 12012");
Ice::PropertiesPtr localipv4 = ipv4->clone();
localipv4->setProperty("Adapter.Endpoints", "tcp -h 127.0.0.1");
Ice::PropertiesPtr localipv6 = ipv6->clone();
localipv6->setProperty("Adapter.Endpoints", "tcp -h \"::1\"");
vector<Ice::PropertiesPtr> serverProps = clientProps;
serverProps.push_back(anyipv4);
serverProps.push_back(anyipv6);
serverProps.push_back(anyboth);
serverProps.push_back(localipv4);
serverProps.push_back(localipv6);
#if defined(_WIN32) && !defined(ICE_OS_WINRT)
OSVERSIONINFO ver;
ver.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
# if defined(_MSC_VER) && _MSC_VER >= 1800
# pragma warning (disable : 4996)
# endif
GetVersionEx(&ver);
# if defined(_MSC_VER) && _MSC_VER >= 1800
# pragma warning (default : 4996)
# endif
const bool dualStack = ver.dwMajorVersion >= 6; // Windows XP IPv6 doesn't support dual-stack
#else
const bool dualStack = true;
#endif
bool ipv6NotSupported = false;
for(vector<Ice::PropertiesPtr>::const_iterator p = serverProps.begin(); p != serverProps.end(); ++p)
{
Ice::InitializationData serverInitData;
serverInitData.properties = *p;
Ice::CommunicatorPtr serverCommunicator = Ice::initialize(serverInitData);
Ice::ObjectAdapterPtr oa;
try
{
oa = serverCommunicator->createObjectAdapter("Adapter");
oa->activate();
}
catch(const Ice::DNSException&)
{
serverCommunicator->destroy();
continue; // IP version not supported.
}
catch(const Ice::SocketException&)
{
if(*p == ipv6)
{
ipv6NotSupported = true;
}
serverCommunicator->destroy();
continue; // IP version not supported.
}
// Ensure the published endpoints are actually valid. On
// Fedora, binding to "localhost" with IPv6 only works but
// resolving localhost don't return the IPv6 adress.
Ice::ObjectPrxPtr prx = oa->createProxy(serverCommunicator->stringToIdentity("dummy"));
try
{
prx->ice_collocationOptimized(false)->ice_ping();
}
catch(const Ice::LocalException&)
{
serverCommunicator->destroy();
continue; // IP version not supported.
}
string strPrx = prx->ice_toString();
for(vector<Ice::PropertiesPtr>::const_iterator q = clientProps.begin(); q != clientProps.end(); ++q)
{
Ice::InitializationData clientInitData;
clientInitData.properties = *q;
Ice::CommunicatorHolder clientCommunicator = Ice::initialize(clientInitData);
Ice::ObjectPrxPtr prx = clientCommunicator->stringToProxy(strPrx);
try
{
prx->ice_ping();
test(false);
}
catch(const Ice::ObjectNotExistException&)
{
// Expected, no object registered.
}
catch(const Ice::DNSException&)
{
// Expected if no IPv4 or IPv6 address is
// associated to localhost or if trying to connect
// to an any endpoint with the wrong IP version,
// e.g.: resolving an IPv4 address when only IPv6
// is enabled fails with a DNS exception.
}
catch(const Ice::SocketException&)
{
test((*p == ipv4 && *q == ipv6) || (*p == ipv6 && *q == ipv4) ||
(*p == bothPreferIPv4 && *q == ipv6) || (*p == bothPreferIPv6 && *q == ipv4) ||
(*p == bothPreferIPv6 && *q == ipv6 && ipv6NotSupported) ||
(*p == anyipv4 && *q == ipv6) || (*p == anyipv6 && *q == ipv4) ||
(*p == anyboth && *q == ipv4 && !dualStack) ||
(*p == localipv4 && *q == ipv6) || (*p == localipv6 && *q == ipv4) ||
(*p == ipv6 && *q == bothPreferIPv4) || (*p == ipv6 && *q == bothPreferIPv6) ||
(*p == bothPreferIPv6 && *q == ipv6));
}
}
serverCommunicator->destroy();
}
cout << "ok" << endl;
}
com->shutdown();
}
void
Client::run(int argc, char** argv)
{
Ice::PropertiesPtr properties = createTestProperties(argc, argv);
#ifndef ICE_CPP11_MAPPING
properties->setProperty("Ice.CollectObjects", "1");
#endif
Ice::CommunicatorHolder communicator = initialize(argc, argv, properties);
#ifdef ICE_CPP11_MAPPING
communicator->getValueFactoryManager()->add(makeFactory<BI>(), "::Test::B");
communicator->getValueFactoryManager()->add(makeFactory<CI>(), "::Test::C");
communicator->getValueFactoryManager()->add(makeFactory<DI>(), "::Test::D");
communicator->getValueFactoryManager()->add(makeFactory<EI>(), "::Test::E");
communicator->getValueFactoryManager()->add(makeFactory<FI>(), "::Test::F");
communicator->getValueFactoryManager()->add(makeFactory<II>(), "::Test::I");
communicator->getValueFactoryManager()->add(makeFactory<JI>(), "::Test::J");
communicator->getValueFactoryManager()->add(makeFactory<HI>(), "::Test::H");
communicator->addObjectFactory(make_shared<MyObjectFactory>(), "TestOF");
#else
Ice::ValueFactoryPtr factory = new MyValueFactory;
communicator->getValueFactoryManager()->add(factory, "::Test::B");
communicator->getValueFactoryManager()->add(factory, "::Test::C");
communicator->getValueFactoryManager()->add(factory, "::Test::D");
communicator->getValueFactoryManager()->add(factory, "::Test::E");
communicator->getValueFactoryManager()->add(factory, "::Test::F");
communicator->getValueFactoryManager()->add(factory, "::Test::I");
communicator->getValueFactoryManager()->add(factory, "::Test::J");
communicator->getValueFactoryManager()->add(factory, "::Test::H");
communicator->addObjectFactory(new MyObjectFactory(), "TestOF");
#endif
InitialPrxPtr allTests(Test::TestHelper*);
InitialPrxPtr initial = allTests(this);
initial->shutdown();
}