diff options
Diffstat (limited to 'cpp/test')
29 files changed, 833 insertions, 1199 deletions
diff --git a/cpp/test/Glacier2/attack/BackendI.h b/cpp/test/Glacier2/attack/BackendI.h index a22383abb94..9ac0cb658db 100644 --- a/cpp/test/Glacier2/attack/BackendI.h +++ b/cpp/test/Glacier2/attack/BackendI.h @@ -7,11 +7,11 @@ #include <Backend.h> -class BackendI : public Test::Backend +class BackendI final : public Test::Backend { public: - virtual void shutdown(const Ice::Current&); + void shutdown(const Ice::Current&) override; }; #endif diff --git a/cpp/test/Glacier2/attack/Client.cpp b/cpp/test/Glacier2/attack/Client.cpp index f0fe833161e..8efc85925a5 100644 --- a/cpp/test/Glacier2/attack/Client.cpp +++ b/cpp/test/Glacier2/attack/Client.cpp @@ -2,28 +2,28 @@ // Copyright (c) ZeroC, Inc. All rights reserved. // -#include <IceUtil/Random.h> #include <Ice/Ice.h> #include <Glacier2/Router.h> #include <Backend.h> #include <TestHelper.h> #include <set> +#include <random> using namespace std; using namespace Ice; using namespace Test; -class AttackClient : public Test::TestHelper +class AttackClient final : public Test::TestHelper { public: - void run(int, char**); + void run(int, char**) override; }; void AttackClient::run(int argc, char** argv) { - Ice::PropertiesPtr properties = createTestProperties(argc, argv); + auto properties = createTestProperties(argc, argv); // // We want to check whether the client retries for evicted // proxies, even with regular retries disabled. @@ -32,22 +32,22 @@ AttackClient::run(int argc, char** argv) Ice::CommunicatorHolder communicator = initialize(argc, argv, properties); cout << "getting router... " << flush; - ObjectPrx routerBase = communicator->stringToProxy("Glacier2/router:" + getTestEndpoint(50)); - Glacier2::RouterPrx router = Glacier2::RouterPrx::checkedCast(routerBase); + auto routerBase = communicator->stringToProxy("Glacier2/router:" + getTestEndpoint(50)); + auto router = checkedCast<Glacier2::RouterPrx>(routerBase); test(router); communicator->setDefaultRouter(router); cout << "ok" << endl; cout << "creating session... " << flush; - Glacier2::SessionPrx session = router->createSession("userid", "abc123"); + auto session = router->createSession("userid", "abc123"); cout << "ok" << endl; cout << "making thousands of invocations on proxies... " << flush; - ObjectPrx backendBase = communicator->stringToProxy("dummy:" + getTestEndpoint()); - BackendPrx backend = BackendPrx::uncheckedCast(backendBase); + auto backendBase = communicator->stringToProxy("dummy:" + getTestEndpoint()); + auto backend = checkedCast<BackendPrx>(backendBase); backend->ice_ping(); - set<BackendPrx> backends; + set<shared_ptr<BackendPrx>, TargetCompare<shared_ptr<BackendPrx>, std::less>> backends; string msg; for(int i = 1; i <= 10000; ++i) @@ -66,22 +66,23 @@ AttackClient::run(int argc, char** argv) Identity ident; string::iterator p; + random_device rd; - ident.name.resize(1); // 1 + IceUtilInternal::random() % 2); + ident.name.resize(1); for(p = ident.name.begin(); p != ident.name.end(); ++p) { - *p = static_cast<char>('A' + IceUtilInternal::random() % 26); + *p = static_cast<char>('A' + rd() % 26); } - ident.category.resize(IceUtilInternal::random() % 2); + ident.category.resize(rd() % 2); for(p = ident.category.begin(); p != ident.category.end(); ++p) { - *p = static_cast<char>('a' + IceUtilInternal::random() % 26); + *p = static_cast<char>('a' + rd() % 26); } - BackendPrx newBackend = BackendPrx::uncheckedCast(backendBase->ice_identity(ident)); + auto newBackend = uncheckedCast<BackendPrx>(backendBase->ice_identity(ident)); - set<BackendPrx>::const_iterator q = backends.find(newBackend); + auto q = backends.find(newBackend); if(q == backends.end()) { @@ -101,8 +102,8 @@ AttackClient::run(int argc, char** argv) cout << "testing server and router shutdown... " << flush; backend->shutdown(); communicator->setDefaultRouter(0); - ObjectPrx adminBase = communicator->stringToProxy("Glacier2/admin -f Process:" + getTestEndpoint(51)); - Ice::ProcessPrx process = Ice::ProcessPrx::checkedCast(adminBase); + auto adminBase = communicator->stringToProxy("Glacier2/admin -f Process:" + getTestEndpoint(51)); + auto process = checkedCast<Ice::ProcessPrx>(adminBase); test(process); process->shutdown(); try diff --git a/cpp/test/Glacier2/attack/Server.cpp b/cpp/test/Glacier2/attack/Server.cpp index 7fa07896709..c70ed62ef4c 100644 --- a/cpp/test/Glacier2/attack/Server.cpp +++ b/cpp/test/Glacier2/attack/Server.cpp @@ -10,38 +10,11 @@ using namespace std; using namespace Ice; using namespace Test; -class ServantLocatorI : public virtual ServantLocator +class BackendServer final : public Test::TestHelper { public: - ServantLocatorI() : - _backend(new BackendI) - { - } - - virtual ObjectPtr locate(const Current&, LocalObjectPtr&) - { - return _backend; - } - - virtual void finished(const Current&, const ObjectPtr&, const LocalObjectPtr&) - { - } - - virtual void deactivate(const string&) - { - } - -private: - - BackendPtr _backend; -}; - -class BackendServer : public Test::TestHelper -{ -public: - - void run(int, char**); + void run(int, char**) override; }; void @@ -49,8 +22,8 @@ BackendServer::run(int argc, char** argv) { Ice::CommunicatorHolder communicator = initialize(argc, argv); communicator->getProperties()->setProperty("BackendAdapter.Endpoints", getTestEndpoint()); - ObjectAdapterPtr adapter = communicator->createObjectAdapter("BackendAdapter"); - adapter->addServantLocator(new ServantLocatorI, ""); + auto adapter = communicator->createObjectAdapter("BackendAdapter"); + adapter->addDefaultServant(make_shared<BackendI>(), ""); adapter->activate(); communicator->waitForShutdown(); } diff --git a/cpp/test/Glacier2/dynamicFiltering/BackendI.h b/cpp/test/Glacier2/dynamicFiltering/BackendI.h index bf17a14fa6a..7dbcadd2930 100644 --- a/cpp/test/Glacier2/dynamicFiltering/BackendI.h +++ b/cpp/test/Glacier2/dynamicFiltering/BackendI.h @@ -7,11 +7,11 @@ #include <Test.h> -class BackendI : public Test::Backend +class BackendI final : public Test::Backend { public: - virtual void check(const Ice::Current&); - virtual void shutdown(const Ice::Current&); + void check(const Ice::Current&) override; + void shutdown(const Ice::Current&) override; }; #endif diff --git a/cpp/test/Glacier2/dynamicFiltering/Client.cpp b/cpp/test/Glacier2/dynamicFiltering/Client.cpp index 87acfd20165..0a236c00196 100644 --- a/cpp/test/Glacier2/dynamicFiltering/Client.cpp +++ b/cpp/test/Glacier2/dynamicFiltering/Client.cpp @@ -11,17 +11,17 @@ using namespace std; using namespace Ice; using namespace Test; -class SessionControlClient : public Test::TestHelper +class SessionControlClient final : public Test::TestHelper { public: - void run(int, char**); + void run(int, char**) override; }; void SessionControlClient::run(int argc, char** argv) { - Ice::PropertiesPtr properties = createTestProperties(argc, argv); + auto properties = createTestProperties(argc, argv); // // We want to check whether the client retries for evicted // proxies, even with regular retries disabled. @@ -38,8 +38,8 @@ SessionControlClient::run(int argc, char** argv) cout << "accessing test controller... " << flush; Ice::InitializationData initData; initData.properties = communicator->getProperties(); - Ice::CommunicatorPtr controlComm = Ice::initialize(argc, argv, initData); - TestControllerPrx controller = TestControllerPrx::checkedCast( + auto controlComm = Ice::initialize(argc, argv, initData); + auto controller = checkedCast<TestControllerPrx>( controlComm->stringToProxy("testController:" + getTestEndpoint(2, "tcp"))); test(controller); TestToken currentState; @@ -47,28 +47,28 @@ SessionControlClient::run(int argc, char** argv) currentState.expectedResult = false; currentState.config = 0; currentState.caseIndex = 0; - currentState.code = Initial; + currentState.code = StateCode::Initial; controller->step(0, currentState, newState); currentState = newState; cout << "ok" << endl; cout << "getting router... " << flush; - ObjectPrx routerBase = communicator->stringToProxy("Glacier2/router:" + getTestEndpoint(50)); - Glacier2::RouterPrx router = Glacier2::RouterPrx::checkedCast(routerBase); + auto routerBase = communicator->stringToProxy("Glacier2/router:" + getTestEndpoint(50)); + auto router = checkedCast<Glacier2::RouterPrx>(routerBase); test(router); communicator->setDefaultRouter(router); cout << "ok" << endl; - Glacier2::SessionPrx sessionBase = router->createSession("userid", "abc123"); - Test::TestSessionPrx currentSession = Test::TestSessionPrx::checkedCast(sessionBase); + auto sessionBase = router->createSession("userid", "abc123"); + auto currentSession = checkedCast<Test::TestSessionPrx>(sessionBase); bool printOk = false; - while(currentState.code == Running) + while(currentState.code == StateCode::Running) { controller->step(currentSession, currentState, newState); currentState = newState; - if(currentState.code != Running) + if(currentState.code != StateCode::Running) { cout << "ok" << endl; break; @@ -92,7 +92,7 @@ SessionControlClient::run(int argc, char** argv) if(currentState.expectedResult) { - BackendPrx prx = BackendPrx::uncheckedCast(communicator->stringToProxy(currentState.testReference)); + auto prx = uncheckedCast<BackendPrx>(communicator->stringToProxy(currentState.testReference)); try { prx->check(); @@ -105,7 +105,7 @@ SessionControlClient::run(int argc, char** argv) } else { - BackendPrx prx = BackendPrx::uncheckedCast(communicator->stringToProxy(currentState.testReference)); + auto prx = uncheckedCast<BackendPrx>(communicator->stringToProxy(currentState.testReference)); try { prx->check(); @@ -134,7 +134,7 @@ SessionControlClient::run(int argc, char** argv) // // Shut down the test server. // - currentSession = Test::TestSessionPrx::uncheckedCast(router->createSession("userid", "abc123")); + currentSession = uncheckedCast<Test::TestSessionPrx>(router->createSession("userid", "abc123")); currentSession->shutdown(); } catch(const Glacier2::CannotCreateSessionException& ex) @@ -147,8 +147,8 @@ SessionControlClient::run(int argc, char** argv) // Shut down the router. // communicator->setDefaultRouter(0); - ObjectPrx processBase = communicator->stringToProxy("Glacier2/admin -f Process:" + getTestEndpoint(51)); - Ice::ProcessPrx process = Ice::ProcessPrx::checkedCast(processBase); + auto processBase = communicator->stringToProxy("Glacier2/admin -f Process:" + getTestEndpoint(51)); + auto process = checkedCast<Ice::ProcessPrx>(processBase); test(process); process->shutdown(); try diff --git a/cpp/test/Glacier2/dynamicFiltering/Server.cpp b/cpp/test/Glacier2/dynamicFiltering/Server.cpp index 02781f7e8b9..edecd49ab05 100644 --- a/cpp/test/Glacier2/dynamicFiltering/Server.cpp +++ b/cpp/test/Glacier2/dynamicFiltering/Server.cpp @@ -19,99 +19,78 @@ using namespace Test; // simplicity, we essentially 'alias' all possible requests to a single // object adapter and a single servant. // -class ServerLocatorRegistry : public virtual LocatorRegistry +class ServerLocatorRegistry final : public LocatorRegistry { public: - virtual void - setAdapterDirectProxy_async(const AMD_LocatorRegistry_setAdapterDirectProxyPtr& cb, const string&, - const ObjectPrx&, const Current&) + void + setAdapterDirectProxyAsync(string, shared_ptr<ObjectPrx>, function<void()> response, + function<void(exception_ptr)>, const Current&) override { - cb->ice_response(); + response(); } - virtual void - setReplicatedAdapterDirectProxy_async(const AMD_LocatorRegistry_setReplicatedAdapterDirectProxyPtr& cb, - const string&, const string&, const ObjectPrx&, const Current&) + void + setReplicatedAdapterDirectProxyAsync(string, string, shared_ptr<ObjectPrx>, + function<void()> response, function<void(exception_ptr)>, + const Current&) override { - cb->ice_response(); + response(); } - virtual void - setServerProcessProxy_async(const AMD_LocatorRegistry_setServerProcessProxyPtr& cb, - const string&, const ProcessPrx&, const Current&) + void + setServerProcessProxyAsync(string, shared_ptr<ProcessPrx>, + function<void()> response, function<void(exception_ptr)>, + const Current&) override { - cb->ice_response(); + response(); } }; -class ServerLocatorI : public virtual Locator +class ServerLocatorI final : public Locator { public: - ServerLocatorI(BackendPtr backend, ObjectAdapterPtr adapter) : - _backend(backend), - _adapter(adapter) + ServerLocatorI(shared_ptr<Backend> backend, shared_ptr<ObjectAdapter> adapter) : + _backend(move(backend)), + _adapter(move(adapter)) { - _registryPrx = LocatorRegistryPrx::uncheckedCast(adapter->add(new ServerLocatorRegistry, - Ice::stringToIdentity("registry"))); + _registryPrx = uncheckedCast<LocatorRegistryPrx>(_adapter->add(make_shared<ServerLocatorRegistry>(), + Ice::stringToIdentity("registry"))); } - virtual void - findObjectById_async(const AMD_Locator_findObjectByIdPtr& cb, const Identity& id, const Current&) const + void + findObjectByIdAsync(Identity id, + function<void(const shared_ptr<ObjectPrx>&)> response, function<void(exception_ptr)>, + const Current&) const override { - cb->ice_response(_adapter->createProxy(id)); + response(_adapter->createProxy(id)); } - virtual void - findAdapterById_async(const AMD_Locator_findAdapterByIdPtr& cb, const string&, const Current&) const + void + findAdapterByIdAsync(string, + function<void(const shared_ptr<ObjectPrx>&)> response, function<void(exception_ptr)>, + const Current&) const override { - cb->ice_response(_adapter->createDirectProxy(stringToIdentity("dummy"))); + response(_adapter->createDirectProxy(stringToIdentity("dummy"))); } - virtual LocatorRegistryPrx - getRegistry(const Current&) const + shared_ptr<LocatorRegistryPrx> + getRegistry(const Current&) const override { return _registryPrx; } private: - BackendPtr _backend; - ObjectAdapterPtr _adapter; - LocatorRegistryPrx _registryPrx; + shared_ptr<Backend> _backend; + shared_ptr<ObjectAdapter> _adapter; + shared_ptr<LocatorRegistryPrx> _registryPrx; }; -class ServantLocatorI : public virtual ServantLocator +class SessionControlServer final : public Test::TestHelper { public: - ServantLocatorI(const BackendPtr& backend) : - _backend(backend) - { - } - - virtual ObjectPtr locate(const Current&, LocalObjectPtr&) - { - return _backend; - } - - virtual void finished(const Current&, const ObjectPtr&, const LocalObjectPtr&) - { - } - - virtual void deactivate(const string&) - { - } - -private: - - BackendPtr _backend; -}; - -class SessionControlServer : public Test::TestHelper -{ -public: - - void run(int, char**); + void run(int, char**) override; }; void @@ -130,23 +109,23 @@ SessionControlServer::run(int argc, char** argv) // expects to use a proxy for the correct type of object. // communicator->getProperties()->setProperty("TestControllerAdapter.Endpoints", getTestEndpoint(2, "tcp")); - ObjectAdapterPtr controllerAdapter = communicator->createObjectAdapter("TestControllerAdapter"); - TestControllerIPtr controller = new TestControllerI(getTestEndpoint(1)); + auto controllerAdapter = communicator->createObjectAdapter("TestControllerAdapter"); + auto controller = make_shared<TestControllerI>(getTestEndpoint(1)); controllerAdapter->add(controller, Ice::stringToIdentity("testController")); controllerAdapter->activate(); communicator->getProperties()->setProperty("SessionControlAdapter.Endpoints", getTestEndpoint()); - ObjectAdapterPtr adapter = communicator->createObjectAdapter("SessionControlAdapter"); - adapter->add(new SessionManagerI(controller), Ice::stringToIdentity("SessionManager")); + auto adapter = communicator->createObjectAdapter("SessionControlAdapter"); + adapter->add(make_shared<SessionManagerI>(controller), Ice::stringToIdentity("SessionManager")); adapter->activate(); - BackendPtr backend = new BackendI; + auto backend = make_shared<BackendI>(); communicator->getProperties()->setProperty("BackendAdapter.Endpoints", getTestEndpoint(1)); - ObjectAdapterPtr backendAdapter = communicator->createObjectAdapter("BackendAdapter"); - backendAdapter->addServantLocator(new ServantLocatorI(backend), ""); + auto backendAdapter = communicator->createObjectAdapter("BackendAdapter"); + backendAdapter->addDefaultServant(backend, ""); backendAdapter->activate(); - Ice::LocatorPtr locator = new ServerLocatorI(backend, backendAdapter); + auto locator = make_shared<ServerLocatorI>(backend, backendAdapter); backendAdapter->add(locator, Ice::stringToIdentity("locator")); communicator->waitForShutdown(); diff --git a/cpp/test/Glacier2/dynamicFiltering/SessionI.cpp b/cpp/test/Glacier2/dynamicFiltering/SessionI.cpp index af7f4f04428..7da0dbd270b 100644 --- a/cpp/test/Glacier2/dynamicFiltering/SessionI.cpp +++ b/cpp/test/Glacier2/dynamicFiltering/SessionI.cpp @@ -8,31 +8,26 @@ using namespace std; using namespace Test; -SessionManagerI::SessionManagerI(const TestControllerIPtr& controller): +SessionManagerI::SessionManagerI(const shared_ptr<TestControllerI>& controller): _controller(controller) { } -Glacier2::SessionPrx -SessionManagerI::create(const string&, const Glacier2::SessionControlPrx& sessionControl, const Ice::Current& current) +shared_ptr<Glacier2::SessionPrx> +SessionManagerI::create(string, shared_ptr<Glacier2::SessionControlPrx> sessionControl, const Ice::Current& current) { - Glacier2::SessionPrx newSession = Glacier2::SessionPrx::uncheckedCast( - current.adapter->addWithUUID(new SessionI(sessionControl, _controller))); - _controller->addSession(SessionTuple(newSession, sessionControl)); + auto newSession = Ice::uncheckedCast<Glacier2::SessionPrx>( + current.adapter->addWithUUID(make_shared<SessionI>(sessionControl, _controller))); + _controller->addSession(SessionTuple(newSession, move(sessionControl))); return newSession; } -SessionI::SessionI(const Glacier2::SessionControlPrx& sessionControl, const TestControllerIPtr& controller) : - _sessionControl(sessionControl), - _controller(controller) -{ - assert(sessionControl); -} - -void -SessionI::destroySession(const Ice::Current&) +SessionI::SessionI(shared_ptr<Glacier2::SessionControlPrx> sessionControl, + shared_ptr<TestControllerI> controller) : + _sessionControl(move(sessionControl)), + _controller(move(controller)) { - _sessionControl->destroy(); + assert(_sessionControl); } void diff --git a/cpp/test/Glacier2/dynamicFiltering/SessionI.h b/cpp/test/Glacier2/dynamicFiltering/SessionI.h index 0e5ba644553..d204e0a4f45 100644 --- a/cpp/test/Glacier2/dynamicFiltering/SessionI.h +++ b/cpp/test/Glacier2/dynamicFiltering/SessionI.h @@ -17,31 +17,30 @@ // reason why not as long as there isn't a deadlock situation. // -class SessionManagerI : public Glacier2::SessionManager +class SessionManagerI final : public Glacier2::SessionManager { public: - SessionManagerI(const TestControllerIPtr&); + SessionManagerI(const std::shared_ptr<TestControllerI>&); - virtual Glacier2::SessionPrx create(const std::string&, const Glacier2::SessionControlPrx&, const Ice::Current&); + std::shared_ptr<Glacier2::SessionPrx> + create(std::string, std::shared_ptr<Glacier2::SessionControlPrx>, const Ice::Current&) override; private: - TestControllerIPtr _controller; + std::shared_ptr<TestControllerI> _controller; }; -class SessionI : public Test::TestSession +class SessionI final : public Test::TestSession { public: - SessionI(const Glacier2::SessionControlPrx&, const TestControllerIPtr&); - virtual void destroySession(const Ice::Current&); - virtual void shutdown(const Ice::Current&); - - virtual void destroy(const Ice::Current&); + SessionI(std::shared_ptr<Glacier2::SessionControlPrx>, std::shared_ptr<TestControllerI>); + void shutdown(const Ice::Current&) override; + void destroy(const Ice::Current&) override; private: - Glacier2::SessionControlPrx _sessionControl; - TestControllerIPtr _controller; + std::shared_ptr<Glacier2::SessionControlPrx> _sessionControl; + std::shared_ptr<TestControllerI> _controller; }; #endif diff --git a/cpp/test/Glacier2/dynamicFiltering/TestControllerI.cpp b/cpp/test/Glacier2/dynamicFiltering/TestControllerI.cpp index 35f1876fd1a..f395e08975c 100644 --- a/cpp/test/Glacier2/dynamicFiltering/TestControllerI.cpp +++ b/cpp/test/Glacier2/dynamicFiltering/TestControllerI.cpp @@ -52,36 +52,35 @@ TestControllerI::TestControllerI(const string& endpoint) }; void -TestControllerI::step(const Glacier2::SessionPrx& currentSession, const TestToken& currentState, TestToken& newState, +TestControllerI::step(shared_ptr<Glacier2::SessionPrx> currentSession, TestToken currentState, TestToken& newState, const Ice::Current&) { switch(currentState.code) { - case Test::Finished: + case Test::StateCode::Finished: { assert(false); break; } - case Test::Running: + case Test::StateCode::Running: { TestConfiguration& config = _configurations[static_cast<size_t>(currentState.config)]; assert(!config.description.empty()); bool found = false; SessionTuple session; + for(const auto& p : _sessions) { - IceUtil::Mutex::Lock sync(_mutex); - for(vector<SessionTuple>::const_iterator i = _sessions.begin(); i != _sessions.end() && !found; ++i) + if(targetEqualTo(p.session, currentSession)) { - if(i->session == currentSession) - { - session = *i; - found = true; - } + session = p; + found = true; + break; } } - assert(found); + + test(found); // // New sessions force configuration step. @@ -103,7 +102,7 @@ TestControllerI::step(const Glacier2::SessionPrx& currentSession, const TestToke ++newState.config; if(!(newState.config < (long)_configurations.size())) { - newState.code = Test::Finished; + newState.code = Test::StateCode::Finished; newState.expectedResult = false; newState.description = "No more tests"; newState.testReference = ""; @@ -126,13 +125,13 @@ TestControllerI::step(const Glacier2::SessionPrx& currentSession, const TestToke if(reconfigure) { - Glacier2::StringSetPrx categories = session.sessionControl->categories(); + auto categories = session.sessionControl->categories(); categories->add(config.categoryFiltersAccept); - Glacier2::StringSetPrx adapterIds = session.sessionControl->adapterIds(); + auto adapterIds = session.sessionControl->adapterIds(); adapterIds->add(config.adapterIdFiltersAccept); - Glacier2::IdentitySetPrx ids = session.sessionControl->identities(); + auto ids = session.sessionControl->identities(); ids->add(config.objectIdFiltersAccept); session.configured = true; } @@ -141,7 +140,7 @@ TestControllerI::step(const Glacier2::SessionPrx& currentSession, const TestToke default: { - newState.code = Running; + newState.code = Test::StateCode::Running; newState.config = 0; newState.caseIndex = 0; newState.testReference = ""; @@ -159,19 +158,17 @@ TestControllerI::shutdown(const Ice::Current& current) } void -TestControllerI::addSession(const SessionTuple& s) +TestControllerI::addSession(SessionTuple&& s) { - IceUtil::Mutex::Lock sync(_mutex); - _sessions.push_back(s); + _sessions.emplace_back(move(s)); } void -TestControllerI::notifyDestroy(const Glacier2::SessionControlPrx& control) +TestControllerI::notifyDestroy(const shared_ptr<Glacier2::SessionControlPrx>& control) { - IceUtil::Mutex::Lock sync(_mutex); - for (vector<SessionTuple>::iterator i = _sessions.begin(); i != _sessions.end(); ++i) + for(auto i = _sessions.begin(); i != _sessions.end(); ++i) { - if(i->sessionControl == control) + if(targetEqualTo(i->sessionControl, control)) { _sessions.erase(i); break; diff --git a/cpp/test/Glacier2/dynamicFiltering/TestControllerI.h b/cpp/test/Glacier2/dynamicFiltering/TestControllerI.h index 7b4e62be61e..0d4f8b287d8 100644 --- a/cpp/test/Glacier2/dynamicFiltering/TestControllerI.h +++ b/cpp/test/Glacier2/dynamicFiltering/TestControllerI.h @@ -5,8 +5,6 @@ #ifndef TEST_CONTROLLER_H #define TEST_CONTROLLER_H -#include <IceUtil/Shared.h> -#include <IceUtil/Mutex.h> #include <Glacier2/Session.h> #include <Test.h> #include <vector> @@ -14,30 +12,21 @@ struct SessionTuple { - Glacier2::SessionPrx session; - Glacier2::SessionControlPrx sessionControl; - bool configured; - - SessionTuple() {} - SessionTuple(Glacier2::SessionPrx s, Glacier2::SessionControlPrx control): - session(s), - sessionControl(control), + std::shared_ptr<Glacier2::SessionPrx> session; + std::shared_ptr<Glacier2::SessionControlPrx> sessionControl; + bool configured = false; + + SessionTuple() = default; + SessionTuple(std::shared_ptr<Glacier2::SessionPrx> s, std::shared_ptr<Glacier2::SessionControlPrx> control): + session(move(s)), + sessionControl(move(control)), configured(false) - {} - - SessionTuple& - operator=(const SessionTuple& rhs) { - if(this == &rhs) - { - return *this; - } - - session = rhs.session; - sessionControl = rhs.sessionControl; - configured = rhs.configured; - return *this; } + + SessionTuple(const SessionTuple&) = delete; + SessionTuple& operator=(const SessionTuple&) = default; + SessionTuple(SessionTuple&&) = default; }; /* @@ -66,33 +55,27 @@ struct TestConfiguration // configuration of the test's session and provides the client with test // cases and expected outcomes. // -class TestControllerI : public Test::TestController +class TestControllerI final : public Test::TestController { public: TestControllerI(const std::string&); - // - // Slice to C++ mapping. - // - void step(const Glacier2::SessionPrx& currentSession, const Test::TestToken& currentState, - Test::TestToken& newState, const Ice::Current&); - void shutdown(const Ice::Current&); + void step(std::shared_ptr<Glacier2::SessionPrx> currentSession, Test::TestToken currentState, + Test::TestToken& newState, const Ice::Current&) override; + + void shutdown(const Ice::Current&) override; // // Internal methods. // - void addSession(const SessionTuple&); + void addSession(SessionTuple&&); - void notifyDestroy(const Glacier2::SessionControlPrx&); + void notifyDestroy(const std::shared_ptr<Glacier2::SessionControlPrx>&); private: - - IceUtil::Mutex _mutex; std::vector<SessionTuple> _sessions; std::vector<TestConfiguration> _configurations; }; -typedef IceUtil::Handle<TestControllerI> TestControllerIPtr; - #endif diff --git a/cpp/test/Glacier2/override/CallbackI.cpp b/cpp/test/Glacier2/override/CallbackI.cpp index 53968ee4bea..cce132802bf 100644 --- a/cpp/test/Glacier2/override/CallbackI.cpp +++ b/cpp/test/Glacier2/override/CallbackI.cpp @@ -10,103 +10,41 @@ using namespace std; using namespace Ice; using namespace Test; -class Cookie : public Ice::LocalObject -{ -}; -typedef IceUtil::Handle<Cookie> CookiePtr; - -template<class T> -class CookieT : public Cookie -{ -public: - - CookieT(const T& v) : cb(v) - { - } - - T cb; -}; - -template<typename T> CookiePtr newCookie(const T& cb) -{ - return new CookieT<T>(cb); -} - -template<typename T> const T& getCookie(const CookiePtr& cookie) -{ - return dynamic_cast<CookieT<T>* >(cookie.get())->cb; -} - -class AsyncCB : public IceUtil::Shared -{ -public: - - void - responseCallback(const CookiePtr& cookie) - { - getCookie<AMD_Callback_initiateCallbackPtr>(cookie)->ice_response(); - } - - void - exceptionCallback(const Ice::Exception& ex, const CookiePtr& cookie) - { - getCookie<AMD_Callback_initiateCallbackPtr>(cookie)->ice_exception(ex); - } - - void - responseCallbackWithPayload(const CookiePtr& cookie) - { - getCookie<AMD_Callback_initiateCallbackWithPayloadPtr>(cookie)->ice_response(); - } - - void - exceptionCallbackWithPayload(const Ice::Exception& ex, const CookiePtr& cookie) - { - getCookie<AMD_Callback_initiateCallbackWithPayloadPtr>(cookie)->ice_exception(ex); - } -}; -typedef IceUtil::Handle<AsyncCB> AsyncCBPtr; - -CallbackReceiverI::CallbackReceiverI() : - _holding(false), - _lastToken(-1), - _callback(0), - _callbackWithPayload(0) -{ -} - void CallbackReceiverI::callback(int token, const Current&) { - Lock sync(*this); - checkForHold(); - - if(token != _lastToken) { - _callback = 0; - _lastToken = token; + unique_lock<mutex> lock(_mutex); + checkForHold(lock); + if(token != _lastToken) + { + _callback = 0; + _lastToken = token; + } + ++_callback; } - ++_callback; - notifyAll(); + _condVar.notify_all(); } void -CallbackReceiverI::callbackWithPayload(const Ice::ByteSeq&, const Current&) +CallbackReceiverI::callbackWithPayload(Ice::ByteSeq, const Current&) { - Lock sync(*this); - checkForHold(); - ++_callbackWithPayload; - notifyAll(); + { + unique_lock<mutex> lock(_mutex); + checkForHold(lock); + ++_callbackWithPayload; + } + _condVar.notify_all(); } int CallbackReceiverI::callbackOK(int count, int token) { - Lock sync(*this); + unique_lock<mutex> lock(_mutex); while(_lastToken != token || _callback < count) { - wait(); + _condVar.wait(lock); } _callback -= count; @@ -116,11 +54,11 @@ CallbackReceiverI::callbackOK(int count, int token) int CallbackReceiverI::callbackWithPayloadOK(int count) { - Lock sync(*this); + unique_lock<mutex> lock(_mutex); while(_callbackWithPayload < count) { - wait(); + _condVar.wait(lock); } _callbackWithPayload -= count; @@ -130,37 +68,36 @@ CallbackReceiverI::callbackWithPayloadOK(int count) void CallbackReceiverI::hold() { - Lock sync(*this); + lock_guard<mutex> lg(_mutex); _holding = true; } void CallbackReceiverI::activate() { - Lock sync(*this); - _holding = false; - notifyAll(); + { + lock_guard<mutex> lg(_mutex); + _holding = false; + } + _condVar.notify_all(); } void -CallbackReceiverI::checkForHold() +CallbackReceiverI::checkForHold(unique_lock<mutex>& lock) { while(_holding) { - wait(); + _condVar.wait(lock); } } -CallbackI::CallbackI() -{ -} - void -CallbackI::initiateCallback_async(const AMD_Callback_initiateCallbackPtr& cb, - const CallbackReceiverPrx& proxy, int token, const Current& current) +CallbackI::initiateCallbackAsync(shared_ptr<CallbackReceiverPrx> proxy, int token, + function<void()> response, function<void(exception_ptr)> error, + const Current& current) { - Ice::Context::const_iterator p = current.ctx.find("serverOvrd"); - Ice::Context ctx = current.ctx; + auto p = current.ctx.find("serverOvrd"); + auto ctx = current.ctx; if(p != current.ctx.end()) { ctx["_ovrd"] = p->second; @@ -168,25 +105,22 @@ CallbackI::initiateCallback_async(const AMD_Callback_initiateCallbackPtr& cb, if(proxy->ice_isTwoway()) { - AsyncCBPtr acb = new AsyncCB(); - proxy->begin_callback(token, ctx, - newCallback_CallbackReceiver_callback(acb, &AsyncCB::responseCallback, &AsyncCB::exceptionCallback), - newCookie(cb)); + proxy->callbackAsync(token, move(response), move(error), nullptr, ctx); } else { proxy->callback(token, ctx); - cb->ice_response(); + response(); } } void -CallbackI::initiateCallbackWithPayload_async(const AMD_Callback_initiateCallbackWithPayloadPtr& cb, - const CallbackReceiverPrx& proxy, - const Current& current) +CallbackI::initiateCallbackWithPayloadAsync(shared_ptr<CallbackReceiverPrx> proxy, + function<void()> response, function<void(exception_ptr)> error, + const Current& current) { - Ice::Context::const_iterator p = current.ctx.find("serverOvrd"); - Ice::Context ctx = current.ctx; + auto p = current.ctx.find("serverOvrd"); + auto ctx = current.ctx; if(p != current.ctx.end()) { ctx["_ovrd"] = p->second; @@ -195,18 +129,12 @@ CallbackI::initiateCallbackWithPayload_async(const AMD_Callback_initiateCallback Ice::ByteSeq seq(1000 * 1024, 0); if(proxy->ice_isTwoway()) { - AsyncCBPtr acb = new AsyncCB(); - proxy->begin_callbackWithPayload(seq, ctx, - newCallback_CallbackReceiver_callbackWithPayload( - acb, - &AsyncCB::responseCallbackWithPayload, - &AsyncCB::exceptionCallbackWithPayload), - newCookie(cb)); + proxy->callbackWithPayloadAsync(seq, move(response), move(error), nullptr, ctx); } else { proxy->callbackWithPayload(seq, ctx); - cb->ice_response(); + response(); } } diff --git a/cpp/test/Glacier2/override/CallbackI.h b/cpp/test/Glacier2/override/CallbackI.h index 2dbfac8750b..2b2fe7bc7c4 100644 --- a/cpp/test/Glacier2/override/CallbackI.h +++ b/cpp/test/Glacier2/override/CallbackI.h @@ -5,19 +5,15 @@ #ifndef CALLBACK_I_H #define CALLBACK_I_H -#include <IceUtil/Mutex.h> -#include <IceUtil/Monitor.h> #include <Callback.h> #include <vector> -class CallbackReceiverI : public ::Test::CallbackReceiver, public IceUtil::Monitor<IceUtil::Mutex> +class CallbackReceiverI final : public Test::CallbackReceiver { public: - CallbackReceiverI(); - - virtual void callback(int token, const Ice::Current&); - virtual void callbackWithPayload(const Ice::ByteSeq&, const ::Ice::Current&); + void callback(int token, const Ice::Current&) override; + void callbackWithPayload(Ice::ByteSeq, const ::Ice::Current&) override; int callbackOK(int, int); int callbackWithPayloadOK(int); @@ -27,28 +23,29 @@ public: private: - void checkForHold(); + void checkForHold(std::unique_lock<std::mutex>&); + + bool _holding = false; - bool _holding; + int _lastToken = -1; + int _callback = 0; + int _callbackWithPayload = 0; - int _lastToken; - int _callback; - int _callbackWithPayload; + std::mutex _mutex; + std::condition_variable _condVar; }; -typedef IceUtil::Handle<CallbackReceiverI> CallbackReceiverIPtr; -class CallbackI : public ::Test::Callback +class CallbackI final : public Test::Callback { public: - CallbackI(); - - virtual void initiateCallback_async(const ::Test::AMD_Callback_initiateCallbackPtr&, - const ::Test::CallbackReceiverPrx&, int, const Ice::Current&); - virtual void initiateCallbackWithPayload_async(const ::Test::AMD_Callback_initiateCallbackWithPayloadPtr&, - const ::Test::CallbackReceiverPrx&, - const ::Ice::Current&); - virtual void shutdown(const Ice::Current&); + void initiateCallbackAsync(std::shared_ptr<Test::CallbackReceiverPrx>, int, + std::function<void()>, std::function<void(std::exception_ptr)>, + const Ice::Current&) override; + void initiateCallbackWithPayloadAsync(std::shared_ptr<Test::CallbackReceiverPrx>, + std::function<void()>, std::function<void(std::exception_ptr)>, + const ::Ice::Current&) override; + void shutdown(const Ice::Current&) override; }; #endif diff --git a/cpp/test/Glacier2/override/Client.cpp b/cpp/test/Glacier2/override/Client.cpp index 1b8d5833b36..7483d000ae4 100644 --- a/cpp/test/Glacier2/override/Client.cpp +++ b/cpp/test/Glacier2/override/Client.cpp @@ -2,58 +2,59 @@ // Copyright (c) ZeroC, Inc. All rights reserved. // -#include <IceUtil/IceUtil.h> #include <Ice/Ice.h> #include <Glacier2/Router.h> #include <TestHelper.h> #include <CallbackI.h> +#include <chrono> using namespace std; +using namespace std::chrono_literals; + using namespace Ice; using namespace Test; -class CallbackClient : public Test::TestHelper +class CallbackClient final : public Test::TestHelper { public: - void run(int, char**); + void run(int, char**) override; }; void CallbackClient::run(int argc, char** argv) { - Ice::PropertiesPtr properties = createTestProperties(argc, argv); + auto 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); + auto routerBase = communicator->stringToProxy("Glacier2/router:" + getTestEndpoint(50)); + auto router = checkedCast<Glacier2::RouterPrx>(routerBase); communicator->setDefaultRouter(router); - ObjectPrx base = communicator->stringToProxy("c/callback:" + getTestEndpoint()); - Glacier2::SessionPrx session = router->createSession("userid", "abc123"); + auto base = communicator->stringToProxy("c/callback:" + getTestEndpoint()); + auto session = router->createSession("userid", "abc123"); base->ice_ping(); - CallbackPrx twoway = CallbackPrx::checkedCast(base); - CallbackPrx oneway = twoway->ice_oneway(); - CallbackPrx batchOneway = twoway->ice_batchOneway(); + auto twoway = checkedCast<CallbackPrx>(base); + auto oneway = twoway->ice_oneway(); + auto batchOneway = twoway->ice_batchOneway(); communicator->getProperties()->setProperty("Ice.PrintAdapterReady", "0"); - ObjectAdapterPtr adapter = communicator->createObjectAdapterWithRouter("CallbackReceiverAdapter", router); + auto adapter = communicator->createObjectAdapterWithRouter("CallbackReceiverAdapter", router); adapter->activate(); string category = router->getCategoryForClient(); - CallbackReceiverI* callbackReceiverImpl = new CallbackReceiverI; - ObjectPtr callbackReceiver = callbackReceiverImpl; + auto callbackReceiver = make_shared<CallbackReceiverI>(); Identity callbackReceiverIdent; callbackReceiverIdent.name = "callbackReceiver"; callbackReceiverIdent.category = category; - CallbackReceiverPrx twowayR = - CallbackReceiverPrx::uncheckedCast(adapter->add(callbackReceiver, callbackReceiverIdent)); - CallbackReceiverPrx onewayR = twowayR->ice_oneway(); + auto twowayR = + uncheckedCast<CallbackReceiverPrx>(adapter->add(callbackReceiver, callbackReceiverIdent)); + auto onewayR = twowayR->ice_oneway(); { cout << "testing client request override... " << flush; @@ -62,7 +63,7 @@ CallbackClient::run(int argc, char** argv) { oneway->initiateCallback(twowayR, 0); oneway->initiateCallback(twowayR, 0); - callbackReceiverImpl->callbackOK(2, 0); + callbackReceiver->callbackOK(2, 0); } } @@ -74,8 +75,8 @@ CallbackClient::run(int argc, char** argv) 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); + this_thread::sleep_for(100ms); + test(callbackReceiver->callbackOK(1, i) < 3); } } cout << "ok" << endl; @@ -90,17 +91,17 @@ CallbackClient::run(int argc, char** argv) 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); + this_thread::sleep_for(100ms); + test(callbackReceiver->callbackOK(1, i) < 3); } oneway->initiateCallback(twowayR, 0); - test(callbackReceiverImpl->callbackOK(1, 0) == 0); + test(callbackReceiver->callbackOK(1, 0) == 0); int count = 0; int nRetry = 0; do { - callbackReceiverImpl->hold(); + callbackReceiver->hold(); oneway->initiateCallbackWithPayload(onewayR, ctx); oneway->initiateCallbackWithPayload(onewayR, ctx); oneway->initiateCallbackWithPayload(onewayR, ctx); @@ -112,18 +113,18 @@ CallbackClient::run(int argc, char** argv) 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); + this_thread::sleep_for(chrono::milliseconds(200 + nRetry * 200)); + callbackReceiver->activate(); + test(callbackReceiver->callbackOK(1, 0) == 0); + count = callbackReceiver->callbackWithPayloadOK(0); + callbackReceiver->callbackWithPayloadOK(count); } while(count == 10 && nRetry++ < 10); test(count < 10); oneway->initiateCallbackWithPayload(twowayR); oneway->initiateCallbackWithPayload(twowayR); - callbackReceiverImpl->hold(); + callbackReceiver->hold(); oneway->initiateCallbackWithPayload(twowayR); oneway->initiateCallback(onewayR, 0, ctx); oneway->initiateCallback(onewayR, 0, ctx); @@ -131,11 +132,11 @@ CallbackClient::run(int argc, char** argv) 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); + this_thread::sleep_for(1000ms); + callbackReceiver->activate(); + test(callbackReceiver->callbackWithPayloadOK(4) == 0); - int remainingCallbacks = callbackReceiverImpl->callbackOK(1, 0); + int remainingCallbacks = callbackReceiver->callbackOK(1, 0); // // Occasionally, Glacier2 flushes in the middle of our 5 // callbacks, so we get more than 1 callback @@ -147,13 +148,13 @@ CallbackClient::run(int argc, char** argv) test(remainingCallbacks <= 4); if(remainingCallbacks > 0) { - test(callbackReceiverImpl->callbackOK(remainingCallbacks, 0) == 0); + test(callbackReceiver->callbackOK(remainingCallbacks, 0) == 0); } ctx["_fwd"] = "O"; oneway->initiateCallbackWithPayload(twowayR); - callbackReceiverImpl->hold(); + callbackReceiver->hold(); oneway->initiateCallbackWithPayload(twowayR); oneway->initiateCallback(onewayR, 0, ctx); oneway->initiateCallback(onewayR, 0, ctx); @@ -161,16 +162,16 @@ CallbackClient::run(int argc, char** argv) 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); + this_thread::sleep_for(200ms); + callbackReceiver->activate(); + test(callbackReceiver->callbackWithPayloadOK(3) == 0); + remainingCallbacks = callbackReceiver->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); + test(callbackReceiver->callbackOK(remainingCallbacks, 0) == 0); } cout << "ok" << endl; @@ -190,8 +191,8 @@ CallbackClient::run(int argc, char** argv) } communicator->setDefaultRouter(0); - ObjectPrx processBase = communicator->stringToProxy("Glacier2/admin -f Process:" + getTestEndpoint(51)); - Ice::ProcessPrx process = Ice::ProcessPrx::checkedCast(processBase); + auto processBase = communicator->stringToProxy("Glacier2/admin -f Process:" + getTestEndpoint(51)); + auto process = checkedCast<Ice::ProcessPrx>(processBase); process->shutdown(); try { diff --git a/cpp/test/Glacier2/override/Server.cpp b/cpp/test/Glacier2/override/Server.cpp index 61df40c3658..85c4ba60c82 100644 --- a/cpp/test/Glacier2/override/Server.cpp +++ b/cpp/test/Glacier2/override/Server.cpp @@ -10,25 +10,25 @@ using namespace std; using namespace Ice; using namespace Test; -class CallbackServer : public Test::TestHelper +class CallbackServer final : public Test::TestHelper { public: - void run(int, char**); + void run(int, char**) override; }; void CallbackServer::run(int argc, char** argv) { - Ice::PropertiesPtr properties = createTestProperties(argc, argv); + auto properties = createTestProperties(argc, argv); properties->setProperty("Ice.Warn.Connections", "0"); properties->setProperty("Ice.Warn.Dispatch", "0"); properties->setProperty("Ice.ThreadPool.Server.Serialize", "1"); Ice::CommunicatorHolder communicator = initialize(argc, argv, properties); communicator->getProperties()->setProperty("CallbackAdapter.Endpoints", getTestEndpoint()); - ObjectAdapterPtr adapter = communicator->createObjectAdapter("CallbackAdapter"); - adapter->add(new CallbackI(), Ice::stringToIdentity("c/callback")); + auto adapter = communicator->createObjectAdapter("CallbackAdapter"); + adapter->add(make_shared<CallbackI>(), Ice::stringToIdentity("c/callback")); adapter->activate(); communicator->waitForShutdown(); } diff --git a/cpp/test/Glacier2/router/CallbackI.cpp b/cpp/test/Glacier2/router/CallbackI.cpp index 920a611c266..b61956111d3 100644 --- a/cpp/test/Glacier2/router/CallbackI.cpp +++ b/cpp/test/Glacier2/router/CallbackI.cpp @@ -7,116 +7,19 @@ #include <TestHelper.h> using namespace std; +using namespace std::chrono_literals; + using namespace Ice; using namespace Test; -class Cookie : public Ice::LocalObject -{ -}; -typedef IceUtil::Handle<Cookie> CookiePtr; - -template<class T> -class CookieT : public Cookie -{ -public: - - CookieT(const T& v) : cb(v) - { - } - - T cb; -}; - -template<typename T> CookiePtr newCookie(const T& cb) -{ - return new CookieT<T>(cb); -} - -template<typename T> const T& getCookie(const CookiePtr& cookie) -{ - return dynamic_cast<CookieT<T>* >(cookie.get())->cb; -} - -class AsyncCB : public IceUtil::Shared -{ -public: - - void - responseCallback(const CookiePtr& cookie) - { - getCookie<AMD_Callback_initiateCallbackPtr>(cookie)->ice_response(); - } - - void - exceptionCallback(const Ice::Exception& ex, const CookiePtr& cookie) - { - getCookie<AMD_Callback_initiateCallbackPtr>(cookie)->ice_exception(ex); - } - - void - responseCallbackEx(const CookiePtr& cookie) - { - getCookie<AMD_Callback_initiateCallbackExPtr>(cookie)->ice_response(); - } - - void - exceptionCallbackEx(const Ice::Exception& ex, const CookiePtr& cookie) - { - getCookie<AMD_Callback_initiateCallbackExPtr>(cookie)->ice_exception(ex); - } - - void - responseConcurrentCallback(Int number, const CookiePtr& cookie) - { - getCookie<AMD_Callback_initiateConcurrentCallbackPtr>(cookie)->ice_response(number); - } - - void - exceptionConcurrentCallback(const Ice::Exception& ex, const CookiePtr& cookie) - { - getCookie<AMD_Callback_initiateConcurrentCallbackPtr>(cookie)->ice_exception(ex); - } - - void - responseWaitCallback(const CookiePtr& cookie) - { - getCookie<AMD_Callback_initiateWaitCallbackPtr>(cookie)->ice_response(); - } - - void - exceptionWaitCallback(const Ice::Exception& ex, const CookiePtr& cookie) - { - getCookie<AMD_Callback_initiateWaitCallbackPtr>(cookie)->ice_exception(ex); - } - - void - responseCallbackWithPayload(const CookiePtr& cookie) - { - getCookie<AMD_Callback_initiateCallbackWithPayloadPtr>(cookie)->ice_response(); - } - - void - exceptionCallbackWithPayload(const Ice::Exception& ex, const CookiePtr& cookie) - { - getCookie<AMD_Callback_initiateCallbackWithPayloadPtr>(cookie)->ice_exception(ex); - } -}; -typedef IceUtil::Handle<AsyncCB> AsyncCBPtr; - -CallbackReceiverI::CallbackReceiverI() : - _callback(0), - _waitCallback(false), - _callbackWithPayload(false), - _finishWaitCallback(false) -{ -} - void CallbackReceiverI::callback(const Current&) { - Lock sync(*this); - ++_callback; - notifyAll(); + { + lock_guard<mutex> lg(_mutex); + ++_callback; + } + _condVar.notify_all(); } void @@ -130,56 +33,54 @@ CallbackReceiverI::callbackEx(const Current& current) } void -CallbackReceiverI::concurrentCallback_async(const AMD_CallbackReceiver_concurrentCallbackPtr& cb, - Int number, - const Current&) +CallbackReceiverI::concurrentCallbackAsync(int number, function<void(int)> response, + function<void(exception_ptr)> error, + const Current&) { - Lock sync(*this); - - pair<AMD_CallbackReceiver_concurrentCallbackPtr, Int> p; - p.first = cb; - p.second = number; - _callbacks.push_back(p); - notifyAll(); + { + lock_guard<mutex> lg(_mutex); + _callbacks.emplace_back(move(response), move(error), number); + } + _condVar.notify_all(); } void CallbackReceiverI::waitCallback(const Current&) { { - Lock sync(*this); + lock_guard<mutex> lg(_mutex); assert(!_waitCallback); _waitCallback = true; - notifyAll(); } + _condVar.notify_all(); + unique_lock<mutex> lock(_mutex); + while(!_finishWaitCallback) { - Lock sync(*this); - while(!_finishWaitCallback) - { - wait(); - } - _finishWaitCallback = false; + _condVar.wait(lock); } + _finishWaitCallback = false; } void -CallbackReceiverI::callbackWithPayload(const Ice::ByteSeq&, const Current&) +CallbackReceiverI::callbackWithPayload(Ice::ByteSeq, const Current&) { - Lock sync(*this); - assert(!_callbackWithPayload); - _callbackWithPayload = true; - notifyAll(); + { + lock_guard<mutex> lg(_mutex); + assert(!_callbackWithPayload); + _callbackWithPayload = true; + } + _condVar.notify_all(); } void CallbackReceiverI::callbackOK(int expected) { - Lock sync(*this); + unique_lock<mutex> lock(_mutex); while(_callback != expected) { - wait(); + _condVar.wait(lock); } _callback = 0; } @@ -187,10 +88,10 @@ CallbackReceiverI::callbackOK(int expected) void CallbackReceiverI::waitCallbackOK() { - Lock sync(*this); + unique_lock<mutex> lock(_mutex); while(!_waitCallback) { - timedWait(IceUtil::Time::seconds(30)); + _condVar.wait_for(lock, 30s); test(_waitCallback); } @@ -200,11 +101,11 @@ CallbackReceiverI::waitCallbackOK() void CallbackReceiverI::callbackWithPayloadOK() { - Lock sync(*this); + unique_lock<mutex> lock(_mutex); while(!_callbackWithPayload) { - wait(); + _condVar.wait(lock); } _callbackWithPayload = false; @@ -213,105 +114,90 @@ CallbackReceiverI::callbackWithPayloadOK() void CallbackReceiverI::notifyWaitCallback() { - Lock sync(*this); - _finishWaitCallback = true; - notifyAll(); + { + lock_guard<mutex> lg(_mutex); + _finishWaitCallback = true; + } + _condVar.notify_all(); }; void CallbackReceiverI::answerConcurrentCallbacks(unsigned int num) { - Lock sync(*this); + unique_lock<mutex> lock(_mutex); while(_callbacks.size() != num) { - wait(); + _condVar.wait(lock); } - for(vector<pair<AMD_CallbackReceiver_concurrentCallbackPtr, Int> >::const_iterator p = _callbacks.begin(); - p != _callbacks.end(); - ++p) + for(const auto& p : _callbacks) { - p->first->ice_response(p->second); + get<0>(p)(get<2>(p)); } _callbacks.clear(); } -CallbackI::CallbackI() -{ -} - void -CallbackI::initiateCallback_async(const AMD_Callback_initiateCallbackPtr& cb, - const CallbackReceiverPrx& proxy, const Current& current) +CallbackI::initiateCallbackAsync(shared_ptr<CallbackReceiverPrx> proxy, + function<void()> response, + function<void(exception_ptr)> error, + const Current& current) { if(proxy->ice_isTwoway()) { - AsyncCBPtr acb = new AsyncCB(); - proxy->begin_callback(current.ctx, - newCallback_CallbackReceiver_callback(acb, &AsyncCB::responseCallback, &AsyncCB::exceptionCallback), - newCookie(cb)); + proxy->callbackAsync(move(response), move(error), nullptr, current.ctx); } else { proxy->callback(current.ctx); - cb->ice_response(); + response(); } } void -CallbackI::initiateCallbackEx_async(const AMD_Callback_initiateCallbackExPtr& cb, - const CallbackReceiverPrx& proxy, const Current& current) +CallbackI::initiateCallbackExAsync(shared_ptr<CallbackReceiverPrx> proxy, + function<void()> response, + function<void(exception_ptr)> error, + const Current& current) { if(proxy->ice_isTwoway()) { - AsyncCBPtr acb = new AsyncCB(); - proxy->begin_callbackEx(current.ctx, - newCallback_CallbackReceiver_callbackEx(acb, &AsyncCB::responseCallbackEx, &AsyncCB::exceptionCallbackEx), - newCookie(cb)); + proxy->callbackExAsync(move(response), move(error), nullptr, current.ctx); } else { proxy->callbackEx(current.ctx); - cb->ice_response(); + response(); } } void -CallbackI::initiateConcurrentCallback_async(const AMD_Callback_initiateConcurrentCallbackPtr& cb, - Int number, - const CallbackReceiverPrx& proxy, - const Current& current) +CallbackI::initiateConcurrentCallbackAsync(int number, shared_ptr<CallbackReceiverPrx> proxy, + function<void(int)> response, + function<void(exception_ptr)> error, + const Current& current) { - AsyncCBPtr acb = new AsyncCB(); - proxy->begin_concurrentCallback(number, current.ctx, - newCallback_CallbackReceiver_concurrentCallback(acb, &AsyncCB::responseConcurrentCallback, - &AsyncCB::exceptionConcurrentCallback), - newCookie(cb)); + proxy->concurrentCallbackAsync(number, move(response), move(error), nullptr, current.ctx); } void -CallbackI::initiateWaitCallback_async(const AMD_Callback_initiateWaitCallbackPtr& cb, - const CallbackReceiverPrx& proxy, - const Current& current) +CallbackI::initiateWaitCallbackAsync(shared_ptr<CallbackReceiverPrx> proxy, + function<void()> response, + function<void(exception_ptr)> error, + const Current& current) { - AsyncCBPtr acb = new AsyncCB(); - proxy->begin_waitCallback(current.ctx, - newCallback_CallbackReceiver_waitCallback(acb, &AsyncCB::responseWaitCallback, &AsyncCB::exceptionWaitCallback), - newCookie(cb)); + proxy->waitCallbackAsync(move(response), move(error), nullptr, current.ctx); } void -CallbackI::initiateCallbackWithPayload_async(const AMD_Callback_initiateCallbackWithPayloadPtr& cb, - const CallbackReceiverPrx& proxy, - const Current& current) +CallbackI::initiateCallbackWithPayloadAsync(shared_ptr<CallbackReceiverPrx> proxy, + function<void()> response, + function<void(exception_ptr)> error, + const Current& current) { Ice::ByteSeq seq(1000 * 1024, 0); - AsyncCBPtr acb = new AsyncCB(); - proxy->begin_callbackWithPayload(seq, current.ctx, - newCallback_CallbackReceiver_callbackWithPayload(acb, &AsyncCB::responseCallbackWithPayload, - &AsyncCB::exceptionCallbackWithPayload), - newCookie(cb)); + proxy->callbackWithPayloadAsync(seq, move(response), move(error), nullptr, current.ctx); } void diff --git a/cpp/test/Glacier2/router/CallbackI.h b/cpp/test/Glacier2/router/CallbackI.h index 31ea2c3ecd3..a8380d3fe2a 100644 --- a/cpp/test/Glacier2/router/CallbackI.h +++ b/cpp/test/Glacier2/router/CallbackI.h @@ -5,25 +5,20 @@ #ifndef CALLBACK_I_H #define CALLBACK_I_H -#include <IceUtil/Mutex.h> -#include <IceUtil/Monitor.h> #include <Callback.h> #include <vector> -class CallbackReceiverI : public ::Test::CallbackReceiver, public IceUtil::Monitor<IceUtil::Mutex> +class CallbackReceiverI final : public Test::CallbackReceiver { public: - CallbackReceiverI(); + void callback(const Ice::Current&) override; + void callbackEx(const Ice::Current&) override; + void concurrentCallbackAsync(int, std::function<void(int)>, std::function<void(std::exception_ptr)>, + const ::Ice::Current&) override; - virtual void callback(const Ice::Current&); - virtual void callbackEx(const Ice::Current&); - virtual void concurrentCallback_async(const ::Test::AMD_CallbackReceiver_concurrentCallbackPtr&, - Ice::Int, - const ::Ice::Current&); - - virtual void waitCallback(const ::Ice::Current&); - virtual void callbackWithPayload(const Ice::ByteSeq&, const ::Ice::Current&); + void waitCallback(const ::Ice::Current&) override; + void callbackWithPayload(Ice::ByteSeq, const ::Ice::Current&) override; void callbackOK(int = 1); void waitCallbackOK(); @@ -33,36 +28,41 @@ public: private: - int _callback; - bool _waitCallback; - bool _callbackWithPayload; - bool _finishWaitCallback; - std::vector<std::pair< ::Test::AMD_CallbackReceiver_concurrentCallbackPtr, Ice::Int> > _callbacks; + int _callback = 0; + bool _waitCallback = false; + bool _callbackWithPayload = false; + bool _finishWaitCallback = false; + std::vector<std::tuple<std::function<void(int)>, std::function<void(std::exception_ptr)>, int>> _callbacks; + + std::mutex _mutex; + std::condition_variable _condVar; }; -typedef IceUtil::Handle<CallbackReceiverI> CallbackReceiverIPtr; -class CallbackI : public ::Test::Callback +class CallbackI final : public ::Test::Callback { public: - CallbackI(); - - virtual void initiateCallback_async(const ::Test::AMD_Callback_initiateCallbackPtr&, - const ::Test::CallbackReceiverPrx&, const Ice::Current&); - virtual void initiateCallbackEx_async(const ::Test::AMD_Callback_initiateCallbackExPtr&, - const ::Test::CallbackReceiverPrx&, const Ice::Current&); - virtual void initiateConcurrentCallback_async(const ::Test::AMD_Callback_initiateConcurrentCallbackPtr&, - Ice::Int, - const ::Test::CallbackReceiverPrx&, - const ::Ice::Current&); - virtual void initiateWaitCallback_async(const ::Test::AMD_Callback_initiateWaitCallbackPtr&, - const ::Test::CallbackReceiverPrx&, - const ::Ice::Current&); - virtual void initiateCallbackWithPayload_async(const ::Test::AMD_Callback_initiateCallbackWithPayloadPtr&, - const ::Test::CallbackReceiverPrx&, - const ::Ice::Current&); - - virtual void shutdown(const Ice::Current&); + void initiateCallbackAsync(std::shared_ptr<Test::CallbackReceiverPrx>, + std::function<void()>, std::function<void(std::exception_ptr)>, + const Ice::Current&) override; + + void initiateCallbackExAsync(std::shared_ptr<Test::CallbackReceiverPrx>, + std::function<void()>, std::function<void(std::exception_ptr)>, + const Ice::Current&) override; + + void initiateConcurrentCallbackAsync(int, std::shared_ptr<Test::CallbackReceiverPrx>, + std::function<void(int)>, std::function<void(std::exception_ptr)>, + const Ice::Current&) override; + + void initiateWaitCallbackAsync(std::shared_ptr<Test::CallbackReceiverPrx>, + std::function<void()>, std::function<void(std::exception_ptr)>, + const Ice::Current&) override; + + void initiateCallbackWithPayloadAsync(std::shared_ptr<Test::CallbackReceiverPrx>, + std::function<void()>, std::function<void(std::exception_ptr)>, + const Ice::Current&) override; + + void shutdown(const Ice::Current&) override; }; #endif diff --git a/cpp/test/Glacier2/router/Client.cpp b/cpp/test/Glacier2/router/Client.cpp index 24d496b34f1..cd22432362f 100644 --- a/cpp/test/Glacier2/router/Client.cpp +++ b/cpp/test/Glacier2/router/Client.cpp @@ -2,113 +2,107 @@ // Copyright (c) ZeroC, Inc. All rights reserved. // -#include <IceUtil/Random.h> -#include <IceUtil/IceUtil.h> #include <Ice/Ice.h> #include <Glacier2/Router.h> #include <TestHelper.h> #include <CallbackI.h> +#include <mutex> +#include <random> using namespace std; +using namespace std::chrono_literals; using namespace Ice; using namespace Test; static Ice::InitializationData initData; -class AsyncCallback : public IceUtil::Monitor<IceUtil::Mutex>, public IceUtil::Shared +class AsyncCallback final { public: - AsyncCallback() : - _haveResponse(false) - { - } - void - response(Int response) + response(int val) { - Lock sync(*this); - _haveResponse = true; - _response = response; - notify(); + { + lock_guard<mutex> lg(_mutex); + _haveResponse = true; + _response = val; + } + _condVar.notify_one(); } void - exception(const Exception& e) + error(exception_ptr e) { - Lock sync(*this); - _haveResponse = true; - _ex.reset(e.ice_clone()); - notify(); + { + lock_guard<mutex> lg(_mutex); + _haveResponse = true; + _exception = e; + } + _condVar.notify_one(); } int - waitResponse() const + waitResponse() { - Lock sync(*this); + unique_lock<mutex> lock(_mutex); while(!_haveResponse) { - wait(); + _condVar.wait(lock); } - if(_ex.get()) + if(_exception) { - _ex->ice_throw(); + rethrow_exception(_exception); } return _response; } private: - bool _haveResponse; - IceInternal::UniquePtr<Exception> _ex; - Int _response; + bool _haveResponse = false; + exception_ptr _exception = nullptr; + int _response = -1; + mutex _mutex; + condition_variable _condVar; }; -typedef IceUtil::Handle<AsyncCallback> AsyncCallbackPtr; -class MisbehavedClient : public IceUtil::Thread, public IceUtil::Monitor<IceUtil::Mutex> +class MisbehavedClient final { public: - MisbehavedClient(int id) : _id(id), _callback(false) + explicit MisbehavedClient(int id) : _id(id) { } - virtual void run() { - CommunicatorPtr communicator = initialize(initData); - ObjectPrx routerBase = communicator->stringToProxy( + auto communicator = initialize(initData); + auto routerBase = communicator->stringToProxy( "Glacier2/router:" + TestHelper::getTestEndpoint(communicator->getProperties(), 50)); - Glacier2::RouterPrx router = Glacier2::RouterPrx::checkedCast(routerBase); + auto router = checkedCast<Glacier2::RouterPrx>(routerBase); communicator->setDefaultRouter(router); ostringstream os; os << "userid-" << _id; - Glacier2::SessionPrx session = router->createSession(os.str(), "abc123"); + auto session = router->createSession(os.str(), "abc123"); communicator->getProperties()->setProperty("Ice.PrintAdapterReady", ""); - ObjectAdapterPtr adapter = communicator->createObjectAdapterWithRouter("CallbackReceiverAdapter", router); + auto adapter = communicator->createObjectAdapterWithRouter("CallbackReceiverAdapter", router); adapter->activate(); - // - // Verify that the generated end_ method is exported properly - see bug 4719. - // - Ice::AsyncResultPtr r = router->begin_getCategoryForClient(); - string category = router->end_getCategoryForClient(r); + string category = router->getCategoryForClient(); { - Lock sync(*this); - _callbackReceiver = new CallbackReceiverI; - notify(); + lock_guard<mutex> lg(_mutex); + _callbackReceiver = make_shared<CallbackReceiverI>(); } + _condVar.notify_one(); - Identity ident; - ident.name = "callbackReceiver"; - ident.category = category; - CallbackReceiverPrx receiver = CallbackReceiverPrx::uncheckedCast(adapter->add(_callbackReceiver, ident)); + Identity ident = {"callbackReceiver", category}; + auto receiver = uncheckedCast<CallbackReceiverPrx>(adapter->add(_callbackReceiver, ident)); - ObjectPrx base = communicator->stringToProxy( + auto base = communicator->stringToProxy( "c1/callback:" + TestHelper::getTestEndpoint(communicator->getProperties())); base = base->ice_oneway(); - CallbackPrx callback = CallbackPrx::uncheckedCast(base); + auto callback = uncheckedCast<CallbackPrx>(base); // // Block the CallbackReceiver in wait() to prevent the client from @@ -121,10 +115,10 @@ public: // Notify the main thread that the callback was received. // { - Lock sync(*this); + lock_guard<mutex> lg(_mutex); _callback = true; - notify(); } + _condVar.notify_one(); // // Callback the client with a large payload. This should cause @@ -156,96 +150,90 @@ public: void waitForCallback() { + unique_lock<mutex> lock(_mutex); + while(!_callback) { - Lock sync(*this); - while(!_callback) - { - wait(); - } + _condVar.wait(lock); } } private: int _id; - CallbackReceiverIPtr _callbackReceiver; - bool _callback; + shared_ptr<CallbackReceiverI> _callbackReceiver; + bool _callback = false; + mutex _mutex; + condition_variable _condVar; }; -typedef IceUtil::Handle<MisbehavedClient> MisbehavedClientPtr; -class StressClient : public IceUtil::Thread, public IceUtil::Monitor<IceUtil::Mutex> +class StressClient { public: - StressClient(int id) : _id(id), _initialized(false), _notified(false) + explicit StressClient(int id) : _id(id) { } - virtual void run() { - CommunicatorPtr communicator = initialize(initData); - ObjectPrx routerBase = communicator->stringToProxy( + auto communicator = initialize(initData); + auto routerBase = communicator->stringToProxy( "Glacier2/router:" + TestHelper::getTestEndpoint(communicator->getProperties(), 50)); - _router = Glacier2::RouterPrx::checkedCast(routerBase); + _router = checkedCast<Glacier2::RouterPrx>(routerBase); communicator->setDefaultRouter(_router); ostringstream os; os << "userid-" << _id; - Glacier2::SessionPrx session = _router->createSession(os.str(), "abc123"); + auto session = _router->createSession(os.str(), "abc123"); communicator->getProperties()->setProperty("Ice.PrintAdapterReady", ""); - ObjectAdapterPtr adapter = communicator->createObjectAdapterWithRouter("CallbackReceiverAdapter", _router); + auto adapter = communicator->createObjectAdapterWithRouter("CallbackReceiverAdapter", _router); adapter->activate(); string category = _router->getCategoryForClient(); - _callbackReceiver = new CallbackReceiverI; - Identity ident; - ident.name = "callbackReceiver"; - ident.category = category; - CallbackReceiverPrx receiver = CallbackReceiverPrx::uncheckedCast(adapter->add(_callbackReceiver, ident)); + _callbackReceiver = make_shared<CallbackReceiverI>(); + Identity ident = {"callbackReceiver", category}; + auto receiver = uncheckedCast<CallbackReceiverPrx>(adapter->add(_callbackReceiver, ident)); - ObjectPrx base = communicator->stringToProxy( + auto base = communicator->stringToProxy( "c1/callback:" + TestHelper::getTestEndpoint(communicator->getProperties())); base = base->ice_oneway(); - CallbackPrx callback = CallbackPrx::uncheckedCast(base); + auto callback = uncheckedCast<CallbackPrx>(base); { - Lock sync(*this); + lock_guard<mutex> lg(_mutex); _initialized = true; - notifyAll(); } + _condVar.notify_all(); + { - Lock sync(*this); + unique_lock<mutex> lock(_mutex); while(!_notified) { - wait(); + _condVar.wait(lock); } } // // Stress the router until the connection is closed. // - stress(callback, receiver); + stress(move(callback), move(receiver)); communicator->destroy(); } - virtual void stress(const CallbackPrx& callback, const CallbackReceiverPrx&) = 0; + virtual void stress(shared_ptr<CallbackPrx> callback, shared_ptr<CallbackReceiverPrx>) = 0; void notifyThread() { { - Lock sync(*this); + unique_lock<mutex> lock(_mutex); while(!_initialized) { - wait(); + _condVar.wait(lock); } - } - { - Lock sync(*this); _notified = true; - notify(); } + _condVar.notify_one(); } void @@ -272,34 +260,35 @@ public: protected: - Glacier2::RouterPrx _router; + shared_ptr<Glacier2::RouterPrx> _router; int _id; - CallbackReceiverIPtr _callbackReceiver; - bool _initialized; - bool _notified; + shared_ptr<CallbackReceiverI> _callbackReceiver; + bool _initialized = false; + bool _notified = false; + mutex _mutex; + condition_variable _condVar; }; -typedef IceUtil::Handle<StressClient> StressClientPtr; -class PingStressClient : public StressClient +class PingStressClient final : public StressClient { public: - PingStressClient(int id) : StressClient(id) + explicit PingStressClient(int id) : StressClient(id) { } - virtual void - stress(const CallbackPrx& callback, const CallbackReceiverPrx&) + void + stress(shared_ptr<CallbackPrx> callback, shared_ptr<CallbackReceiverPrx>) override { try { - CallbackPrx cb = CallbackPrx::uncheckedCast(callback->ice_twoway()); + auto cb = callback->ice_twoway(); Context context; context["_fwd"] = "t"; while(true) { cb->ice_ping(context); - IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(1)); + this_thread::sleep_for(1ms); } } catch(const Ice::ConnectionLostException&) @@ -319,27 +308,27 @@ public: } }; -class CallbackStressClient : public StressClient +class CallbackStressClient final : public StressClient { public: - CallbackStressClient(int id) : StressClient(id) + explicit CallbackStressClient(int id) : StressClient(id) { } - virtual void - stress(const CallbackPrx& callback, const CallbackReceiverPrx& receiver) + void + stress(shared_ptr<CallbackPrx> callback, shared_ptr<CallbackReceiverPrx> receiver) override { try { - CallbackPrx cb = CallbackPrx::uncheckedCast(callback->ice_twoway()); + auto cb = callback->ice_twoway(); Context context; context["_fwd"] = "t"; while(true) { cb->initiateCallback(receiver, context); _callbackReceiver->callbackOK(); - IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(1)); + this_thread::sleep_for(1ms); } } catch(const Ice::ConnectionLostException&) @@ -363,27 +352,27 @@ public: } }; -class CallbackWithPayloadStressClient : public StressClient +class CallbackWithPayloadStressClient final : public StressClient { public: - CallbackWithPayloadStressClient(int id) : StressClient(id) + explicit CallbackWithPayloadStressClient(int id) : StressClient(id) { } - virtual void - stress(const CallbackPrx& callback, const CallbackReceiverPrx& receiver) + void + stress(shared_ptr<CallbackPrx> callback, shared_ptr<CallbackReceiverPrx> receiver) override { try { - CallbackPrx cb = CallbackPrx::uncheckedCast(callback->ice_twoway()); + auto cb = callback->ice_twoway(); Context context; context["_fwd"] = "t"; while(true) { cb->initiateCallbackWithPayload(receiver, context); _callbackReceiver->callbackWithPayloadOK(); - IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(10)); + this_thread::sleep_for(10ms); } } catch(const Ice::ConnectionLostException&) @@ -407,11 +396,11 @@ public: } }; -class CallbackClient : public Test::TestHelper +class CallbackClient final : public Test::TestHelper { public: - void run(int, char**); + void run(int, char**) override; }; void @@ -426,26 +415,26 @@ CallbackClient::run(int argc, char** argv) initData.properties->setProperty("Ice.Warn.Connections", "0"); Ice::CommunicatorHolder communicator = initialize(argc, argv, initData); - ObjectPrx routerBase; + shared_ptr<ObjectPrx> routerBase; { cout << "testing stringToProxy for router... " << flush; routerBase = communicator->stringToProxy("Glacier2/router:" + getTestEndpoint(50)); cout << "ok" << endl; } - Glacier2::RouterPrx router; + shared_ptr<Glacier2::RouterPrx> router; { cout << "testing checked cast for router... " << flush; - router = Glacier2::RouterPrx::checkedCast(routerBase); + router = checkedCast<Glacier2::RouterPrx>(routerBase); test(router); cout << "ok" << endl; } { cout << "testing router finder... " << flush; - Ice::RouterFinderPrx finder = - RouterFinderPrx::uncheckedCast(communicator->stringToProxy("Ice/RouterFinder:" + getTestEndpoint(50))); + auto finder = + uncheckedCast<RouterFinderPrx>(communicator->stringToProxy("Ice/RouterFinder:" + getTestEndpoint(50))); test(finder->getRouter()->ice_getIdentity() == router->ice_getIdentity()); cout << "ok" << endl; } @@ -458,12 +447,12 @@ CallbackClient::run(int argc, char** argv) { cout << "getting the session timeout... " << flush; - Ice::Long timeout = router->getSessionTimeout(); + auto timeout = router->getSessionTimeout(); test(timeout == 30); cout << "ok" << endl; } - ObjectPrx base; + shared_ptr<ObjectPrx> base; { cout << "testing stringToProxy for server object... " << flush; @@ -484,7 +473,7 @@ CallbackClient::run(int argc, char** argv) } } - Glacier2::SessionPrx session; + shared_ptr<Glacier2::SessionPrx> session; { cout << "trying to create session with wrong password... " << flush; @@ -547,7 +536,7 @@ CallbackClient::run(int argc, char** argv) { cout << "pinging object with client endpoint... " << flush; - Ice::ObjectPrx baseC = communicator->stringToProxy("collocated:" + getTestEndpoint(50)); + auto baseC = communicator->stringToProxy("collocated:" + getTestEndpoint(50)); try { baseC->ice_ping(); @@ -558,16 +547,16 @@ CallbackClient::run(int argc, char** argv) cout << "ok" << endl; } - CallbackPrx twoway; + shared_ptr<CallbackPrx> twoway; { cout << "testing checked cast for server object... " << flush; - twoway = CallbackPrx::checkedCast(base); + twoway = checkedCast<CallbackPrx>(base); test(twoway); cout << "ok" << endl; } - ObjectAdapterPtr adapter; + shared_ptr<ObjectAdapter> adapter; { cout << "creating and activating callback receiver adapter with router... " << flush; @@ -585,37 +574,31 @@ CallbackClient::run(int argc, char** argv) cout << "ok" << endl; } - CallbackReceiverI* callbackReceiverImpl; - ObjectPtr callbackReceiver; - CallbackReceiverPrx twowayR; - CallbackReceiverPrx fakeTwowayR; + shared_ptr<CallbackReceiverI> callbackReceiver; + shared_ptr<CallbackReceiverPrx> twowayR; + shared_ptr<CallbackReceiverPrx> fakeTwowayR; { cout << "creating and adding callback receiver object... " << flush; - callbackReceiverImpl = new CallbackReceiverI; - callbackReceiver = callbackReceiverImpl; - Identity callbackReceiverIdent; - callbackReceiverIdent.name = "callbackReceiver"; - callbackReceiverIdent.category = category; - twowayR = CallbackReceiverPrx::uncheckedCast(adapter->add(callbackReceiver, callbackReceiverIdent)); - Identity fakeCallbackReceiverIdent; - fakeCallbackReceiverIdent.name = "callbackReceiver"; - fakeCallbackReceiverIdent.category = "dummy"; - fakeTwowayR = CallbackReceiverPrx::uncheckedCast(adapter->add(callbackReceiver, fakeCallbackReceiverIdent)); + callbackReceiver = make_shared<CallbackReceiverI>(); + Identity callbackReceiverIdent = {"callbackReceiver", category}; + twowayR = uncheckedCast<CallbackReceiverPrx>(adapter->add(callbackReceiver, callbackReceiverIdent)); + Identity fakeCallbackReceiverIdent = {"callbackReceiver", "dummy"}; + fakeTwowayR = uncheckedCast<CallbackReceiverPrx>(adapter->add(callbackReceiver, fakeCallbackReceiverIdent)); cout << "ok" << endl; } { cout << "testing oneway callback... " << flush; - CallbackPrx oneway = CallbackPrx::uncheckedCast(twoway->ice_oneway()); - CallbackReceiverPrx onewayR = CallbackReceiverPrx::uncheckedCast(twowayR->ice_oneway()); + auto oneway = twoway->ice_oneway(); + auto onewayR = twowayR->ice_oneway(); Context context; context["_fwd"] = "o"; oneway->initiateCallback(onewayR, context); oneway->initiateCallback(onewayR, context); oneway->initiateCallback(onewayR, context); oneway->initiateCallback(onewayR, context); - callbackReceiverImpl->callbackOK(4); + callbackReceiver->callbackOK(4); cout << "ok" << endl; } @@ -627,7 +610,7 @@ CallbackClient::run(int argc, char** argv) twoway->initiateCallback(twowayR, context); twoway->initiateCallback(twowayR, context); twoway->initiateCallback(twowayR, context); - callbackReceiverImpl->callbackOK(4); + callbackReceiver->callbackOK(4); cout << "ok" << endl; } @@ -635,8 +618,8 @@ CallbackClient::run(int argc, char** argv) cout << "testing batch oneway callback... " << flush; Context context; context["_fwd"] = "O"; - CallbackPrx batchOneway = CallbackPrx::uncheckedCast(twoway->ice_batchOneway()); - CallbackReceiverPrx onewayR = CallbackReceiverPrx::uncheckedCast(twowayR->ice_oneway()); + auto batchOneway = twoway->ice_batchOneway(); + auto onewayR = twowayR->ice_oneway(); batchOneway->initiateCallback(onewayR, context); batchOneway->initiateCallback(onewayR, context); batchOneway->initiateCallback(onewayR, context); @@ -644,7 +627,7 @@ CallbackClient::run(int argc, char** argv) batchOneway->initiateCallback(onewayR, context); batchOneway->initiateCallback(onewayR, context); batchOneway->ice_flushBatchRequests(); - callbackReceiverImpl->callbackOK(6); + callbackReceiver->callbackOK(6); cout << "ok" << endl; } @@ -658,19 +641,28 @@ CallbackClient::run(int argc, char** argv) cout << "testing concurrent twoway callback... " << flush; Context context; context["_fwd"] = "t"; - AsyncCallbackPtr cb0 = new AsyncCallback(); - twoway->begin_initiateConcurrentCallback(0, twowayR, context, - newCallback_Callback_initiateConcurrentCallback(cb0, &AsyncCallback::response, &AsyncCallback::exception)); - AsyncCallbackPtr cb1 = new AsyncCallback(); - twoway->begin_initiateConcurrentCallback(1, twowayR, context, - newCallback_Callback_initiateConcurrentCallback(cb1, &AsyncCallback::response, &AsyncCallback::exception)); - AsyncCallbackPtr cb2 = new AsyncCallback(); - twoway->begin_initiateConcurrentCallback(2, twowayR, context, - newCallback_Callback_initiateConcurrentCallback(cb2, &AsyncCallback::response, &AsyncCallback::exception)); - callbackReceiverImpl->answerConcurrentCallbacks(3); - test(cb0->waitResponse() == 0); - test(cb1->waitResponse() == 1); - test(cb2->waitResponse() == 2); + AsyncCallback cb0; + twoway->initiateConcurrentCallbackAsync(0, twowayR, + [&cb0](int val){ cb0.response(val); }, + [&cb0](exception_ptr e){ cb0.error(e); }, + nullptr, context); + + AsyncCallback cb1; + twoway->initiateConcurrentCallbackAsync(1, twowayR, + [&cb1](int val){ cb1.response(val); }, + [&cb1](exception_ptr e){ cb1.error(e); }, + nullptr, context); + + AsyncCallback cb2; + twoway->initiateConcurrentCallbackAsync(2, twowayR, + [&cb2](int val){ cb2.response(val); }, + [&cb2](exception_ptr e){ cb2.error(e); }, + nullptr, context); + + callbackReceiver->answerConcurrentCallbacks(3); + test(cb0.waitResponse() == 0); + test(cb1.waitResponse() == 1); + test(cb2.waitResponse() == 2); cout << "ok" << endl; } @@ -688,7 +680,7 @@ CallbackClient::run(int argc, char** argv) test(ex.someValue == 3.14); test(ex.someString == "3.14"); } - callbackReceiverImpl->callbackOK(); + callbackReceiver->callbackOK(); cout << "ok" << endl; } @@ -711,10 +703,10 @@ CallbackClient::run(int argc, char** argv) cout << "testing whether other allowed category is accepted... " << flush; Context context; context["_fwd"] = "t"; - CallbackPrx otherCategoryTwoway = CallbackPrx::uncheckedCast( + auto otherCategoryTwoway = uncheckedCast<CallbackPrx>( twoway->ice_identity(stringToIdentity("c2/callback"))); otherCategoryTwoway->initiateCallback(twowayR, context); - callbackReceiverImpl->callbackOK(); + callbackReceiver->callbackOK(); cout << "ok" << endl; } @@ -724,7 +716,7 @@ CallbackClient::run(int argc, char** argv) context["_fwd"] = "t"; try { - CallbackPrx otherCategoryTwoway = CallbackPrx::uncheckedCast( + auto otherCategoryTwoway = uncheckedCast<CallbackPrx>( twoway->ice_identity(stringToIdentity("c3/callback"))); otherCategoryTwoway->initiateCallback(twowayR, context); test(false); @@ -739,10 +731,10 @@ CallbackClient::run(int argc, char** argv) cout << "testing whether user-id as category is accepted... " << flush; Context context; context["_fwd"] = "t"; - CallbackPrx otherCategoryTwoway = CallbackPrx::uncheckedCast( + auto otherCategoryTwoway = uncheckedCast<CallbackPrx>( twoway->ice_identity(stringToIdentity("_userid/callback"))); otherCategoryTwoway->initiateCallback(twowayR, context); - callbackReceiverImpl->callbackOK(); + callbackReceiver->callbackOK(); cout << "ok" << endl; } @@ -752,21 +744,21 @@ CallbackClient::run(int argc, char** argv) // // Start 3 misbehaving clients. // + MisbehavedClient clients[] = {MisbehavedClient(0), MisbehavedClient(1), MisbehavedClient(2)}; + std::future<void> futures[3] = {}; const int nClients = 3; // Passwords need to be added to the password file if more clients are needed. - int i; - vector<MisbehavedClientPtr> clients; - for(i = 0; i < nClients; ++i) + for(int i = 0; i < nClients; ++i) { - clients.push_back(new MisbehavedClient(i)); - clients.back()->start(); - clients.back()->waitForCallback(); + auto& client = clients[i]; + futures[i] = std::async(launch::async, [&client]{ client.run(); }); + client.waitForCallback(); } // // Sleep for one second to make sure the router starts sending // the callback with the payload to the clients. // - IceUtil::ThreadControl::sleep(IceUtil::Time::seconds(1)); + this_thread::sleep_for(1s); // // Initiate few callbacks with a large payload. Because of @@ -777,18 +769,18 @@ CallbackClient::run(int argc, char** argv) Context context; context["_fwd"] = "t"; twoway->initiateCallbackWithPayload(twowayR, context); - callbackReceiverImpl->callbackWithPayloadOK(); + callbackReceiver->callbackWithPayloadOK(); twoway->initiateCallbackWithPayload(twowayR, context); - callbackReceiverImpl->callbackWithPayloadOK(); + callbackReceiver->callbackWithPayloadOK(); twoway->initiateCallbackWithPayload(twowayR, context); - callbackReceiverImpl->callbackWithPayloadOK(); + callbackReceiver->callbackWithPayloadOK(); twoway->initiateCallbackWithPayload(twowayR, context); - callbackReceiverImpl->callbackWithPayloadOK(); + callbackReceiver->callbackWithPayloadOK(); - for(vector<MisbehavedClientPtr>::const_iterator p = clients.begin(); p != clients.end(); ++p) + for(int i = 0; i < nClients; ++i) { - (*p)->notifyWaitCallback(); - (*p)->getThreadControl().join(); + clients[i].notifyWaitCallback(); + futures[i].get(); } cout << "ok" << endl; @@ -797,36 +789,38 @@ CallbackClient::run(int argc, char** argv) { cout << "stress test... " << flush; const int nClients = 3; // Passwords need to be added to the password file if more clients are needed. - int i; - vector<StressClientPtr> clients; - for(i = 0; i < nClients; ++i) + vector<shared_ptr<StressClient>> clients; + vector<future<void>> futures; + random_device rd; + for(int i = 0; i < nClients; ++i) { - switch(IceUtilInternal::random(3)) + switch(rd() % 3) { case 0: - clients.push_back(new PingStressClient(i)); + clients.push_back(make_shared<PingStressClient>(i)); break; case 1: - clients.push_back(new CallbackStressClient(i)); + clients.push_back(make_shared<CallbackStressClient>(i)); break; case 2: - clients.push_back(new CallbackWithPayloadStressClient(i)); + clients.push_back(make_shared<CallbackWithPayloadStressClient>(i)); break; default: assert(false); break; } - clients.back()->start(); + auto client = clients.back(); + futures.push_back(std::async(launch::async, [client = move(client)]{ client->run(); })); } - for(vector<StressClientPtr>::const_iterator p = clients.begin(); p != clients.end(); ++p) + for(const auto& p: clients) { - (*p)->notifyThread(); + p->notifyThread(); } // // Let the stress client run for a bit. // - IceUtil::ThreadControl::sleep(IceUtil::Time::seconds(3)); + this_thread::sleep_for(3s); // // Send some callbacks. @@ -834,15 +828,18 @@ CallbackClient::run(int argc, char** argv) Context context; context["_fwd"] = "t"; twoway->initiateCallback(twowayR); - callbackReceiverImpl->callbackOK(); + callbackReceiver->callbackOK(); // // Kill the stress clients. // - for(vector<StressClientPtr>::const_iterator q = clients.begin(); q != clients.end(); ++q) + for(const auto& p: clients) + { + p->kill(); + } + for(auto& f: futures) { - (*q)->kill(); - (*q)->getThreadControl().join(); + f.get(); } cout << "ok" << endl; @@ -905,7 +902,7 @@ CallbackClient::run(int argc, char** argv) cout << "ok" << endl; } - ObjectPrx processBase; + shared_ptr<ObjectPrx> processBase; { cout << "testing stringToProxy for admin process facet... " << flush; @@ -913,11 +910,11 @@ CallbackClient::run(int argc, char** argv) cout << "ok" << endl; } - Ice::ProcessPrx process; + shared_ptr<Ice::ProcessPrx> process; { cout << "testing checked cast for process facet... " << flush; - process = Ice::ProcessPrx::checkedCast(processBase); + process = checkedCast<Ice::ProcessPrx>(processBase); test(process); cout << "ok" << endl; } diff --git a/cpp/test/Glacier2/router/Server.cpp b/cpp/test/Glacier2/router/Server.cpp index 3b7afc5a76b..c0021b7591b 100644 --- a/cpp/test/Glacier2/router/Server.cpp +++ b/cpp/test/Glacier2/router/Server.cpp @@ -10,26 +10,26 @@ using namespace std; using namespace Ice; using namespace Test; -class CallbackServer : public Test::TestHelper +class CallbackServer final : public Test::TestHelper { public: - void run(int, char**); + void run(int, char**) override; }; void CallbackServer::run(int argc, char** argv) { - Ice::PropertiesPtr properties = createTestProperties(argc, argv); + auto 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("CallbackAdapter.Endpoints", getTestEndpoint()); - ObjectAdapterPtr adapter = communicator->createObjectAdapter("CallbackAdapter"); - adapter->add(new CallbackI(), Ice::stringToIdentity("c1/callback")); // The test allows "c1" as category. - adapter->add(new CallbackI(), Ice::stringToIdentity("c2/callback")); // The test allows "c2" as category. - adapter->add(new CallbackI(), Ice::stringToIdentity("c3/callback")); // The test rejects "c3" as category. - adapter->add(new CallbackI(), Ice::stringToIdentity("_userid/callback")); // The test allows the prefixed userid. + auto adapter = communicator->createObjectAdapter("CallbackAdapter"); + adapter->add(make_shared<CallbackI>(), Ice::stringToIdentity("c1/callback")); // The test allows "c1" as category. + adapter->add(make_shared<CallbackI>(), Ice::stringToIdentity("c2/callback")); // The test allows "c2" as category. + adapter->add(make_shared<CallbackI>(), Ice::stringToIdentity("c3/callback")); // The test rejects "c3" as category. + adapter->add(make_shared<CallbackI>(), Ice::stringToIdentity("_userid/callback")); // The test allows the prefixed userid. adapter->activate(); communicator->waitForShutdown(); } diff --git a/cpp/test/Glacier2/sessionControl/Client.cpp b/cpp/test/Glacier2/sessionControl/Client.cpp index b6592cde343..711e17056bd 100644 --- a/cpp/test/Glacier2/sessionControl/Client.cpp +++ b/cpp/test/Glacier2/sessionControl/Client.cpp @@ -12,17 +12,17 @@ using namespace std; using namespace Ice; using namespace Test; -class SessionControlClient : public Test::TestHelper +class SessionControlClient final : public Test::TestHelper { public: - void run(int, char**); + void run(int, char**) override; }; void SessionControlClient::run(int argc, char** argv) { - Ice::PropertiesPtr properties = createTestProperties(argc, argv); + auto properties = createTestProperties(argc, argv); // // We want to check whether the client retries for evicted @@ -34,15 +34,15 @@ SessionControlClient::run(int argc, char** argv) Ice::CommunicatorHolder communicator = initialize(argc, argv, properties); cout << "getting router... " << flush; - ObjectPrx routerBase = communicator->stringToProxy("Glacier2/router:" + getTestEndpoint(50)); - Glacier2::RouterPrx router = Glacier2::RouterPrx::checkedCast(routerBase); + auto routerBase = communicator->stringToProxy("Glacier2/router:" + getTestEndpoint(50)); + auto router = checkedCast<Glacier2::RouterPrx>(routerBase); test(router); communicator->setDefaultRouter(router); cout << "ok" << endl; cout << "creating session... " << flush; - Glacier2::SessionPrx sessionBase = router->createSession("userid", "abc123"); - Test::SessionPrx session = Test::SessionPrx::uncheckedCast(sessionBase); + auto sessionBase = router->createSession("userid", "abc123"); + auto session = uncheckedCast<Test::SessionPrx>(sessionBase); test(session); cout << "ok" << endl; @@ -85,11 +85,11 @@ SessionControlClient::run(int argc, char** argv) cout << "ok" << endl; cout << "testing shutdown... " << flush; - session = Test::SessionPrx::uncheckedCast(router->createSession("userid", "abc123")); + session = uncheckedCast<Test::SessionPrx>(router->createSession("userid", "abc123")); session->shutdown(); communicator->setDefaultRouter(0); - ObjectPrx processBase = communicator->stringToProxy("Glacier2/admin -f Process:" + getTestEndpoint(51)); - Ice::ProcessPrx process = Ice::ProcessPrx::checkedCast(processBase); + auto processBase = communicator->stringToProxy("Glacier2/admin -f Process:" + getTestEndpoint(51)); + auto process = checkedCast<Ice::ProcessPrx>(processBase); test(process); process->shutdown(); try diff --git a/cpp/test/Glacier2/sessionControl/Server.cpp b/cpp/test/Glacier2/sessionControl/Server.cpp index 0e05292edc4..b64881f095c 100644 --- a/cpp/test/Glacier2/sessionControl/Server.cpp +++ b/cpp/test/Glacier2/sessionControl/Server.cpp @@ -11,11 +11,11 @@ using namespace std; using namespace Ice; using namespace Test; -class SessionControlServer : public Test::TestHelper +class SessionControlServer final : public Test::TestHelper { public: - void run(int, char**); + void run(int, char**) override; }; void @@ -23,8 +23,8 @@ SessionControlServer::run(int argc, char** argv) { Ice::CommunicatorHolder communicator = initialize(argc, argv); communicator->getProperties()->setProperty("SessionControlAdapter.Endpoints", getTestEndpoint()); - ObjectAdapterPtr adapter = communicator->createObjectAdapter("SessionControlAdapter"); - adapter->add(new SessionManagerI, Ice::stringToIdentity("SessionManager")); + auto adapter = communicator->createObjectAdapter("SessionControlAdapter"); + adapter->add(make_shared<SessionManagerI>(), Ice::stringToIdentity("SessionManager")); adapter->activate(); communicator->waitForShutdown(); } diff --git a/cpp/test/Glacier2/sessionControl/SessionI.cpp b/cpp/test/Glacier2/sessionControl/SessionI.cpp index 5d25ab239ae..693992514ff 100644 --- a/cpp/test/Glacier2/sessionControl/SessionI.cpp +++ b/cpp/test/Glacier2/sessionControl/SessionI.cpp @@ -9,35 +9,8 @@ using namespace std; using namespace Test; -class DestroyCB : public virtual IceUtil::Shared -{ -public: - - DestroyCB(const Test::AMD_Session_destroyFromClientPtr& cb) : _cb(cb) - { - } - - void - response() - { - _cb->ice_response(); - } - - void - exception(const IceUtil::Exception&) - { - test(false); - } - -private: - - Test::AMD_Session_destroyFromClientPtr _cb; -}; - -typedef IceUtil::Handle<DestroyCB> DestroyCBPtr; - -Glacier2::SessionPrx -SessionManagerI::create(const string& userId, const Glacier2::SessionControlPrx& sessionControl, +shared_ptr<Glacier2::SessionPrx> +SessionManagerI::create(string userId, shared_ptr<Glacier2::SessionControlPrx> sessionControl, const Ice::Current& current) { if(userId == "rejectme") @@ -48,23 +21,19 @@ SessionManagerI::create(const string& userId, const Glacier2::SessionControlPrx& { throw Ice::ObjectNotExistException(__FILE__, __LINE__); } - return Glacier2::SessionPrx::uncheckedCast(current.adapter->addWithUUID(new SessionI(sessionControl))); + return Ice::uncheckedCast<Glacier2::SessionPrx>(current.adapter->addWithUUID(make_shared<SessionI>(sessionControl))); } -SessionI::SessionI(const Glacier2::SessionControlPrx& sessionControl) : - _sessionControl(sessionControl) +SessionI::SessionI(shared_ptr<Glacier2::SessionControlPrx> sessionControl) : + _sessionControl(move(sessionControl)) { - assert(sessionControl); + assert(_sessionControl); } void -SessionI::destroyFromClient_async(const Test::AMD_Session_destroyFromClientPtr& cb, const Ice::Current&) +SessionI::destroyFromClientAsync(function<void()> response, function<void(exception_ptr)>, const Ice::Current&) { - DestroyCBPtr asyncCB = new DestroyCB(cb); - Glacier2::Callback_SessionControl_destroyPtr amiCB = Glacier2::newCallback_SessionControl_destroy(asyncCB, - &DestroyCB::response, - &DestroyCB::exception); - _sessionControl->begin_destroy(amiCB); + _sessionControl->destroyAsync(move(response), [](exception_ptr){ test(false); }); } void diff --git a/cpp/test/Glacier2/sessionControl/SessionI.h b/cpp/test/Glacier2/sessionControl/SessionI.h index d325ea3ff7d..831f04679b0 100644 --- a/cpp/test/Glacier2/sessionControl/SessionI.h +++ b/cpp/test/Glacier2/sessionControl/SessionI.h @@ -7,27 +7,29 @@ #include <Session.h> -class SessionManagerI : public Glacier2::SessionManager +class SessionManagerI final : public Glacier2::SessionManager { public: - virtual Glacier2::SessionPrx create(const std::string&, const Glacier2::SessionControlPrx&, const Ice::Current&); + std::shared_ptr<Glacier2::SessionPrx> + create(std::string, std::shared_ptr<Glacier2::SessionControlPrx>, const Ice::Current&) override; }; -class SessionI : public Test::Session +class SessionI final : public Test::Session { public: - SessionI(const Glacier2::SessionControlPrx&); + explicit SessionI(std::shared_ptr<Glacier2::SessionControlPrx>); - virtual void destroyFromClient_async(const Test::AMD_Session_destroyFromClientPtr&, const Ice::Current&); - virtual void shutdown(const Ice::Current&); + void + destroyFromClientAsync(std::function<void()>, std::function<void(std::exception_ptr)>, const Ice::Current&) override; - virtual void destroy(const Ice::Current&); + void shutdown(const Ice::Current&) override; + void destroy(const Ice::Current&) override; private: - Glacier2::SessionControlPrx _sessionControl; + std::shared_ptr<Glacier2::SessionControlPrx> _sessionControl; }; #endif diff --git a/cpp/test/Glacier2/sessionHelper/Client.cpp b/cpp/test/Glacier2/sessionHelper/Client.cpp index be2b034caae..9229d192687 100644 --- a/cpp/test/Glacier2/sessionHelper/Client.cpp +++ b/cpp/test/Glacier2/sessionHelper/Client.cpp @@ -2,7 +2,6 @@ // Copyright (c) ZeroC, Inc. All rights reserved. // -#include <IceUtil/IceUtil.h> #include <Ice/Ice.h> #include <Glacier2/Glacier2.h> @@ -11,177 +10,134 @@ #include <iostream> #include <iomanip> #include <list> +#include <chrono> #include <Callback.h> using namespace std; +using namespace std::chrono_literals; using namespace Test; +class Client; +void notifyClient(); + namespace { -class Notify -{ -public: +Client* instance = nullptr; - virtual ~Notify() - { - } - - virtual void notify() = 0; -}; - -Notify* instance = 0; - -class Dispatcher : -#ifndef ICE_CPP11_MAPPING - public Ice::Dispatcher, -#endif - public IceUtil::Thread +class Dispatcher final { - public: - Dispatcher(): - _destroyed(false) - { - } - - virtual void dispatch( -#ifdef ICE_CPP11_MAPPING - std::function<void()> call, -#else - const Ice::DispatcherCallPtr& call, -#endif - const Ice::ConnectionPtr&) + void dispatch(std::function<void()> call, const shared_ptr<Ice::Connection>&) { - IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor); - if(_queue.empty()) + bool wasEmpty = false; { - _monitor.notify(); + lock_guard<mutex> lg(_mutex); + wasEmpty = _queue.empty(); + _queue.push_back(move(call)); + } + if(wasEmpty) + { + _condVar.notify_one(); } - _queue.push_back(call); } - virtual void - destroy() + void destroy() { - IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor); - _destroyed = true; - _monitor.notify(); + { + lock_guard<mutex> lg(_mutex); + _destroyed = true; + } + _condVar.notify_one(); } - virtual void - run() + void run() { - while(1) + for(;;) { -#ifdef ICE_CPP11_MAPPING auto item = nextItem(); - if (!item) - { - break; - } - item(); -#else - Ice::DispatcherCallPtr item = nextItem(); if(!item) { break; } - item->run(); -#endif + item(); } } private: -#ifdef ICE_CPP11_MAPPING - std::function<void()> -#else - Ice::DispatcherCallPtr -#endif - nextItem() + std::function<void()> nextItem() { - IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor); + unique_lock<mutex> lock(_mutex); while(_queue.empty()) { if(_destroyed) { - return ICE_NULLPTR; + return nullptr; } - _monitor.wait(); + _condVar.wait(lock); } -#ifdef ICE_CPP11_MAPPING auto item = _queue.front(); -#else - Ice::DispatcherCallPtr item = _queue.front(); -#endif _queue.pop_front(); return item; } - IceUtil::Monitor<IceUtil::Mutex> _monitor; -#ifdef ICE_CPP11_MAPPING list<std::function<void()>> _queue; -#else - list<Ice::DispatcherCallPtr> _queue; -#endif - bool _destroyed; + bool _destroyed = false; + mutex _mutex; + condition_variable _condVar; }; -typedef IceUtil::Handle<Dispatcher> DispatcherPtr; -class SuccessSessionCallback : public Glacier2::SessionCallback +class SuccessSessionCallback final : public Glacier2::SessionCallback { - public: - virtual void - connected(const Glacier2::SessionHelperPtr&) + void connected(const shared_ptr<Glacier2::SessionHelper>&) override { cout << "ok" << endl; - instance->notify(); + notifyClient(); } - virtual void - disconnected(const Glacier2::SessionHelperPtr&) + void + disconnected(const shared_ptr<Glacier2::SessionHelper>&) override { cout << "ok" << endl; - instance->notify(); + notifyClient(); } - virtual void - connectFailed(const Glacier2::SessionHelperPtr&, const Ice::Exception&) + void + connectFailed(const shared_ptr<Glacier2::SessionHelper>&, const Ice::Exception&) override { test(false); } - virtual void - createdCommunicator(const Glacier2::SessionHelperPtr& session) + void + createdCommunicator(const shared_ptr<Glacier2::SessionHelper>& session) override { test(session->communicator()); } }; -class AfterShutdownSessionCallback : public Glacier2::SessionCallback +class AfterShutdownSessionCallback final : public Glacier2::SessionCallback { - public: - virtual void - connected(const Glacier2::SessionHelperPtr&) + void + connected(const shared_ptr<Glacier2::SessionHelper>&) override { test(false); } - virtual void - disconnected(const Glacier2::SessionHelperPtr&) + void + disconnected(const shared_ptr<Glacier2::SessionHelper>&) override { test(false); } - virtual void - connectFailed(const Glacier2::SessionHelperPtr&, const Ice::Exception& ex) + void + connectFailed(const shared_ptr<Glacier2::SessionHelper>&, const Ice::Exception& ex) override { try { @@ -190,7 +146,7 @@ public: catch(const Ice::ConnectFailedException&) { cout << "ok" << endl; - instance->notify(); + notifyClient(); } catch(...) { @@ -198,32 +154,31 @@ public: } } - virtual void - createdCommunicator(const Glacier2::SessionHelperPtr& session) + void + createdCommunicator(const shared_ptr<Glacier2::SessionHelper>& session) override { test(session->communicator()); } }; -class FailSessionCallback : public Glacier2::SessionCallback +class FailSessionCallback final : public Glacier2::SessionCallback { - public: - virtual void - connected(const Glacier2::SessionHelperPtr&) + void + connected(const shared_ptr<Glacier2::SessionHelper>&) override { test(false); } - virtual void - disconnected(const Glacier2::SessionHelperPtr&) + void + disconnected(const shared_ptr<Glacier2::SessionHelper>&) override { test(false); } - virtual void - connectFailed(const Glacier2::SessionHelperPtr&, const Ice::Exception& ex) + void + connectFailed(const shared_ptr<Glacier2::SessionHelper>&, const Ice::Exception& ex) override { try { @@ -232,7 +187,7 @@ public: catch(const Glacier2::PermissionDeniedException&) { cout << "ok" << endl; - instance->notify(); + notifyClient(); } catch(const Ice::LocalException&) { @@ -240,32 +195,31 @@ public: } } - virtual void - createdCommunicator(const Glacier2::SessionHelperPtr& session) + void + createdCommunicator(const shared_ptr<Glacier2::SessionHelper>& session) override { test(session->communicator()); } }; -class InterruptConnectCallback : public Glacier2::SessionCallback +class InterruptConnectCallback final : public Glacier2::SessionCallback { - public: - virtual void - connected(const Glacier2::SessionHelperPtr&) + void + connected(const shared_ptr<Glacier2::SessionHelper>&) override { test(false); } - virtual void - disconnected(const Glacier2::SessionHelperPtr&) + void + disconnected(const shared_ptr<Glacier2::SessionHelper>&) override { test(false); } - virtual void - connectFailed(const Glacier2::SessionHelperPtr&, const Ice::Exception& ex) + void + connectFailed(const shared_ptr<Glacier2::SessionHelper>&, const Ice::Exception& ex) override { try { @@ -274,7 +228,7 @@ public: catch(const Ice::CommunicatorDestroyedException&) { cout << "ok" << endl; - instance->notify(); + notifyClient(); } catch(...) { @@ -282,8 +236,8 @@ public: } } - virtual void - createdCommunicator(const Glacier2::SessionHelperPtr& session) + void + createdCommunicator(const shared_ptr<Glacier2::SessionHelper>& session) override { test(session->communicator()); } @@ -291,28 +245,32 @@ public: } // Anonymous namespace end -class Client : public Test::TestHelper, - public Notify +class Client final : public Test::TestHelper { public: - void run(int, char**); + void run(int, char**) override; void notify() { - IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor); - _monitor.notify(); + _condVar.notify_one(); } private: - Glacier2::SessionHelperPtr _session; - Glacier2::SessionFactoryHelperPtr _factory; + shared_ptr<Glacier2::SessionHelper> _session; + shared_ptr<Glacier2::SessionFactoryHelper> _factory; Ice::InitializationData _initData; - IceUtil::Monitor<IceUtil::Mutex> _monitor; + mutex _mutex; + condition_variable _condVar; }; +void notifyClient() +{ + instance->notify(); +} + void Client::run(int argc, char** argv) { @@ -323,24 +281,21 @@ Client::run(int argc, char** argv) _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)); + Dispatcher dispatcher; + auto dfut = std::async(launch::async, [&dispatcher]{ dispatcher.run(); }); + + _initData.dispatcher = [&dispatcher](std::function<void()> call, const std::shared_ptr<Ice::Connection>& conn) + { + dispatcher.dispatch(call, conn); + }; + _factory = make_shared<Glacier2::SessionFactoryHelper>(_initData, make_shared<FailSessionCallback>()); // // Test to create a session with wrong userid/password // { - IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor); + unique_lock<mutex> lock(_mutex); cout << "testing SessionHelper connect with wrong userid/password... " << flush; @@ -348,8 +303,7 @@ Client::run(int argc, char** argv) // // Wait for connectFailed callback // - _monitor.timedWait(IceUtil::Time::seconds(30)); - + _condVar.wait_for(lock, 30s); test(!_session->isConnected()); } _factory->destroy(); @@ -359,31 +313,31 @@ Client::run(int argc, char** argv) // _initData.properties->setProperty("Ice.Default.Router", ""); - _factory = ICE_MAKE_SHARED(Glacier2::SessionFactoryHelper, _initData, ICE_MAKE_SHARED(InterruptConnectCallback)); + _factory = make_shared<Glacier2::SessionFactoryHelper>(_initData, make_shared<InterruptConnectCallback>()); { - IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor); + unique_lock<mutex> lock(_mutex); 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)); + this_thread::sleep_for(100ms); _session->destroy(); // // Wait for connectFailed callback // - _monitor.timedWait(IceUtil::Time::seconds(30)); + _condVar.wait_for(lock, 30s); test(!_session->isConnected()); } _factory->destroy(); - _factory = ICE_MAKE_SHARED(Glacier2::SessionFactoryHelper, _initData, ICE_MAKE_SHARED(SuccessSessionCallback)); + _factory = make_shared<Glacier2::SessionFactoryHelper>(_initData, make_shared<SuccessSessionCallback>()); { - IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor); + unique_lock<mutex> lock(_mutex); cout << "testing SessionHelper connect... " << flush; _factory->setRouterHost(host); _factory->setPort(getTestPort(_initData.properties, 50)); @@ -393,7 +347,7 @@ Client::run(int argc, char** argv) // // Wait for connect callback // - _monitor.timedWait(IceUtil::Time::seconds(30)); + _condVar.wait_for(lock, 30s); cout << "testing SessionHelper isConnected after connect... " << flush; test(_session->isConnected()); @@ -413,7 +367,7 @@ Client::run(int argc, char** argv) test(!_session->session()); cout << "testing stringToProxy for server object... " << flush; - Ice::ObjectPrxPtr base = + auto base = _session->communicator()->stringToProxy("callback:" + getTestEndpoint(_session->communicator()->getProperties())); cout << "ok" << endl; @@ -422,7 +376,7 @@ Client::run(int argc, char** argv) cout << "ok" << endl; cout << "testing checked cast for server object... " << flush; - CallbackPrxPtr twoway = ICE_CHECKED_CAST(CallbackPrx, base); + auto twoway = Ice::checkedCast<CallbackPrx>(base); test(twoway); cout << "ok" << endl; @@ -437,7 +391,7 @@ Client::run(int argc, char** argv) // // Wait for disconnected callback // - _monitor.wait(); + _condVar.wait(lock); cout << "testing SessionHelper isConnected after destroy... " << flush; test(_session->isConnected() == false); @@ -455,7 +409,7 @@ Client::run(int argc, char** argv) cout << "ok" << endl; cout << "testing SessionHelper session after destroy... " << flush; - test(_session->session() == ICE_NULLPTR); + test(_session->session() == nullptr); cout << "ok" << endl; cout << "testing SessionHelper communicator after destroy... " << flush; @@ -471,20 +425,20 @@ Client::run(int argc, char** argv) cout << "ok" << endl; cout << "uninstalling router with communicator... " << flush; - communicator->setDefaultRouter(0); + communicator->setDefaultRouter(nullptr); cout << "ok" << endl; - Ice::ObjectPrxPtr processBase; + shared_ptr<Ice::ObjectPrx> processBase; { cout << "testing stringToProxy for process object... " << flush; processBase = communicator->stringToProxy("Glacier2/admin -f Process:" + getTestEndpoint(51)); cout << "ok" << endl; } - Ice::ProcessPrxPtr process; + shared_ptr<Ice::ProcessPrx> process; { cout << "testing checked cast for admin object... " << flush; - process = ICE_CHECKED_CAST(Ice::ProcessPrx, processBase); + process = Ice::checkedCast<Ice::ProcessPrx>(processBase); test(process != 0); cout << "ok" << endl; } @@ -504,15 +458,15 @@ Client::run(int argc, char** argv) _factory->destroy(); - _factory = ICE_MAKE_SHARED(Glacier2::SessionFactoryHelper, _initData, ICE_MAKE_SHARED(AfterShutdownSessionCallback)); + _factory = make_shared<Glacier2::SessionFactoryHelper>( _initData, make_shared<AfterShutdownSessionCallback>()); // // Wait a bit to ensure glaci2router has been shutdown. // - IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(100)); + this_thread::sleep_for(100ms); { - IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor); + unique_lock<mutex> lock(_mutex); cout << "testing SessionHelper connect after router shutdown... " << flush; _factory->setRouterHost(host); _factory->setPort(getTestPort(_initData.properties, 50)); @@ -522,7 +476,7 @@ Client::run(int argc, char** argv) // // Wait for connectFailed callback // - _monitor.wait(); + _condVar.wait(lock); cout << "testing SessionHelper isConnect after connect failure... " << flush; test(_session->isConnected() == false); @@ -547,11 +501,9 @@ Client::run(int argc, char** argv) _factory->destroy(); - if(dispatcher) - { - dispatcher->destroy(); - dispatcher->getThreadControl().join(); - } + // Wait for std::async thread to complete: + dispatcher.destroy(); + dfut.get(); } DEFINE_TEST(Client) diff --git a/cpp/test/Glacier2/sessionHelper/Server.cpp b/cpp/test/Glacier2/sessionHelper/Server.cpp index dd510c28337..df94ef27022 100644 --- a/cpp/test/Glacier2/sessionHelper/Server.cpp +++ b/cpp/test/Glacier2/sessionHelper/Server.cpp @@ -2,7 +2,6 @@ // Copyright (c) ZeroC, Inc. All rights reserved. // -#include <IceUtil/IceUtil.h> #include <Ice/Ice.h> #include <TestHelper.h> #include <Callback.h> @@ -13,25 +12,24 @@ using namespace Test; namespace { -class CallbackI : public Callback +class CallbackI final : public Callback { - public: - virtual void - initiateCallback(ICE_IN(CallbackReceiverPrxPtr) proxy, const Ice::Current& current) + void + initiateCallback(shared_ptr<CallbackReceiverPrx> proxy, const Ice::Current& current) override { proxy->callback(current.ctx); } - virtual void - initiateCallbackEx(ICE_IN(CallbackReceiverPrxPtr) proxy, const Ice::Current& current) + void + initiateCallbackEx(shared_ptr<CallbackReceiverPrx> proxy, const Ice::Current& current) override { proxy->callbackEx(current.ctx); } - virtual void - shutdown(const Ice::Current& current) + void + shutdown(const Ice::Current& current) override { current.adapter->getCommunicator()->shutdown(); } @@ -39,11 +37,11 @@ public: } -class Server : public Test::TestHelper +class Server final : public Test::TestHelper { public: - void run(int, char**); + void run(int, char**) override; }; void @@ -54,7 +52,7 @@ Server::run(int argc, char** argv) communicator->createObjectAdapter("DeactivatedAdapter"); communicator->getProperties()->setProperty("CallbackAdapter.Endpoints", getTestEndpoint()); - Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("CallbackAdapter"); + auto adapter = communicator->createObjectAdapter("CallbackAdapter"); adapter->add(ICE_MAKE_SHARED(CallbackI), Ice::stringToIdentity("callback")); adapter->activate(); communicator->waitForShutdown(); diff --git a/cpp/test/Glacier2/ssl/Client.cpp b/cpp/test/Glacier2/ssl/Client.cpp index bace1ce9100..0f6147c2e72 100644 --- a/cpp/test/Glacier2/ssl/Client.cpp +++ b/cpp/test/Glacier2/ssl/Client.cpp @@ -10,21 +10,21 @@ using namespace std; using namespace Ice; using namespace Test; -class Client : public Test::TestHelper +class Client final : public Test::TestHelper { public: - void run(int, char**); + void run(int, char**) override; }; void Client::run(int argc, char** argv) { - Ice::PropertiesPtr properties = createTestProperties(argc, argv); + auto properties = createTestProperties(argc, argv); properties->setProperty("Ice.Warn.Connections", "0"); Ice::CommunicatorHolder communicator = initialize(argc, argv, properties); - Glacier2::RouterPrx router = Glacier2::RouterPrx::uncheckedCast( + auto router = uncheckedCast<Glacier2::RouterPrx>( communicator->stringToProxy("Glacier2/router:" + getTestEndpoint("tcp"))); communicator->setDefaultRouter(router); @@ -34,7 +34,7 @@ Client::run(int argc, char** argv) cout << "creating non-ssl session with tcp connection... "; try { - Glacier2::SessionPrx session = router->createSession("nossl", ""); + auto session = router->createSession("nossl", ""); session->ice_ping(); router->destroySession(); } @@ -47,7 +47,7 @@ Client::run(int argc, char** argv) cout << "creating ssl session with tcp connection... "; try { - Glacier2::SessionPrx session = router->createSessionFromSecureConnection(); + auto session = router->createSessionFromSecureConnection(); test(false); } catch(const Glacier2::PermissionDeniedException&) @@ -59,8 +59,8 @@ Client::run(int argc, char** argv) // Switch to using the SSL router. First, clear the router. Then // set a new SSL based router. // - communicator->setDefaultRouter(Glacier2::RouterPrx()); - router = Glacier2::RouterPrx::uncheckedCast( + communicator->setDefaultRouter(nullptr); + router = uncheckedCast<Glacier2::RouterPrx>( communicator->stringToProxy("Glacier2/router:" + getTestEndpoint(1, "ssl"))); communicator->setDefaultRouter(router); @@ -70,7 +70,7 @@ Client::run(int argc, char** argv) cout << "creating non-ssl session with ssl connection... "; try { - Glacier2::SessionPrx session = router->createSession("ssl", ""); + auto session = router->createSession("ssl", ""); session->ice_ping(); router->destroySession(); } @@ -83,7 +83,7 @@ Client::run(int argc, char** argv) cout << "creating ssl session with ssl connection... "; try { - Glacier2::SessionPrx session = router->createSessionFromSecureConnection(); + auto session = router->createSessionFromSecureConnection(); session->ice_ping(); router->destroySession(); } @@ -93,8 +93,8 @@ Client::run(int argc, char** argv) } cout << "ok" << endl; - communicator->setDefaultRouter(0); - Ice::ProcessPrx process = Ice::ProcessPrx::checkedCast( + communicator->setDefaultRouter(nullptr); + auto process = checkedCast<Ice::ProcessPrx>( communicator->stringToProxy("Glacier2/admin -f Process:" + getTestEndpoint(2, "tcp"))); process->shutdown(); } diff --git a/cpp/test/Glacier2/ssl/Server.cpp b/cpp/test/Glacier2/ssl/Server.cpp index cec0703fe1a..5f7d0744da4 100644 --- a/cpp/test/Glacier2/ssl/Server.cpp +++ b/cpp/test/Glacier2/ssl/Server.cpp @@ -14,7 +14,7 @@ using namespace Test; namespace { -void testContext(bool ssl, const Ice::CommunicatorPtr& communicator, const Ice::Context& context) +void testContext(bool ssl, const shared_ptr<Ice::Communicator>& communicator, const Ice::Context& context) { Ice::Context ctx = context; if(!ssl) @@ -38,28 +38,28 @@ void testContext(bool ssl, const Ice::CommunicatorPtr& communicator, const Ice:: } -class PermissionsVerifierI : public Glacier2::PermissionsVerifier +class PermissionsVerifierI final : public Glacier2::PermissionsVerifier { public: - virtual bool - checkPermissions(const string& userId, const string&, string&, const Ice::Current& current) const + bool + checkPermissions(string userId, string, string&, const Ice::Current& current) const override { testContext(userId == "ssl", current.adapter->getCommunicator(), current.ctx); return true; } }; -class SSLPermissionsVerifierI : public Glacier2::SSLPermissionsVerifier +class SSLPermissionsVerifierI final : public Glacier2::SSLPermissionsVerifier { public: - virtual bool - authorize(const Glacier2::SSLInfo& info, string&, const Ice::Current& current) const + bool + authorize(Glacier2::SSLInfo info, string&, const Ice::Current& current) const override { testContext(true, current.adapter->getCommunicator(), current.ctx); - IceSSL::CertificatePtr cert = IceSSL::Certificate::decode(info.certs[0]); + auto cert = IceSSL::Certificate::decode(info.certs[0]); test(cert->getIssuerDN() == IceSSL::DistinguishedName( "emailAddress=info@zeroc.com,C=US,ST=Florida,L=Jupiter,O=ZeroC\\, Inc.,OU=Ice,CN=Ice Tests CA")); test(cert->getSubjectDN() == IceSSL::DistinguishedName( @@ -70,7 +70,7 @@ public: } }; -class SessionI : public Glacier2::Session +class SessionI final : public Glacier2::Session { public: @@ -78,8 +78,8 @@ public: { } - virtual void - destroy(const Ice::Current& current) + void + destroy(const Ice::Current& current) override { testContext(_ssl, current.adapter->getCommunicator(), current.ctx); @@ -90,8 +90,8 @@ public: } } - virtual void - ice_ping(const Ice::Current& current) const + void + ice_ping(const Ice::Current& current) const override { testContext(_ssl, current.adapter->getCommunicator(), current.ctx); } @@ -102,26 +102,26 @@ private: const bool _ssl; }; -class SessionManagerI : public Glacier2::SessionManager +class SessionManagerI final : public Glacier2::SessionManager { public: - virtual Glacier2::SessionPrx - create(const string& userId, const Glacier2::SessionControlPrx&, const Ice::Current& current) + shared_ptr<Glacier2::SessionPrx> + create(string userId, shared_ptr<Glacier2::SessionControlPrx>, const Ice::Current& current) override { testContext(userId == "ssl", current.adapter->getCommunicator(), current.ctx); - Glacier2::SessionPtr session = new SessionI(false, userId == "ssl"); - return Glacier2::SessionPrx::uncheckedCast(current.adapter->addWithUUID(session)); + auto session = make_shared<SessionI>(false, userId == "ssl"); + return Ice::uncheckedCast<Glacier2::SessionPrx>(current.adapter->addWithUUID(session)); } }; -class SSLSessionManagerI : public Glacier2::SSLSessionManager +class SSLSessionManagerI final : public Glacier2::SSLSessionManager { public: - virtual Glacier2::SessionPrx - create(const Glacier2::SSLInfo& info, const Glacier2::SessionControlPrx&, const Ice::Current& current) + shared_ptr<Glacier2::SessionPrx> + create(Glacier2::SSLInfo info, shared_ptr<Glacier2::SessionControlPrx>, const Ice::Current& current) override { testContext(true, current.adapter->getCommunicator(), current.ctx); @@ -131,7 +131,7 @@ public: try { - IceSSL::CertificatePtr cert = IceSSL::Certificate::decode(info.certs[0]); + auto cert = IceSSL::Certificate::decode(info.certs[0]); test(cert->getIssuerDN() == IceSSL::DistinguishedName( "emailAddress=info@zeroc.com,C=US,ST=Florida,L=Jupiter,O=ZeroC\\, Inc.,OU=Ice,CN=Ice Tests CA")); test(cert->getSubjectDN() == IceSSL::DistinguishedName( @@ -143,28 +143,28 @@ public: test(false); } - Glacier2::SessionPtr session = new SessionI(true, true); - return Glacier2::SessionPrx::uncheckedCast(current.adapter->addWithUUID(session)); + auto session = make_shared<SessionI>(true, true); + return Ice::uncheckedCast<Glacier2::SessionPrx>(current.adapter->addWithUUID(session)); } }; -class Server : public Test::TestHelper +class Server final : public Test::TestHelper { public: - void run(int, char**); + void run(int, char**) override; }; void Server::run(int argc, char** argv) { Ice::CommunicatorHolder communicator = initialize(argc, argv); - Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapterWithEndpoints("SessionServer", + auto adapter = communicator->createObjectAdapterWithEndpoints("SessionServer", getTestEndpoint(3, "tcp")); - adapter->add(new PermissionsVerifierI, Ice::stringToIdentity("verifier")); - adapter->add(new SSLPermissionsVerifierI, Ice::stringToIdentity("sslverifier")); - adapter->add(new SessionManagerI, Ice::stringToIdentity("sessionmanager")); - adapter->add(new SSLSessionManagerI, Ice::stringToIdentity("sslsessionmanager")); + adapter->add(make_shared<PermissionsVerifierI>(), Ice::stringToIdentity("verifier")); + adapter->add(make_shared<SSLPermissionsVerifierI>(), Ice::stringToIdentity("sslverifier")); + adapter->add(make_shared<SessionManagerI>(), Ice::stringToIdentity("sessionmanager")); + adapter->add(make_shared<SSLSessionManagerI>(), Ice::stringToIdentity("sslsessionmanager")); adapter->activate(); communicator->waitForShutdown(); } diff --git a/cpp/test/Glacier2/staticFiltering/BackendI.h b/cpp/test/Glacier2/staticFiltering/BackendI.h index a22383abb94..9ac0cb658db 100644 --- a/cpp/test/Glacier2/staticFiltering/BackendI.h +++ b/cpp/test/Glacier2/staticFiltering/BackendI.h @@ -7,11 +7,11 @@ #include <Backend.h> -class BackendI : public Test::Backend +class BackendI final : public Test::Backend { public: - virtual void shutdown(const Ice::Current&); + void shutdown(const Ice::Current&) override; }; #endif diff --git a/cpp/test/Glacier2/staticFiltering/Client.cpp b/cpp/test/Glacier2/staticFiltering/Client.cpp index 6d50ee00c89..1c397a7e660 100644 --- a/cpp/test/Glacier2/staticFiltering/Client.cpp +++ b/cpp/test/Glacier2/staticFiltering/Client.cpp @@ -11,17 +11,17 @@ using namespace std; using namespace Ice; using namespace Test; -class AttackClient : public Test::TestHelper +class AttackClient final : public Test::TestHelper { public: - void run(int, char**); + void run(int, char**) override; }; void AttackClient::run(int argc, char** argv) { - Ice::PropertiesPtr properties = createTestProperties(argc, argv); + auto properties = createTestProperties(argc, argv); // // We want to check whether the client retries for evicted // proxies, even with regular retries disabled. @@ -30,29 +30,27 @@ AttackClient::run(int argc, char** argv) Ice::CommunicatorHolder communicator = initialize(argc, argv, properties); - ObjectPrx routerBase = communicator->stringToProxy("Glacier2/router:" + getTestEndpoint(50)); - Glacier2::RouterPrx router = Glacier2::RouterPrx::checkedCast(routerBase); + auto routerBase = communicator->stringToProxy("Glacier2/router:" + getTestEndpoint(50)); + auto router = checkedCast<Glacier2::RouterPrx>(routerBase); test(router); communicator->setDefaultRouter(router); - PropertyDict::const_iterator p; - - PropertyDict badProxies = communicator->getProperties()->getPropertiesForPrefix("Reject.Proxy."); - for(p = badProxies.begin(); p != badProxies.end(); ++p) + auto badProxies = communicator->getProperties()->getPropertiesForPrefix("Reject.Proxy."); + for(const auto& p : badProxies) { try { - Glacier2::SessionPrx session = router->createSession("userid", "abc123"); + auto session = router->createSession("userid", "abc123"); } catch(const Glacier2::CannotCreateSessionException&) { test(false); } - BackendPrx backend = BackendPrx::uncheckedCast(communicator->stringToProxy(p->second)); + auto backend = uncheckedCast<BackendPrx>(communicator->stringToProxy(p.second)); try { backend->ice_ping(); - cerr << "Test failed on : " << p->second << endl; + cerr << "Test failed on : " << p.second << endl; test(false); } catch(const ConnectionLostException&) @@ -87,25 +85,25 @@ AttackClient::run(int argc, char** argv) } } - PropertyDict goodProxies = communicator->getProperties()->getPropertiesForPrefix("Accept.Proxy."); - for(p = goodProxies.begin(); p != goodProxies.end(); ++p) + auto goodProxies = communicator->getProperties()->getPropertiesForPrefix("Accept.Proxy."); + for(const auto& p : goodProxies) { try { - Glacier2::SessionPrx session = router->createSession("userid", "abc123"); + auto session = router->createSession("userid", "abc123"); } catch(const Glacier2::CannotCreateSessionException&) { test(false); } - BackendPrx backend = BackendPrx::uncheckedCast(communicator->stringToProxy(p->second)); + auto backend = uncheckedCast<BackendPrx>(communicator->stringToProxy(p.second)); try { backend->ice_ping(); } catch(const LocalException& ex) { - cerr << p->second << endl; + cerr << p.second << endl; cerr << ex << endl; test(false); } @@ -125,10 +123,10 @@ AttackClient::run(int argc, char** argv) // Stop using router and communicate with backend and router directly // to shut things down. // - communicator->setDefaultRouter(0); + communicator->setDefaultRouter(nullptr); try { - BackendPrx backend = BackendPrx::checkedCast(communicator->stringToProxy("dummy:tcp -p 12010")); + auto backend = checkedCast<BackendPrx>(communicator->stringToProxy("dummy:tcp -p 12010")); backend->shutdown(); } catch(const Ice::LocalException&) @@ -136,8 +134,8 @@ AttackClient::run(int argc, char** argv) test(false); } - ObjectPrx processBase = communicator->stringToProxy("Glacier2/admin -f Process:" + getTestEndpoint(51)); - Ice::ProcessPrx process = Ice::ProcessPrx::checkedCast(processBase); + auto processBase = communicator->stringToProxy("Glacier2/admin -f Process:" + getTestEndpoint(51)); + auto process = checkedCast<Ice::ProcessPrx>(processBase); test(process); process->shutdown(); try diff --git a/cpp/test/Glacier2/staticFiltering/Server.cpp b/cpp/test/Glacier2/staticFiltering/Server.cpp index 93446b0575f..b286d7a404d 100644 --- a/cpp/test/Glacier2/staticFiltering/Server.cpp +++ b/cpp/test/Glacier2/staticFiltering/Server.cpp @@ -15,100 +15,79 @@ using namespace Test; // simplicity, we essentially 'alias' all possible requests to a single // object adapter and a single servant. // -class ServerLocatorRegistry : public virtual LocatorRegistry +class ServerLocatorRegistry final : public LocatorRegistry { public: - virtual void - setAdapterDirectProxy_async(const AMD_LocatorRegistry_setAdapterDirectProxyPtr& cb, const string&, - const ObjectPrx&, const Current&) + void + setAdapterDirectProxyAsync(string, shared_ptr<ObjectPrx>, function<void()> response, function<void(exception_ptr)>, + const Current&) override { - cb->ice_response(); + response(); } - virtual void - setReplicatedAdapterDirectProxy_async(const AMD_LocatorRegistry_setReplicatedAdapterDirectProxyPtr& cb, - const string&, const string&, const ObjectPrx&, const Current&) + void + setReplicatedAdapterDirectProxyAsync(string, string, shared_ptr<ObjectPrx>, + function<void()> response, function<void(exception_ptr)>, + const Current&) override { - cb->ice_response(); + response(); } - virtual void - setServerProcessProxy_async(const AMD_LocatorRegistry_setServerProcessProxyPtr& cb, - const string&, const ProcessPrx&, const Current&) + void + setServerProcessProxyAsync(string, shared_ptr<ProcessPrx>, + function<void()> response, function<void(exception_ptr)>, + const Current&) override { - cb->ice_response(); + response(); } }; -class ServerLocatorI : public virtual Locator +class ServerLocatorI final : public Locator { public: - ServerLocatorI(const BackendPtr& backend, const ObjectAdapterPtr& adapter) : - _backend(backend), + + ServerLocatorI(shared_ptr<Backend> backend, const shared_ptr<ObjectAdapter>& adapter) : + _backend(move(backend)), _adapter(adapter), - _registryPrx( - LocatorRegistryPrx::uncheckedCast( - adapter->add(new ServerLocatorRegistry, Ice::stringToIdentity("registry")))) + _registryPrx(uncheckedCast<LocatorRegistryPrx>( + adapter->add(make_shared<ServerLocatorRegistry>(), Ice::stringToIdentity("registry")))) { } - virtual void - findObjectById_async(const AMD_Locator_findObjectByIdPtr& cb, const Identity& id, const Current&) const + void + findObjectByIdAsync(Identity id, + function<void(const shared_ptr<ObjectPrx>&)> response, function<void(exception_ptr)>, + const Current&) const override { - cb->ice_response(_adapter->createProxy(id)); + response(_adapter->createProxy(id)); } - virtual void - findAdapterById_async(const AMD_Locator_findAdapterByIdPtr& cb, const string&, const Current&) const + void + findAdapterByIdAsync(string, + function<void(const shared_ptr<ObjectPrx>&)> response, function<void(exception_ptr)>, + const Current&) const override { - cb->ice_response(_adapter->createDirectProxy(stringToIdentity("dummy"))); + response(_adapter->createDirectProxy(stringToIdentity("dummy"))); } - virtual LocatorRegistryPrx - getRegistry(const Current&) const + shared_ptr<LocatorRegistryPrx> + getRegistry(const Current&) const override { return _registryPrx; } private: - const BackendPtr _backend; - const ObjectAdapterPtr _adapter; - const LocatorRegistryPrx _registryPrx; -}; - -class ServantLocatorI : public virtual ServantLocator -{ -public: - - ServantLocatorI(const BackendPtr& backend) : - _backend(backend) - { - } - - virtual ObjectPtr locate(const Current&, LocalObjectPtr&) - { - return _backend; - } - - virtual void finished(const Current&, const ObjectPtr&, const LocalObjectPtr&) - { - } - - virtual void deactivate(const string&) - { - } - -private: - - const BackendPtr _backend; + const shared_ptr<Backend> _backend; + const shared_ptr<ObjectAdapter> _adapter; + const shared_ptr<LocatorRegistryPrx> _registryPrx; }; -class BackendServer : public Test::TestHelper +class BackendServer final : public Test::TestHelper { public: - void run(int, char**); + void run(int, char**) override; }; void @@ -119,11 +98,11 @@ BackendServer::run(int argc, char** argv) "tcp -p 12010:ssl -p 12011"); communicator->getProperties()->setProperty("BackendAdapter.Endpoints", endpoints); - ObjectAdapterPtr adapter = communicator->createObjectAdapter("BackendAdapter"); - BackendPtr backend = new BackendI; - Ice::LocatorPtr locator = new ServerLocatorI(backend, adapter); + auto adapter = communicator->createObjectAdapter("BackendAdapter"); + auto backend = make_shared<BackendI>(); + auto locator = make_shared<ServerLocatorI>(backend, adapter); adapter->add(locator, Ice::stringToIdentity("locator")); - adapter->addServantLocator(new ServantLocatorI(backend), ""); + adapter->addDefaultServant(backend, ""); adapter->activate(); communicator->waitForShutdown(); } |