Ice::StringSeq ReplicaGroupFilterI::filter(const string& /* replicaGroupId */, const Ice::StringSeq& adapters, const Ice::ConnectionPtr&, const Ice::Context& ctx) { Ice::Context::const_iterator p = ctx.find("currency"); if(p == ctx.end()) { return adapters; } string currency = p->second; // // Get the Currencies property value from the server descriptor // that owns the adapter and only keep adapters for servers that // are configured with the currency specified in the client // context. // Ice::StringSeq filteredAdapters; for(Ice::StringSeq::const_iterator p = adapters.begin(); p != adapters.end(); ++p) { if(_facade->getPropertyForAdapter(*p, "Currencies").find(currency) != string::npos) { filteredAdapters.push_back(*p); } } return filteredAdapters; }
virtual void createSession() { Ice::Context ctx = _current.ctx; ctx.insert(_context.begin(), _context.end()); _sessionRouter->_sslSessionManager->begin_create(_sslInfo, _control, ctx, newCallback_SSLSessionManager_create( static_cast<CreateSession*>(this), &CreateSession::sessionCreated, &CreateSession::createException)); }
virtual void authorize() { assert(_sessionRouter->_sslVerifier); Ice::Context ctx = _current.ctx; ctx.insert(_context.begin(), _context.end()); _sessionRouter->_sslVerifier->begin_authorize(_sslInfo, ctx, newCallback_SSLPermissionsVerifier_authorize(this, &SSLCreateSession::authorizeResponse, &SSLCreateSession::authorizeException)); }
virtual void authorize() { assert(_sessionRouter->_verifier); Ice::Context ctx = _current.ctx; ctx.insert(_context.begin(), _context.end()); _sessionRouter->_verifier->begin_checkPermissions(_user, _password, ctx, newCallback_PermissionsVerifier_checkPermissions(this, &UserPasswordCreateSession::checkPermissionsResponse, &UserPasswordCreateSession::checkPermissionsException)); }
bool IcePy::contextToDictionary(const Ice::Context& ctx, PyObject* dict) { assert(PyDict_Check(dict)); for(Ice::Context::const_iterator p = ctx.begin(); p != ctx.end(); ++p) { PyObjectHandle key = createString(p->first); PyObjectHandle value = createString(p->second); if(!key.get() || !value.get()) { return false; } if(PyDict_SetItem(dict, key.get(), value.get()) < 0) { return false; } } return true; }
bool IcePy::dictionaryToContext(PyObject* dict, Ice::Context& context) { assert(PyDict_Check(dict)); Py_ssize_t pos = 0; PyObject* key; PyObject* value; while(PyDict_Next(dict, &pos, &key, &value)) { string keystr; if(checkString(key)) { keystr = getString(key); } else if(key != Py_None) { PyErr_Format(PyExc_ValueError, STRCAST("context key must be a string")); return false; } string valuestr; if(checkString(value)) { valuestr = getString(value); } else if(value != Py_None) { PyErr_Format(PyExc_ValueError, STRCAST("context value must be a string")); return false; } context.insert(Ice::Context::value_type(keystr, valuestr)); } return true; }
Test::MyClassPrx allTests(const Ice::CommunicatorPtr& communicator) { cout << "testing stringToProxy... " << flush; string ref = "test:default -p 12010"; Ice::ObjectPrx base = communicator->stringToProxy(ref); test(base); Ice::ObjectPrx b1 = communicator->stringToProxy("test"); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category.empty() && b1->ice_getAdapterId().empty() && b1->ice_getFacet().empty()); b1 = communicator->stringToProxy("test "); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category.empty() && b1->ice_getFacet().empty()); b1 = communicator->stringToProxy(" test "); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category.empty() && b1->ice_getFacet().empty()); b1 = communicator->stringToProxy(" test"); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category.empty() && b1->ice_getFacet().empty()); b1 = communicator->stringToProxy("'test -f facet'"); test(b1->ice_getIdentity().name == "test -f facet" && b1->ice_getIdentity().category.empty() && b1->ice_getFacet().empty()); try { b1 = communicator->stringToProxy("\"test -f facet'"); test(false); } catch(const Ice::ProxyParseException&) { } b1 = communicator->stringToProxy("\"test -f facet\""); test(b1->ice_getIdentity().name == "test -f facet" && b1->ice_getIdentity().category.empty() && b1->ice_getFacet().empty()); b1 = communicator->stringToProxy("\"test -f facet@test\""); test(b1->ice_getIdentity().name == "test -f facet@test" && b1->ice_getIdentity().category.empty() && b1->ice_getFacet().empty()); b1 = communicator->stringToProxy("\"test -f facet@test @test\""); test(b1->ice_getIdentity().name == "test -f facet@test @test" && b1->ice_getIdentity().category.empty() && b1->ice_getFacet().empty()); try { b1 = communicator->stringToProxy("test test"); test(false); } catch(const Ice::ProxyParseException&) { } b1 = communicator->stringToProxy("test\\040test"); test(b1->ice_getIdentity().name == "test test" && b1->ice_getIdentity().category.empty()); try { b1 = communicator->stringToProxy("test\\777"); test(false); } catch(const Ice::IdentityParseException&) { } b1 = communicator->stringToProxy("test\\40test"); test(b1->ice_getIdentity().name == "test test"); // Test some octal and hex corner cases. b1 = communicator->stringToProxy("test\\4test"); test(b1->ice_getIdentity().name == "test\4test"); b1 = communicator->stringToProxy("test\\04test"); test(b1->ice_getIdentity().name == "test\4test"); b1 = communicator->stringToProxy("test\\004test"); test(b1->ice_getIdentity().name == "test\4test"); b1 = communicator->stringToProxy("test\\1114test"); test(b1->ice_getIdentity().name == "test\1114test"); b1 = communicator->stringToProxy("test\\b\\f\\n\\r\\t\\'\\\"\\\\test"); test(b1->ice_getIdentity().name == "test\b\f\n\r\t\'\"\\test" && b1->ice_getIdentity().category.empty()); b1 = communicator->stringToProxy("category/test"); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category == "category" && b1->ice_getAdapterId().empty()); b1 = communicator->stringToProxy(""); test(!b1); b1 = communicator->stringToProxy("\"\""); test(!b1); try { b1 = communicator->stringToProxy("\"\" test"); // Invalid trailing characters. test(false); } catch(const Ice::ProxyParseException&) { } try { b1 = communicator->stringToProxy("test:"); // Missing endpoint. test(false); } catch(const Ice::EndpointParseException&) { } b1 = communicator->stringToProxy("test@adapter"); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category.empty() && b1->ice_getAdapterId() == "adapter"); try { b1 = communicator->stringToProxy("id@adapter test"); test(false); } catch(const Ice::ProxyParseException&) { } b1 = communicator->stringToProxy("category/test@adapter"); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category == "category" && b1->ice_getAdapterId() == "adapter"); b1 = communicator->stringToProxy("category/test@adapter:tcp"); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category == "category" && b1->ice_getAdapterId() == "adapter:tcp"); b1 = communicator->stringToProxy("'category 1/test'@adapter"); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category == "category 1" && b1->ice_getAdapterId() == "adapter"); b1 = communicator->stringToProxy("'category/test 1'@adapter"); test(b1->ice_getIdentity().name == "test 1" && b1->ice_getIdentity().category == "category" && b1->ice_getAdapterId() == "adapter"); b1 = communicator->stringToProxy("'category/test'@'adapter 1'"); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category == "category" && b1->ice_getAdapterId() == "adapter 1"); b1 = communicator->stringToProxy("\"category \\/test@foo/test\"@adapter"); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category == "category /test@foo" && b1->ice_getAdapterId() == "adapter"); b1 = communicator->stringToProxy("\"category \\/test@foo/test\"@\"adapter:tcp\""); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category == "category /test@foo" && b1->ice_getAdapterId() == "adapter:tcp"); b1 = communicator->stringToProxy("id -f facet"); test(b1->ice_getIdentity().name == "id" && b1->ice_getIdentity().category.empty() && b1->ice_getFacet() == "facet"); b1 = communicator->stringToProxy("id -f 'facet x'"); test(b1->ice_getIdentity().name == "id" && b1->ice_getIdentity().category.empty() && b1->ice_getFacet() == "facet x"); b1 = communicator->stringToProxy("id -f \"facet x\""); test(b1->ice_getIdentity().name == "id" && b1->ice_getIdentity().category.empty() && b1->ice_getFacet() == "facet x"); try { b1 = communicator->stringToProxy("id -f \"facet x"); test(false); } catch(const Ice::ProxyParseException&) { } try { b1 = communicator->stringToProxy("id -f \'facet x"); test(false); } catch(const Ice::ProxyParseException&) { } b1 = communicator->stringToProxy("test -f facet:tcp"); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category.empty() && b1->ice_getFacet() == "facet" && b1->ice_getAdapterId().empty()); b1 = communicator->stringToProxy("test -f \"facet:tcp\""); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category.empty() && b1->ice_getFacet() == "facet:tcp" && b1->ice_getAdapterId().empty()); b1 = communicator->stringToProxy("test -f facet@test"); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category.empty() && b1->ice_getFacet() == "facet" && b1->ice_getAdapterId() == "test"); b1 = communicator->stringToProxy("test -f 'facet@test'"); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category.empty() && b1->ice_getFacet() == "facet@test" && b1->ice_getAdapterId().empty()); b1 = communicator->stringToProxy("test -f 'facet@test'@test"); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category.empty() && b1->ice_getFacet() == "facet@test" && b1->ice_getAdapterId() == "test"); try { b1 = communicator->stringToProxy("test -f facet@test @test"); test(false); } catch(const Ice::ProxyParseException&) { } b1 = communicator->stringToProxy("test"); test(b1->ice_isTwoway()); b1 = communicator->stringToProxy("test -t"); test(b1->ice_isTwoway()); b1 = communicator->stringToProxy("test -o"); test(b1->ice_isOneway()); b1 = communicator->stringToProxy("test -O"); test(b1->ice_isBatchOneway()); b1 = communicator->stringToProxy("test -d"); test(b1->ice_isDatagram()); b1 = communicator->stringToProxy("test -D"); test(b1->ice_isBatchDatagram()); b1 = communicator->stringToProxy("test"); test(!b1->ice_isSecure()); b1 = communicator->stringToProxy("test -s"); test(b1->ice_isSecure()); test(b1->ice_getEncodingVersion() == Ice::currentEncoding); b1 = communicator->stringToProxy("test -e 1.0"); test(b1->ice_getEncodingVersion().major == 1 && b1->ice_getEncodingVersion().minor == 0); b1 = communicator->stringToProxy("test -e 6.5"); test(b1->ice_getEncodingVersion().major == 6 && b1->ice_getEncodingVersion().minor == 5); b1 = communicator->stringToProxy("test -p 1.0 -e 1.0"); test(b1->ice_toString() == "test -t -e 1.0"); b1 = communicator->stringToProxy("test -p 6.5 -e 1.0"); test(b1->ice_toString() == "test -t -p 6.5 -e 1.0"); try { b1 = communicator->stringToProxy("test:tcp@adapterId"); test(false); } catch(const Ice::EndpointParseException&) { } // This is an unknown endpoint warning, not a parse exception. // //try //{ // b1 = communicator->stringToProxy("test -f the:facet:tcp"); // test(false); //} //catch(const Ice::EndpointParseException&) //{ //} try { b1 = communicator->stringToProxy("test::tcp"); test(false); } catch(const Ice::EndpointParseException&) { } // // Test for bug ICE-5543: escaped escapes in stringToIdentity // Ice::Identity id = { "test", ",X2QNUAzSBcJ_e$AV;E\\" }; Ice::Identity id2 = communicator->stringToIdentity(communicator->identityToString(id)); test(id == id2); id.name = "test"; id.category = ",X2QNUAz\\SB\\/cJ_e$AV;E\\\\"; id2 = communicator->stringToIdentity(communicator->identityToString(id)); test(id == id2); cout << "ok" << endl; cout << "testing propertyToProxy... " << flush; Ice::PropertiesPtr prop = communicator->getProperties(); string propertyPrefix = "Foo.Proxy"; prop->setProperty(propertyPrefix, "test:default -p 12010"); b1 = communicator->propertyToProxy(propertyPrefix); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category.empty() && b1->ice_getAdapterId().empty() && b1->ice_getFacet().empty()); string property; property = propertyPrefix + ".Locator"; test(!b1->ice_getLocator()); prop->setProperty(property, "locator:default -p 10000"); b1 = communicator->propertyToProxy(propertyPrefix); test(b1->ice_getLocator() && b1->ice_getLocator()->ice_getIdentity().name == "locator"); prop->setProperty(property, ""); property = propertyPrefix + ".LocatorCacheTimeout"; test(b1->ice_getLocatorCacheTimeout() == -1); prop->setProperty(property, "1"); b1 = communicator->propertyToProxy(propertyPrefix); test(b1->ice_getLocatorCacheTimeout() == 1); prop->setProperty(property, ""); // Now retest with an indirect proxy. prop->setProperty(propertyPrefix, "test"); property = propertyPrefix + ".Locator"; prop->setProperty(property, "locator:default -p 10000"); b1 = communicator->propertyToProxy(propertyPrefix); test(b1->ice_getLocator() && b1->ice_getLocator()->ice_getIdentity().name == "locator"); prop->setProperty(property, ""); property = propertyPrefix + ".LocatorCacheTimeout"; test(b1->ice_getLocatorCacheTimeout() == -1); prop->setProperty(property, "1"); b1 = communicator->propertyToProxy(propertyPrefix); test(b1->ice_getLocatorCacheTimeout() == 1); prop->setProperty(property, ""); // This cannot be tested so easily because the property is cached // on communicator initialization. // //prop->setProperty("Ice.Default.LocatorCacheTimeout", "60"); //b1 = communicator->propertyToProxy(propertyPrefix); //test(b1->ice_getLocatorCacheTimeout() == 60); //prop->setProperty("Ice.Default.LocatorCacheTimeout", ""); prop->setProperty(propertyPrefix, "test:default -p 12010"); property = propertyPrefix + ".Router"; test(!b1->ice_getRouter()); prop->setProperty(property, "router:default -p 10000"); b1 = communicator->propertyToProxy(propertyPrefix); test(b1->ice_getRouter() && b1->ice_getRouter()->ice_getIdentity().name == "router"); prop->setProperty(property, ""); property = propertyPrefix + ".PreferSecure"; test(!b1->ice_isPreferSecure()); prop->setProperty(property, "1"); b1 = communicator->propertyToProxy(propertyPrefix); test(b1->ice_isPreferSecure()); prop->setProperty(property, ""); property = propertyPrefix + ".ConnectionCached"; test(b1->ice_isConnectionCached()); prop->setProperty(property, "0"); b1 = communicator->propertyToProxy(propertyPrefix); test(!b1->ice_isConnectionCached()); prop->setProperty(property, ""); property = propertyPrefix + ".InvocationTimeout"; test(b1->ice_getInvocationTimeout() == -1); prop->setProperty(property, "1000"); b1 = communicator->propertyToProxy(propertyPrefix); test(b1->ice_getInvocationTimeout() == 1000); prop->setProperty(property, ""); property = propertyPrefix + ".EndpointSelection"; test(b1->ice_getEndpointSelection() == Ice::Random); prop->setProperty(property, "Random"); b1 = communicator->propertyToProxy(propertyPrefix); test(b1->ice_getEndpointSelection() == Ice::Random); prop->setProperty(property, "Ordered"); b1 = communicator->propertyToProxy(propertyPrefix); test(b1->ice_getEndpointSelection() == Ice::Ordered); prop->setProperty(property, ""); property = propertyPrefix + ".CollocationOptimized"; test(b1->ice_isCollocationOptimized()); prop->setProperty(property, "0"); b1 = communicator->propertyToProxy(propertyPrefix); test(!b1->ice_isCollocationOptimized()); prop->setProperty(property, ""); property = propertyPrefix + ".Context.c1"; test(b1->ice_getContext()["c1"].empty()); prop->setProperty(property, "TEST"); b1 = communicator->propertyToProxy(propertyPrefix); test(b1->ice_getContext()["c1"] == "TEST"); property = propertyPrefix + ".Context.c2"; test(b1->ice_getContext()["c2"].empty()); prop->setProperty(property, "TEST"); b1 = communicator->propertyToProxy(propertyPrefix); test(b1->ice_getContext()["c2"] == "TEST"); prop->setProperty(propertyPrefix + ".Context.c1", ""); prop->setProperty(propertyPrefix + ".Context.c2", ""); cout << "ok" << endl; cout << "testing proxyToProperty... " << flush; b1 = communicator->stringToProxy("test"); b1 = b1->ice_collocationOptimized(true); b1 = b1->ice_connectionCached(true); b1 = b1->ice_preferSecure(false); b1 = b1->ice_endpointSelection(Ice::Ordered); b1 = b1->ice_locatorCacheTimeout(100); b1 = b1->ice_invocationTimeout(1234); Ice::EncodingVersion v = { 1, 0 }; b1 = b1->ice_encodingVersion(v); Ice::ObjectPrx router = communicator->stringToProxy("router"); router = router->ice_collocationOptimized(false); router = router->ice_connectionCached(true); router = router->ice_preferSecure(true); router = router->ice_endpointSelection(Ice::Random); router = router->ice_locatorCacheTimeout(200); router = router->ice_invocationTimeout(1500); Ice::ObjectPrx locator = communicator->stringToProxy("locator"); locator = locator->ice_collocationOptimized(true); locator = locator->ice_connectionCached(false); locator = locator->ice_preferSecure(true); locator = locator->ice_endpointSelection(Ice::Random); locator = locator->ice_locatorCacheTimeout(300); locator = locator->ice_invocationTimeout(1500); locator = locator->ice_router(Ice::RouterPrx::uncheckedCast(router)); b1 = b1->ice_locator(Ice::LocatorPrx::uncheckedCast(locator)); Ice::PropertyDict proxyProps = communicator->proxyToProperty(b1, "Test"); test(proxyProps.size() == 21); test(proxyProps["Test"] == "test -t -e 1.0"); test(proxyProps["Test.CollocationOptimized"] == "1"); test(proxyProps["Test.ConnectionCached"] == "1"); test(proxyProps["Test.PreferSecure"] == "0"); test(proxyProps["Test.EndpointSelection"] == "Ordered"); test(proxyProps["Test.LocatorCacheTimeout"] == "100"); test(proxyProps["Test.InvocationTimeout"] == "1234"); test(proxyProps["Test.Locator"] == "locator -t -e " + Ice::encodingVersionToString(Ice::currentEncoding)); // Locator collocation optimization is always disabled. //test(proxyProps["Test.Locator.CollocationOptimized"] == "1"); test(proxyProps["Test.Locator.ConnectionCached"] == "0"); test(proxyProps["Test.Locator.PreferSecure"] == "1"); test(proxyProps["Test.Locator.EndpointSelection"] == "Random"); test(proxyProps["Test.Locator.LocatorCacheTimeout"] == "300"); test(proxyProps["Test.Locator.InvocationTimeout"] == "1500"); test(proxyProps["Test.Locator.Router"] == "router -t -e " + Ice::encodingVersionToString(Ice::currentEncoding)); test(proxyProps["Test.Locator.Router.CollocationOptimized"] == "0"); test(proxyProps["Test.Locator.Router.ConnectionCached"] == "1"); test(proxyProps["Test.Locator.Router.PreferSecure"] == "1"); test(proxyProps["Test.Locator.Router.EndpointSelection"] == "Random"); test(proxyProps["Test.Locator.Router.LocatorCacheTimeout"] == "200"); test(proxyProps["Test.Locator.Router.InvocationTimeout"] == "1500"); cout << "ok" << endl; cout << "testing ice_getCommunicator... " << flush; test(base->ice_getCommunicator() == communicator); cout << "ok" << endl; cout << "testing proxy methods... " << flush; test(communicator->identityToString(base->ice_identity(communicator->stringToIdentity("other"))->ice_getIdentity()) == "other"); test(base->ice_facet("facet")->ice_getFacet() == "facet"); test(base->ice_adapterId("id")->ice_getAdapterId() == "id"); test(base->ice_twoway()->ice_isTwoway()); test(base->ice_oneway()->ice_isOneway()); test(base->ice_batchOneway()->ice_isBatchOneway()); test(base->ice_datagram()->ice_isDatagram()); test(base->ice_batchDatagram()->ice_isBatchDatagram()); test(base->ice_secure(true)->ice_isSecure()); test(!base->ice_secure(false)->ice_isSecure()); test(base->ice_collocationOptimized(true)->ice_isCollocationOptimized()); test(!base->ice_collocationOptimized(false)->ice_isCollocationOptimized()); test(base->ice_preferSecure(true)->ice_isPreferSecure()); test(!base->ice_preferSecure(false)->ice_isPreferSecure()); test(base->ice_encodingVersion(Ice::Encoding_1_0)->ice_getEncodingVersion() == Ice::Encoding_1_0); test(base->ice_encodingVersion(Ice::Encoding_1_1)->ice_getEncodingVersion() == Ice::Encoding_1_1); test(base->ice_encodingVersion(Ice::Encoding_1_0)->ice_getEncodingVersion() != Ice::Encoding_1_1); try { base->ice_timeout(0); test(false); } catch(const IceUtil::IllegalArgumentException&) { } try { base->ice_timeout(-1); } catch(const IceUtil::IllegalArgumentException&) { test(false); } try { base->ice_timeout(-2); test(false); } catch(const IceUtil::IllegalArgumentException&) { } try { base->ice_invocationTimeout(0); test(false); } catch(const IceUtil::IllegalArgumentException&) { } try { base->ice_invocationTimeout(-1); base->ice_invocationTimeout(-2); } catch(const IceUtil::IllegalArgumentException&) { test(false); } try { base->ice_invocationTimeout(-3); test(false); } catch(const IceUtil::IllegalArgumentException&) { } try { base->ice_locatorCacheTimeout(0); } catch(const IceUtil::IllegalArgumentException&) { test(false); } try { base->ice_locatorCacheTimeout(-1); } catch(const IceUtil::IllegalArgumentException&) { test(false); } try { base->ice_locatorCacheTimeout(-2); test(false); } catch(const IceUtil::IllegalArgumentException&) { } cout << "ok" << endl; cout << "testing proxy comparison... " << flush; test(communicator->stringToProxy("foo") == communicator->stringToProxy("foo")); test(communicator->stringToProxy("foo") != communicator->stringToProxy("foo2")); test(communicator->stringToProxy("foo") < communicator->stringToProxy("foo2")); test(!(communicator->stringToProxy("foo2") < communicator->stringToProxy("foo"))); Ice::ObjectPrx compObj = communicator->stringToProxy("foo"); test(compObj->ice_facet("facet") == compObj->ice_facet("facet")); test(compObj->ice_facet("facet") != compObj->ice_facet("facet1")); test(compObj->ice_facet("facet") < compObj->ice_facet("facet1")); test(!(compObj->ice_facet("facet") < compObj->ice_facet("facet"))); test(compObj->ice_oneway() == compObj->ice_oneway()); test(compObj->ice_oneway() != compObj->ice_twoway()); test(compObj->ice_twoway() < compObj->ice_oneway()); test(!(compObj->ice_oneway() < compObj->ice_twoway())); test(compObj->ice_secure(true) == compObj->ice_secure(true)); test(compObj->ice_secure(false) != compObj->ice_secure(true)); test(compObj->ice_secure(false) < compObj->ice_secure(true)); test(!(compObj->ice_secure(true) < compObj->ice_secure(false))); test(compObj->ice_collocationOptimized(true) == compObj->ice_collocationOptimized(true)); test(compObj->ice_collocationOptimized(false) != compObj->ice_collocationOptimized(true)); test(compObj->ice_collocationOptimized(false) < compObj->ice_collocationOptimized(true)); test(!(compObj->ice_collocationOptimized(true) < compObj->ice_collocationOptimized(false))); test(compObj->ice_connectionCached(true) == compObj->ice_connectionCached(true)); test(compObj->ice_connectionCached(false) != compObj->ice_connectionCached(true)); test(compObj->ice_connectionCached(false) < compObj->ice_connectionCached(true)); test(!(compObj->ice_connectionCached(true) < compObj->ice_connectionCached(false))); test(compObj->ice_endpointSelection(Ice::Random) == compObj->ice_endpointSelection(Ice::Random)); test(compObj->ice_endpointSelection(Ice::Random) != compObj->ice_endpointSelection(Ice::Ordered)); test(compObj->ice_endpointSelection(Ice::Random) < compObj->ice_endpointSelection(Ice::Ordered)); test(!(compObj->ice_endpointSelection(Ice::Ordered) < compObj->ice_endpointSelection(Ice::Random))); test(compObj->ice_connectionId("id2") == compObj->ice_connectionId("id2")); test(compObj->ice_connectionId("id1") != compObj->ice_connectionId("id2")); test(compObj->ice_connectionId("id1") < compObj->ice_connectionId("id2")); test(!(compObj->ice_connectionId("id2") < compObj->ice_connectionId("id1"))); test(compObj->ice_connectionId("id1")->ice_getConnectionId() == "id1"); test(compObj->ice_connectionId("id2")->ice_getConnectionId() == "id2"); test(compObj->ice_compress(true) == compObj->ice_compress(true)); test(compObj->ice_compress(false) != compObj->ice_compress(true)); test(compObj->ice_compress(false) < compObj->ice_compress(true)); test(!(compObj->ice_compress(true) < compObj->ice_compress(false))); test(compObj->ice_timeout(20) == compObj->ice_timeout(20)); test(compObj->ice_timeout(10) != compObj->ice_timeout(20)); test(compObj->ice_timeout(10) < compObj->ice_timeout(20)); test(!(compObj->ice_timeout(20) < compObj->ice_timeout(10))); Ice::LocatorPrx loc1 = Ice::LocatorPrx::uncheckedCast(communicator->stringToProxy("loc1:default -p 10000")); Ice::LocatorPrx loc2 = Ice::LocatorPrx::uncheckedCast(communicator->stringToProxy("loc2:default -p 10000")); test(compObj->ice_locator(0) == compObj->ice_locator(0)); test(compObj->ice_locator(loc1) == compObj->ice_locator(loc1)); test(compObj->ice_locator(loc1) != compObj->ice_locator(0)); test(compObj->ice_locator(0) != compObj->ice_locator(loc2)); test(compObj->ice_locator(loc1) != compObj->ice_locator(loc2)); test(compObj->ice_locator(0) < compObj->ice_locator(loc1)); test(!(compObj->ice_locator(loc1) < compObj->ice_locator(0))); test(compObj->ice_locator(loc1) < compObj->ice_locator(loc2)); test(!(compObj->ice_locator(loc2) < compObj->ice_locator(loc1))); Ice::RouterPrx rtr1 = Ice::RouterPrx::uncheckedCast(communicator->stringToProxy("rtr1:default -p 10000")); Ice::RouterPrx rtr2 = Ice::RouterPrx::uncheckedCast(communicator->stringToProxy("rtr2:default -p 10000")); test(compObj->ice_router(0) == compObj->ice_router(0)); test(compObj->ice_router(rtr1) == compObj->ice_router(rtr1)); test(compObj->ice_router(rtr1) != compObj->ice_router(0)); test(compObj->ice_router(0) != compObj->ice_router(rtr2)); test(compObj->ice_router(rtr1) != compObj->ice_router(rtr2)); test(compObj->ice_router(0) < compObj->ice_router(rtr1)); test(!(compObj->ice_router(rtr1) < compObj->ice_router(0))); test(compObj->ice_router(rtr1) < compObj->ice_router(rtr2)); test(!(compObj->ice_router(rtr2) < compObj->ice_router(rtr1))); Ice::Context ctx1; ctx1["ctx1"] = "v1"; Ice::Context ctx2; ctx2["ctx2"] = "v2"; test(compObj->ice_context(Ice::Context()) == compObj->ice_context(Ice::Context())); test(compObj->ice_context(ctx1) == compObj->ice_context(ctx1)); test(compObj->ice_context(ctx1) != compObj->ice_context(Ice::Context())); test(compObj->ice_context(Ice::Context()) != compObj->ice_context(ctx2)); test(compObj->ice_context(ctx1) != compObj->ice_context(ctx2)); test(compObj->ice_context(ctx1) < compObj->ice_context(ctx2)); test(!(compObj->ice_context(ctx2) < compObj->ice_context(ctx1))); test(compObj->ice_preferSecure(true) == compObj->ice_preferSecure(true)); test(compObj->ice_preferSecure(true) != compObj->ice_preferSecure(false)); test(compObj->ice_preferSecure(false) < compObj->ice_preferSecure(true)); test(!(compObj->ice_preferSecure(true) < compObj->ice_preferSecure(false))); Ice::ObjectPrx compObj1 = communicator->stringToProxy("foo:tcp -h 127.0.0.1 -p 10000"); Ice::ObjectPrx compObj2 = communicator->stringToProxy("foo:tcp -h 127.0.0.1 -p 10001"); test(compObj1 != compObj2); test(compObj1 < compObj2); test(!(compObj2 < compObj1)); compObj1 = communicator->stringToProxy("foo@MyAdapter1"); compObj2 = communicator->stringToProxy("foo@MyAdapter2"); test(compObj1 != compObj2); test(compObj1 < compObj2); test(!(compObj2 < compObj1)); test(compObj1->ice_locatorCacheTimeout(20) == compObj1->ice_locatorCacheTimeout(20)); test(compObj1->ice_locatorCacheTimeout(10) != compObj1->ice_locatorCacheTimeout(20)); test(compObj1->ice_locatorCacheTimeout(10) < compObj1->ice_locatorCacheTimeout(20)); test(!(compObj1->ice_locatorCacheTimeout(20) < compObj1->ice_locatorCacheTimeout(10))); test(compObj1->ice_invocationTimeout(20) == compObj1->ice_invocationTimeout(20)); test(compObj1->ice_invocationTimeout(10) != compObj1->ice_invocationTimeout(20)); test(compObj1->ice_invocationTimeout(10) < compObj1->ice_invocationTimeout(20)); test(!(compObj1->ice_invocationTimeout(20) < compObj1->ice_invocationTimeout(10))); compObj1 = communicator->stringToProxy("foo:tcp -h 127.0.0.1 -p 1000"); compObj2 = communicator->stringToProxy("foo@MyAdapter1"); test(compObj1 != compObj2); test(compObj1 < compObj2); test(!(compObj2 < compObj1)); Ice::EndpointSeq endpts1 = communicator->stringToProxy("foo:tcp -h 127.0.0.1 -p 10000")->ice_getEndpoints(); Ice::EndpointSeq endpts2 = communicator->stringToProxy("foo:tcp -h 127.0.0.1 -p 10001")->ice_getEndpoints(); test(endpts1 != endpts2); test(endpts1 < endpts2); test(!(endpts2 < endpts1)); test(endpts1 == communicator->stringToProxy("foo:tcp -h 127.0.0.1 -p 10000")->ice_getEndpoints()); test(compObj1->ice_encodingVersion(Ice::Encoding_1_0) == compObj1->ice_encodingVersion(Ice::Encoding_1_0)); test(compObj1->ice_encodingVersion(Ice::Encoding_1_0) != compObj1->ice_encodingVersion(Ice::Encoding_1_1)); test(compObj->ice_encodingVersion(Ice::Encoding_1_0) < compObj->ice_encodingVersion(Ice::Encoding_1_1)); test(!(compObj->ice_encodingVersion(Ice::Encoding_1_1) < compObj->ice_encodingVersion(Ice::Encoding_1_0))); // // TODO: Ideally we should also test comparison of fixed proxies. // cout << "ok" << endl; cout << "testing checked cast... " << flush; Test::MyClassPrx cl = Test::MyClassPrx::checkedCast(base); test(cl); Test::MyDerivedClassPrx derived = Test::MyDerivedClassPrx::checkedCast(cl); test(derived); test(cl == base); test(derived == base); test(cl == derived); Ice::LocatorPrx loc = Ice::LocatorPrx::checkedCast(base); test(loc == 0); // // Upcasting // Test::MyClassPrx cl2 = Test::MyClassPrx::checkedCast(derived); Ice::ObjectPrx obj = Ice::ObjectPrx::checkedCast(derived); test(cl2); test(obj); test(cl2 == obj); test(cl2 == derived); // // Now with alternate API // cl = checkedCast<Test::MyClassPrx>(base); test(cl); derived = checkedCast<Test::MyDerivedClassPrx>(cl); test(derived); test(cl == base); test(derived == base); test(cl == derived); loc = checkedCast<Ice::LocatorPrx>(base); test(loc == 0); cl2 = checkedCast<Test::MyClassPrx>(derived); obj = checkedCast<Ice::ObjectPrx>(derived); test(cl2); test(obj); test(cl2 == obj); test(cl2 == derived); cout << "ok" << endl; cout << "testing checked cast with context... " << flush; Ice::Context c = cl->getContext(); test(c.size() == 0); c["one"] = "hello"; c["two"] = "world"; cl = Test::MyClassPrx::checkedCast(base, c); Ice::Context c2 = cl->getContext(); test(c == c2); // // Now with alternate API // cl = checkedCast<Test::MyClassPrx>(base); c = cl->getContext(); test(c.size() == 0); cl = checkedCast<Test::MyClassPrx>(base, c); c2 = cl->getContext(); test(c == c2); cout << "ok" << endl; cout << "testing encoding versioning... " << flush; string ref20 = "test -e 2.0:default -p 12010"; Test::MyClassPrx cl20 = Test::MyClassPrx::uncheckedCast(communicator->stringToProxy(ref20)); try { cl20->ice_ping(); test(false); } catch(const Ice::UnsupportedEncodingException&) { // Server 2.0 endpoint doesn't support 1.1 version. } string ref10 = "test -e 1.0:default -p 12010"; Test::MyClassPrx cl10 = Test::MyClassPrx::uncheckedCast(communicator->stringToProxy(ref10)); cl10->ice_ping(); cl10->ice_encodingVersion(Ice::Encoding_1_0)->ice_ping(); cl->ice_encodingVersion(Ice::Encoding_1_0)->ice_ping(); // 1.3 isn't supported but since a 1.3 proxy supports 1.1, the // call will use the 1.1 encoding string ref13 = "test -e 1.3:default -p 12010"; Test::MyClassPrx cl13 = Test::MyClassPrx::uncheckedCast(communicator->stringToProxy(ref13)); cl13->ice_ping(); cl13->end_ice_ping(cl13->begin_ice_ping()); try { // Send request with bogus 1.2 encoding. Ice::EncodingVersion version = { 1, 2 }; Ice::OutputStreamPtr out = Ice::createOutputStream(communicator); out->startEncapsulation(); out->endEncapsulation(); vector<Ice::Byte> inEncaps; out->finished(inEncaps); inEncaps[4] = version.major; inEncaps[5] = version.minor; vector<Ice::Byte> outEncaps; cl->ice_invoke("ice_ping", Ice::Normal, inEncaps, outEncaps); test(false); } catch(const Ice::UnknownLocalException& ex) { // The server thrown an UnsupportedEncodingException test(ex.unknown.find("UnsupportedEncodingException") != string::npos); } try { // Send request with bogus 2.0 encoding. Ice::EncodingVersion version = { 2, 0 }; Ice::OutputStreamPtr out = Ice::createOutputStream(communicator); out->startEncapsulation(); out->endEncapsulation(); vector<Ice::Byte> inEncaps; out->finished(inEncaps); inEncaps[4] = version.major; inEncaps[5] = version.minor; vector<Ice::Byte> outEncaps; cl->ice_invoke("ice_ping", Ice::Normal, inEncaps, outEncaps); test(false); } catch(const Ice::UnknownLocalException& ex) { // The server thrown an UnsupportedEncodingException test(ex.unknown.find("UnsupportedEncodingException") != string::npos); } cout << "ok" << endl; cout << "testing protocol versioning... " << flush; ref20 = "test -p 2.0:default -p 12010"; cl20 = Test::MyClassPrx::uncheckedCast(communicator->stringToProxy(ref20)); try { cl20->ice_ping(); test(false); } catch(const Ice::UnsupportedProtocolException&) { // Server 2.0 proxy doesn't support 1.0 version. } ref10 = "test -p 1.0:default -p 12010"; cl10 = Test::MyClassPrx::uncheckedCast(communicator->stringToProxy(ref10)); cl10->ice_ping(); // 1.3 isn't supported but since a 1.3 proxy supports 1.0, the // call will use the 1.0 encoding ref13 = "test -p 1.3:default -p 12010"; cl13 = Test::MyClassPrx::uncheckedCast(communicator->stringToProxy(ref13)); cl13->ice_ping(); cl13->end_ice_ping(cl13->begin_ice_ping()); cout << "ok" <<endl; cout << "testing opaque endpoints... " << flush; try { // Invalid -x option Ice::ObjectPrx p = communicator->stringToProxy("id:opaque -t 99 -v abc -x abc"); test(false); } catch(const Ice::EndpointParseException&) { } try { // Missing -t and -v Ice::ObjectPrx p = communicator->stringToProxy("id:opaque"); test(false); } catch(const Ice::EndpointParseException&) { } try { // Repeated -t Ice::ObjectPrx p = communicator->stringToProxy("id:opaque -t 1 -t 1 -v abc"); test(false); } catch(const Ice::EndpointParseException&) { } try { // Repeated -v Ice::ObjectPrx p = communicator->stringToProxy("id:opaque -t 1 -v abc -v abc"); test(false); } catch(const Ice::EndpointParseException&) { } try { // Missing -t Ice::ObjectPrx p = communicator->stringToProxy("id:opaque -v abc"); test(false); } catch(const Ice::EndpointParseException&) { } try { // Missing -v Ice::ObjectPrx p = communicator->stringToProxy("id:opaque -t 1"); test(false); } catch(const Ice::EndpointParseException&) { } try { // Missing arg for -t Ice::ObjectPrx p = communicator->stringToProxy("id:opaque -t -v abc"); test(false); } catch(const Ice::EndpointParseException&) { } try { // Missing arg for -v Ice::ObjectPrx p = communicator->stringToProxy("id:opaque -t 1 -v"); test(false); } catch(const Ice::EndpointParseException&) { } try { // Not a number for -t Ice::ObjectPrx p = communicator->stringToProxy("id:opaque -t x -v abc"); test(false); } catch(const Ice::EndpointParseException&) { } try { // < 0 for -t Ice::ObjectPrx p = communicator->stringToProxy("id:opaque -t -1 -v abc"); test(false); } catch(const Ice::EndpointParseException&) { } try { // Invalid char for -v Ice::ObjectPrx p = communicator->stringToProxy("id:opaque -t 99 -v x?c"); test(false); } catch(const Ice::EndpointParseException&) { } // Legal TCP endpoint expressed as opaque endpoint Ice::ObjectPrx p1 = communicator->stringToProxy("test -e 1.1:opaque -e 1.0 -t 1 -v CTEyNy4wLjAuMeouAAAQJwAAAA=="); string pstr = communicator->proxyToString(p1); test(pstr == "test -t -e 1.1:tcp -h 127.0.0.1 -p 12010 -t 10000"); // Opaque endpoint encoded with 1.1 encoding. Ice::ObjectPrx p2 = communicator->stringToProxy("test -e 1.1:opaque -e 1.1 -t 1 -v CTEyNy4wLjAuMeouAAAQJwAAAA=="); test(communicator->proxyToString(p2) == "test -t -e 1.1:tcp -h 127.0.0.1 -p 12010 -t 10000"); if(communicator->getProperties()->getPropertyAsInt("Ice.IPv6") == 0) { // Working? #ifndef ICE_OS_WINRT const bool ssl = communicator->getProperties()->getProperty("Ice.Default.Protocol") == "ssl"; #else const bool ssl = true; #endif const bool tcp = communicator->getProperties()->getProperty("Ice.Default.Protocol") == "tcp"; if(tcp) { p1->ice_encodingVersion(Ice::Encoding_1_0)->ice_ping(); } // Two legal TCP endpoints expressed as opaque endpoints p1 = communicator->stringToProxy("test -e 1.0:opaque -e 1.0 -t 1 -v CTEyNy4wLjAuMeouAAAQJwAAAA==:opaque -e 1.0 -t 1 -v CTEyNy4wLjAuMusuAAAQJwAAAA=="); pstr = communicator->proxyToString(p1); test(pstr == "test -t -e 1.0:tcp -h 127.0.0.1 -p 12010 -t 10000:tcp -h 127.0.0.2 -p 12011 -t 10000"); // // Test that an SSL endpoint and a nonsense endpoint get written // back out as an opaque endpoint. // p1 = communicator->stringToProxy( "test -e 1.0:opaque -e 1.0 -t 2 -v CTEyNy4wLjAuMREnAAD/////AA==:opaque -e 1.0 -t 99 -v abch"); pstr = communicator->proxyToString(p1); if(ssl) { test(pstr == "test -t -e 1.0:ssl -h 127.0.0.1 -p 10001 -t infinite:opaque -t 99 -e 1.0 -v abch"); } else if(tcp) { test(pstr == "test -t -e 1.0:opaque -t 2 -e 1.0 -v CTEyNy4wLjAuMREnAAD/////AA==:opaque -t 99 -e 1.0 -v abch"); } // // Try to invoke on the endpoint to verify that we get a // NoEndpointException (or ConnectionRefusedException when // running with SSL). // if(ssl) { try { p1->ice_encodingVersion(Ice::Encoding_1_0)->ice_ping(); test(false); } catch(const Ice::ConnectFailedException&) { } } // // Test that the proxy with an SSL endpoint and a nonsense // endpoint (which the server doesn't understand either) can be // sent over the wire and returned by the server without losing // the opaque endpoints. // Ice::ObjectPrx p2 = derived->echo(p1); pstr = communicator->proxyToString(p2); if(ssl) { test(pstr == "test -t -e 1.0:ssl -h 127.0.0.1 -p 10001 -t infinite:opaque -t 99 -e 1.0 -v abch"); } else if(tcp) { test(pstr == "test -t -e 1.0:opaque -t 2 -e 1.0 -v CTEyNy4wLjAuMREnAAD/////AA==:opaque -t 99 -e 1.0 -v abch"); } } cout << "ok" << endl; return cl; }
void twoways(const Ice::CommunicatorPtr& communicator, const Test::MyClassPrx& p) { { p->opVoid(); } { Ice::Byte b; Ice::Byte r; r = p->opByte(Ice::Byte(0xff), Ice::Byte(0x0f), b); test(b == Ice::Byte(0xf0)); test(r == Ice::Byte(0xff)); } { bool b; bool r; r = p->opBool(true, false, b); test(b); test(!r); } { Ice::Short s; Ice::Int i; Ice::Long l; Ice::Long r; r = p->opShortIntLong(10, 11, 12, s, i, l); test(s == 10); test(i == 11); test(l == 12); test(r == 12); r = p->opShortIntLong(numeric_limits<Ice::Short>::min(), numeric_limits<Ice::Int>::min(), numeric_limits<Ice::Long>::min(), s, i, l); test(s == numeric_limits<Ice::Short>::min()); test(i == numeric_limits<Ice::Int>::min()); test(l == numeric_limits<Ice::Long>::min()); test(r == numeric_limits<Ice::Long>::min()); r = p->opShortIntLong(numeric_limits<Ice::Short>::max(), numeric_limits<Ice::Int>::max(), numeric_limits<Ice::Long>::max(), s, i, l); test(s == numeric_limits<Ice::Short>::max()); test(i == numeric_limits<Ice::Int>::max()); test(l == numeric_limits<Ice::Long>::max()); test(r == numeric_limits<Ice::Long>::max()); } { Ice::Float f; Ice::Double d; Ice::Double r; r = p->opFloatDouble(Ice::Float(3.14), Ice::Double(1.1E10), f, d); test(f == Ice::Float(3.14)); test(d == Ice::Double(1.1E10)); test(r == Ice::Double(1.1E10)); r = p->opFloatDouble(numeric_limits<Ice::Float>::min(), numeric_limits<Ice::Double>::min(), f, d); test(f == numeric_limits<Ice::Float>::min()); test(d == numeric_limits<Ice::Double>::min()); test(r == numeric_limits<Ice::Double>::min()); r = p->opFloatDouble(numeric_limits<Ice::Float>::max(), numeric_limits<Ice::Double>::max(), f, d); test(f == numeric_limits<Ice::Float>::max()); test(d == numeric_limits<Ice::Double>::max()); test(r == numeric_limits<Ice::Double>::max()); } { string s; string r; r = p->opString("hello", "world", s); test(s == "world hello"); test(r == "hello world"); } { Test::MyEnum e; Test::MyEnum r; r = p->opMyEnum(Test::enum2, e); test(e == Test::enum2); test(r == Test::enum3); } { Test::MyClassPrx c1; Test::MyClassPrx c2; Test::MyClassPrx r; r = p->opMyClass(p, c1, c2); test(Ice::proxyIdentityAndFacetEqual(c1, p)); test(!Ice::proxyIdentityAndFacetEqual(c2, p)); test(Ice::proxyIdentityAndFacetEqual(r, p)); test(c1->ice_getIdentity() == communicator->stringToIdentity("test")); test(c2->ice_getIdentity() == communicator->stringToIdentity("noSuchIdentity")); test(r->ice_getIdentity() == communicator->stringToIdentity("test")); r->opVoid(); c1->opVoid(); try { c2->opVoid(); test(false); } catch(const Ice::ObjectNotExistException&) { } r = p->opMyClass(0, c1, c2); test(c1 == 0); test(c2 != 0); test(Ice::proxyIdentityAndFacetEqual(r, p)); r->opVoid(); } { Test::Structure si1; si1.p = p; si1.e = Test::enum3; si1.s.s = "abc"; Test::Structure si2; si2.p = 0; si2.e = Test::enum2; si2.s.s = "def"; Test::Structure so; Test::Structure rso = p->opStruct(si1, si2, so); test(rso.p == 0); test(rso.e == Test::enum2); test(rso.s.s == "def"); test(so.p == p); test(so.e == Test::enum3); test(so.s.s == "a new string"); so.p->opVoid(); } { Test::ByteS bsi1; Test::ByteS bsi2; bsi1.push_back(Ice::Byte(0x01)); bsi1.push_back(Ice::Byte(0x11)); bsi1.push_back(Ice::Byte(0x12)); bsi1.push_back(Ice::Byte(0x22)); bsi2.push_back(Ice::Byte(0xf1)); bsi2.push_back(Ice::Byte(0xf2)); bsi2.push_back(Ice::Byte(0xf3)); bsi2.push_back(Ice::Byte(0xf4)); Test::ByteS bso; Test::ByteS rso; rso = p->opByteS(bsi1, bsi2, bso); test(bso.size() == 4); test(bso[0] == Ice::Byte(0x22)); test(bso[1] == Ice::Byte(0x12)); test(bso[2] == Ice::Byte(0x11)); test(bso[3] == Ice::Byte(0x01)); test(rso.size() == 8); test(rso[0] == Ice::Byte(0x01)); test(rso[1] == Ice::Byte(0x11)); test(rso[2] == Ice::Byte(0x12)); test(rso[3] == Ice::Byte(0x22)); test(rso[4] == Ice::Byte(0xf1)); test(rso[5] == Ice::Byte(0xf2)); test(rso[6] == Ice::Byte(0xf3)); test(rso[7] == Ice::Byte(0xf4)); } { Test::BoolS bsi1; Test::BoolS bsi2; bsi1.push_back(true); bsi1.push_back(true); bsi1.push_back(false); bsi2.push_back(false); Test::BoolS bso; Test::BoolS rso; rso = p->opBoolS(bsi1, bsi2, bso); test(bso.size() == 4); test(bso[0]); test(bso[1]); test(!bso[2]); test(!bso[3]); test(rso.size() == 3); test(!rso[0]); test(rso[1]); test(rso[2]); } { Test::ShortS ssi; Test::IntS isi; Test::LongS lsi; ssi.push_back(1); ssi.push_back(2); ssi.push_back(3); isi.push_back(5); isi.push_back(6); isi.push_back(7); isi.push_back(8); lsi.push_back(10); lsi.push_back(30); lsi.push_back(20); Test::ShortS sso; Test::IntS iso; Test::LongS lso; Test::LongS rso; rso = p->opShortIntLongS(ssi, isi, lsi, sso, iso, lso); test(sso.size() == 3); test(sso[0] == 1); test(sso[1] == 2); test(sso[2] == 3); test(iso.size() == 4); test(iso[0] == 8); test(iso[1] == 7); test(iso[2] == 6); test(iso[3] == 5); test(lso.size() == 6); test(lso[0] == 10); test(lso[1] == 30); test(lso[2] == 20); test(lso[3] == 10); test(lso[4] == 30); test(lso[5] == 20); test(rso.size() == 3); test(rso[0] == 10); test(rso[1] == 30); test(rso[2] == 20); } { Test::FloatS fsi; Test::DoubleS dsi; fsi.push_back(Ice::Float(3.14)); fsi.push_back(Ice::Float(1.11)); dsi.push_back(Ice::Double(1.1E10)); dsi.push_back(Ice::Double(1.2E10)); dsi.push_back(Ice::Double(1.3E10)); Test::FloatS fso; Test::DoubleS dso; Test::DoubleS rso; rso = p->opFloatDoubleS(fsi, dsi, fso, dso); test(fso.size() == 2); test(fso[0] == ::Ice::Float(3.14)); test(fso[1] == ::Ice::Float(1.11)); test(dso.size() == 3); test(dso[0] == ::Ice::Double(1.3E10)); test(dso[1] == ::Ice::Double(1.2E10)); test(dso[2] == ::Ice::Double(1.1E10)); test(rso.size() == 5); test(rso[0] == ::Ice::Double(1.1E10)); test(rso[1] == ::Ice::Double(1.2E10)); test(rso[2] == ::Ice::Double(1.3E10)); test(::Ice::Float(rso[3]) == ::Ice::Float(3.14)); test(::Ice::Float(rso[4]) == ::Ice::Float(1.11)); } { Test::StringS ssi1; Test::StringS ssi2; ssi1.push_back("abc"); ssi1.push_back("de"); ssi1.push_back("fghi"); ssi2.push_back("xyz"); Test::StringS sso; Test::StringS rso; rso = p->opStringS(ssi1, ssi2, sso); test(sso.size() == 4); test(sso[0] == "abc"); test(sso[1] == "de"); test(sso[2] == "fghi"); test(sso[3] == "xyz"); test(rso.size() == 3); test(rso[0] == "fghi"); test(rso[1] == "de"); test(rso[2] == "abc"); } { Test::ByteSS bsi1; bsi1.resize(2); Test::ByteSS bsi2; bsi2.resize(2); bsi1[0].push_back(Ice::Byte(0x01)); bsi1[0].push_back(Ice::Byte(0x11)); bsi1[0].push_back(Ice::Byte(0x12)); bsi1[1].push_back(Ice::Byte(0xff)); bsi2[0].push_back(Ice::Byte(0x0e)); bsi2[1].push_back(Ice::Byte(0xf2)); bsi2[1].push_back(Ice::Byte(0xf1)); Test::ByteSS bso; Test::ByteSS rso; rso = p->opByteSS(bsi1, bsi2, bso); test(bso.size() == 2); test(bso[0].size() == 1); test(bso[0][0] == Ice::Byte(0xff)); test(bso[1].size() == 3); test(bso[1][0] == Ice::Byte(0x01)); test(bso[1][1] == Ice::Byte(0x11)); test(bso[1][2] == Ice::Byte(0x12)); test(rso.size() == 4); test(rso[0].size() == 3); test(rso[0][0] == Ice::Byte(0x01)); test(rso[0][1] == Ice::Byte(0x11)); test(rso[0][2] == Ice::Byte(0x12)); test(rso[1].size() == 1); test(rso[1][0] == Ice::Byte(0xff)); test(rso[2].size() == 1); test(rso[2][0] == Ice::Byte(0x0e)); test(rso[3].size() == 2); test(rso[3][0] == Ice::Byte(0xf2)); test(rso[3][1] == Ice::Byte(0xf1)); } { Test::FloatSS fsi; fsi.resize(3); Test::DoubleSS dsi; dsi.resize(1); fsi[0].push_back(Ice::Float(3.14)); fsi[1].push_back(Ice::Float(1.11)); dsi[0].push_back(Ice::Double(1.1E10)); dsi[0].push_back(Ice::Double(1.2E10)); dsi[0].push_back(Ice::Double(1.3E10)); Test::FloatSS fso; Test::DoubleSS dso; Test::DoubleSS rso; rso = p->opFloatDoubleSS(fsi, dsi, fso, dso); test(fso.size() == 3); test(fso[0].size() == 1); test(fso[0][0] == ::Ice::Float(3.14)); test(fso[1].size() == 1); test(fso[1][0] == ::Ice::Float(1.11)); test(fso[2].size() == 0); test(dso.size() == 1); test(dso[0].size() == 3); test(dso[0][0] == ::Ice::Double(1.1E10)); test(dso[0][1] == ::Ice::Double(1.2E10)); test(dso[0][2] == ::Ice::Double(1.3E10)); test(rso.size() == 2); test(rso[0].size() == 3); test(rso[0][0] == ::Ice::Double(1.1E10)); test(rso[0][1] == ::Ice::Double(1.2E10)); test(rso[0][2] == ::Ice::Double(1.3E10)); test(rso[1].size() == 3); test(rso[1][0] == ::Ice::Double(1.1E10)); test(rso[1][1] == ::Ice::Double(1.2E10)); test(rso[1][2] == ::Ice::Double(1.3E10)); } { Test::StringSS ssi1; ssi1.resize(2); Test::StringSS ssi2; ssi2.resize(3); ssi1[0].push_back("abc"); ssi1[1].push_back("de"); ssi1[1].push_back("fghi"); ssi2[2].push_back("xyz"); Test::StringSS sso; Test::StringSS rso; rso = p->opStringSS(ssi1, ssi2, sso); test(sso.size() == 5); test(sso[0].size() == 1); test(sso[0][0] == "abc"); test(sso[1].size() == 2); test(sso[1][0] == "de"); test(sso[1][1] == "fghi"); test(sso[2].size() == 0); test(sso[3].size() == 0); test(sso[4].size() == 1); test(sso[4][0] == "xyz"); test(rso.size() == 3); test(rso[0].size() == 1); test(rso[0][0] == "xyz"); test(rso[1].size() == 0); test(rso[2].size() == 0); } { Test::StringSSS sssi1; sssi1.resize(2); sssi1[0].resize(2); sssi1[0][0].push_back("abc"); sssi1[0][0].push_back("de"); sssi1[0][1].push_back("xyz"); sssi1[1].resize(1); sssi1[1][0].push_back("hello"); Test::StringSSS sssi2; sssi2.resize(3); sssi2[0].resize(2); sssi2[0][0].push_back(""); sssi2[0][0].push_back(""); sssi2[0][1].push_back("abcd"); sssi2[1].resize(1); sssi2[1][0].push_back(""); Test::StringSSS ssso; Test::StringSSS rsso; rsso = p->opStringSSS(sssi1, sssi2, ssso); test(ssso.size() == 5); test(ssso[0].size() == 2); test(ssso[0][0].size() == 2); test(ssso[0][1].size() == 1); test(ssso[1].size() == 1); test(ssso[1][0].size() == 1); test(ssso[2].size() == 2); test(ssso[2][0].size() == 2); test(ssso[2][1].size() == 1); test(ssso[3].size() == 1); test(ssso[3][0].size() == 1); test(ssso[4].size() == 0); test(ssso[0][0][0] == "abc"); test(ssso[0][0][1] == "de"); test(ssso[0][1][0] == "xyz"); test(ssso[1][0][0] == "hello"); test(ssso[2][0][0] == ""); test(ssso[2][0][1] == ""); test(ssso[2][1][0] == "abcd"); test(ssso[3][0][0] == ""); test(rsso.size() == 3); test(rsso[0].size() == 0); test(rsso[1].size() == 1); test(rsso[1][0].size() == 1); test(rsso[2].size() == 2); test(rsso[2][0].size() == 2); test(rsso[2][1].size() == 1); test(rsso[1][0][0] == ""); test(rsso[2][0][0] == ""); test(rsso[2][0][1] == ""); test(rsso[2][1][0] == "abcd"); } { Test::ByteBoolD di1; di1[10] = true; di1[100] = false; Test::ByteBoolD di2; di2[10] = true; di2[11] = false; di2[101] = true; Test::ByteBoolD _do; Test::ByteBoolD ro = p->opByteBoolD(di1, di2, _do); test(_do == di1); test(ro.size() == 4); test(ro[10] == true); test(ro[11] == false); test(ro[100] == false); test(ro[101] == true); } { Test::ShortIntD di1; di1[110] = -1; di1[1100] = 123123; Test::ShortIntD di2; di2[110] = -1; di2[111] = -100; di2[1101] = 0; Test::ShortIntD _do; Test::ShortIntD ro = p->opShortIntD(di1, di2, _do); test(_do == di1); test(ro.size() == 4); test(ro[110] == -1); test(ro[111] == -100); test(ro[1100] == 123123); test(ro[1101] == 0); } { Test::LongFloatD di1; di1[999999110] = Ice::Float(-1.1); di1[999999111] = Ice::Float(123123.2); Test::LongFloatD di2; di2[999999110] = Ice::Float(-1.1); di2[999999120] = Ice::Float(-100.4); di2[999999130] = Ice::Float(0.5); Test::LongFloatD _do; Test::LongFloatD ro = p->opLongFloatD(di1, di2, _do); test(_do == di1); test(ro.size() == 4); test(ro[999999110] == Ice::Float(-1.1)); test(ro[999999120] == Ice::Float(-100.4)); test(ro[999999111] == Ice::Float(123123.2)); test(ro[999999130] == Ice::Float(0.5)); } { Test::StringStringD di1; di1["foo"] = "abc -1.1"; di1["bar"] = "abc 123123.2"; Test::StringStringD di2; di2["foo"] = "abc -1.1"; di2["FOO"] = "abc -100.4"; di2["BAR"] = "abc 0.5"; Test::StringStringD _do; Test::StringStringD ro = p->opStringStringD(di1, di2, _do); test(_do == di1); test(ro.size() == 4); test(ro["foo"] == "abc -1.1"); test(ro["FOO"] == "abc -100.4"); test(ro["bar"] == "abc 123123.2"); test(ro["BAR"] == "abc 0.5"); } { Test::StringMyEnumD di1; di1["abc"] = Test::enum1; di1[""] = Test::enum2; Test::StringMyEnumD di2; di2["abc"] = Test::enum1; di2["qwerty"] = Test::enum3; di2["Hello!!"] = Test::enum2; Test::StringMyEnumD _do; Test::StringMyEnumD ro = p->opStringMyEnumD(di1, di2, _do); test(_do == di1); test(ro.size() == 4); test(ro["abc"] == Test::enum1); test(ro["qwerty"] == Test::enum3); test(ro[""] == Test::enum2); test(ro["Hello!!"] == Test::enum2); } { const int lengths[] = { 0, 1, 2, 126, 127, 128, 129, 253, 254, 255, 256, 257, 1000 }; for(int l = 0; l != sizeof(lengths) / sizeof(*lengths); ++l) { Test::IntS s; for(int i = 0; i < lengths[l]; ++i) { s.push_back(i); } Test::IntS r = p->opIntS(s); test(r.size() == static_cast<size_t>(lengths[l])); for(int j = 0; j < static_cast<int>(r.size()); ++j) { test(r[j] == -j); } } } { Ice::Context ctx; ctx["one"] = "ONE"; ctx["two"] = "TWO"; ctx["three"] = "THREE"; { Test::StringStringD r = p->opContext(); test(p->ice_getContext().empty()); test(r != ctx); } { Test::StringStringD r = p->opContext(ctx); test(p->ice_getContext().empty()); test(r == ctx); } { Test::MyClassPrx p2 = Test::MyClassPrx::checkedCast(p->ice_context(ctx)); test(p2->ice_getContext() == ctx); Test::StringStringD r = p2->opContext(); test(r == ctx); r = p2->opContext(ctx); test(r == ctx); } { // // Test that default context is obtained correctly from communicator. // /* DEPRECATED Ice::Context dflt; dflt["a"] = "b"; communicator->setDefaultContext(dflt); test(p->opContext() != dflt); Test::MyClassPrx p2 = Test::MyClassPrx::uncheckedCast(p->ice_context(Ice::Context())); test(p2->opContext().empty()); p2 = Test::MyClassPrx::uncheckedCast(p->ice_defaultContext()); test(p2->opContext() == dflt); communicator->setDefaultContext(Ice::Context()); test(!p2->opContext().empty()); communicator->setDefaultContext(dflt); Test::MyClassPrx c = Test::MyClassPrx::checkedCast( communicator->stringToProxy("test:default -p 12010 -t 10000")); test(c->opContext() == dflt); dflt["a"] = "c"; Test::MyClassPrx c2 = Test::MyClassPrx::uncheckedCast(c->ice_context(dflt)); test(c2->opContext()["a"] == "c"); dflt.clear(); Test::MyClassPrx c3 = Test::MyClassPrx::uncheckedCast(c2->ice_context(dflt)); Ice::Context tmp = c3->opContext(); test(tmp.find("a") == tmp.end()); Test::MyClassPrx c4 = Test::MyClassPrx::uncheckedCast(c2->ice_defaultContext()); test(c4->opContext()["a"] == "b"); dflt["a"] = "d"; communicator->setDefaultContext(dflt); Test::MyClassPrx c5 = Test::MyClassPrx::uncheckedCast(c->ice_defaultContext()); test(c5->opContext()["a"] == "d"); communicator->setDefaultContext(Ice::Context()); */ } { // // Test implicit context propagation // string impls[] = {"Shared", "PerThread"}; for(int i = 0; i < 2; i++) { Ice::InitializationData initData; initData.properties = communicator->getProperties()->clone(); initData.properties->setProperty("Ice.ImplicitContext", impls[i]); Ice::CommunicatorPtr ic = Ice::initialize(initData); Ice::Context ctx; ctx["one"] = "ONE"; ctx["two"] = "TWO"; ctx["three"] = "THREE"; Test::MyClassPrx p = Test::MyClassPrx::uncheckedCast( ic->stringToProxy("test:default -p 12010 -t 10000")); ic->getImplicitContext()->setContext(ctx); test(ic->getImplicitContext()->getContext() == ctx); test(p->opContext() == ctx); test(ic->getImplicitContext()->containsKey("zero") == false); string r = ic->getImplicitContext()->put("zero", "ZERO"); test(r == ""); test(ic->getImplicitContext()->containsKey("zero") == true); test(ic->getImplicitContext()->get("zero") == "ZERO"); ctx = ic->getImplicitContext()->getContext(); test(p->opContext() == ctx); Ice::Context prxContext; prxContext["one"] = "UN"; prxContext["four"] = "QUATRE"; Ice::Context combined = prxContext; combined.insert(ctx.begin(), ctx.end()); test(combined["one"] == "UN"); p = Test::MyClassPrx::uncheckedCast(p->ice_context(prxContext)); ic->getImplicitContext()->setContext(Ice::Context()); test(p->opContext() == prxContext); ic->getImplicitContext()->setContext(ctx); test(p->opContext() == combined); test(ic->getImplicitContext()->remove("one") == "ONE"); ic->destroy(); } } } { Ice::Double d = 1278312346.0 / 13.0; Test::DoubleS ds(5, d); p->opDoubleMarshaling(d, ds); } }
void allTests(Test::TestHelper* helper) { Ice::CommunicatorPtr communicator = helper->communicator(); cout << "testing proxy endpoint information... " << flush; { Ice::ObjectPrxPtr p1 = communicator->stringToProxy("test -t:default -h tcphost -p 10000 -t 1200 -z --sourceAddress 10.10.10.10:" "udp -h udphost -p 10001 --interface eth0 --ttl 5 --sourceAddress 10.10.10.10:" "opaque -e 1.8 -t 100 -v ABCD"); Ice::EndpointSeq endps = p1->ice_getEndpoints(); Ice::EndpointInfoPtr info = endps[0]->getInfo(); Ice::TCPEndpointInfoPtr ipEndpoint = getTCPEndpointInfo(info); test(ipEndpoint); test(ipEndpoint->host == "tcphost"); test(ipEndpoint->port == 10000); test(ipEndpoint->timeout == 1200); #if !defined(ICE_OS_UWP) test(ipEndpoint->sourceAddress == "10.10.10.10"); #endif test(ipEndpoint->compress); test(!ipEndpoint->datagram()); test((ipEndpoint->type() == Ice::TCPEndpointType && !ipEndpoint->secure()) || (ipEndpoint->type() == Ice::SSLEndpointType && ipEndpoint->secure()) || (ipEndpoint->type() == Ice::WSEndpointType && !ipEndpoint->secure()) || (ipEndpoint->type() == Ice::WSSEndpointType && ipEndpoint->secure())); test((ipEndpoint->type() == Ice::TCPEndpointType && ICE_DYNAMIC_CAST(Ice::TCPEndpointInfo, info)) || (ipEndpoint->type() == Ice::SSLEndpointType && ICE_DYNAMIC_CAST(IceSSL::EndpointInfo, info)) || (ipEndpoint->type() == Ice::WSEndpointType && ICE_DYNAMIC_CAST(Ice::WSEndpointInfo, info)) || (ipEndpoint->type() == Ice::WSSEndpointType && ICE_DYNAMIC_CAST(Ice::WSEndpointInfo, info))); Ice::UDPEndpointInfoPtr udpEndpoint = ICE_DYNAMIC_CAST(Ice::UDPEndpointInfo, endps[1]->getInfo()); test(udpEndpoint); test(udpEndpoint->host == "udphost"); test(udpEndpoint->port == 10001); #if !defined(ICE_OS_UWP) test(udpEndpoint->sourceAddress == "10.10.10.10"); #endif test(udpEndpoint->mcastInterface == "eth0"); test(udpEndpoint->mcastTtl == 5); test(udpEndpoint->timeout == -1); test(!udpEndpoint->compress); test(!udpEndpoint->secure()); test(udpEndpoint->datagram()); test(udpEndpoint->type() == Ice::UDPEndpointType); Ice::OpaqueEndpointInfoPtr opaqueEndpoint = ICE_DYNAMIC_CAST(Ice::OpaqueEndpointInfo, endps[2]->getInfo()); test(opaqueEndpoint); Ice::EncodingVersion rev; rev.major = 1; rev.minor = 8; test(opaqueEndpoint->rawEncoding == rev); } cout << "ok" << endl; string defaultHost = communicator->getProperties()->getProperty("Ice.Default.Host"); #ifdef ICE_OS_UWP bool uwp = true; #else bool uwp = false; #endif if(!uwp || (communicator->getProperties()->getProperty("Ice.Default.Protocol") != "ssl" && communicator->getProperties()->getProperty("Ice.Default.Protocol") != "wss")) { cout << "test object adapter endpoint information... " << flush; { communicator->getProperties()->setProperty("TestAdapter.Endpoints", "default -h 127.0.0.1 -t 15000:udp -h 127.0.0.1"); Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter"); Ice::EndpointSeq endpoints = adapter->getEndpoints(); test(endpoints.size() == 2); Ice::EndpointSeq publishedEndpoints = adapter->getPublishedEndpoints(); test(endpoints == publishedEndpoints); Ice::TCPEndpointInfoPtr ipEndpoint = getTCPEndpointInfo(endpoints[0]->getInfo()); test(ipEndpoint); test(ipEndpoint->type() == Ice::TCPEndpointType || ipEndpoint->type() == Ice::SSLEndpointType || ipEndpoint->type() == Ice::WSEndpointType || ipEndpoint->type() == Ice::WSSEndpointType); test(ipEndpoint->host == "127.0.0.1"); test(ipEndpoint->port > 0); test(ipEndpoint->timeout == 15000); Ice::UDPEndpointInfoPtr udpEndpoint = ICE_DYNAMIC_CAST(Ice::UDPEndpointInfo, endpoints[1]->getInfo()); test(udpEndpoint); test(udpEndpoint->host == "127.0.0.1"); test(udpEndpoint->datagram()); test(udpEndpoint->port > 0); endpoints.pop_back(); test(endpoints.size() == 1); adapter->setPublishedEndpoints(endpoints); publishedEndpoints = adapter->getPublishedEndpoints(); test(endpoints == publishedEndpoints); adapter->destroy(); int port = helper->getTestPort(1); ostringstream portStr; portStr << port; communicator->getProperties()->setProperty("TestAdapter.Endpoints", "default -h * -p " + portStr.str()); communicator->getProperties()->setProperty("TestAdapter.PublishedEndpoints", helper->getTestEndpoint(1)); adapter = communicator->createObjectAdapter("TestAdapter"); endpoints = adapter->getEndpoints(); test(endpoints.size() >= 1); publishedEndpoints = adapter->getPublishedEndpoints(); test(publishedEndpoints.size() == 1); for(Ice::EndpointSeq::const_iterator p = endpoints.begin(); p != endpoints.end(); ++p) { ipEndpoint = getTCPEndpointInfo((*p)->getInfo()); test(ipEndpoint->port == port); } ipEndpoint = getTCPEndpointInfo(publishedEndpoints[0]->getInfo()); test(ipEndpoint->host == helper->getTestHost()); test(ipEndpoint->port == port); adapter->destroy(); } cout << "ok" << endl; } string endpoints = helper->getTestEndpoint() + ":" + helper->getTestEndpoint("udp") + " -c"; int port = helper->getTestPort(); Ice::ObjectPrxPtr base = communicator->stringToProxy("test:" + endpoints); TestIntfPrxPtr testIntf = ICE_CHECKED_CAST(TestIntfPrx, base); cout << "test connection endpoint information... " << flush; { Ice::EndpointInfoPtr info = base->ice_getConnection()->getEndpoint()->getInfo(); Ice::TCPEndpointInfoPtr tcpinfo = getTCPEndpointInfo(info); test(tcpinfo->port == port); test(!tcpinfo->compress); test(tcpinfo->host == defaultHost); ostringstream os; Ice::Context ctx = testIntf->getEndpointInfoAsContext(); test(ctx["host"] == tcpinfo->host); test(ctx["compress"] == "false"); istringstream is(ctx["port"]); int portCtx; is >> portCtx; test(portCtx > 0); info = base->ice_datagram()->ice_getConnection()->getEndpoint()->getInfo(); Ice::UDPEndpointInfoPtr udp = ICE_DYNAMIC_CAST(Ice::UDPEndpointInfo, info); test(udp); test(udp->port == portCtx); test(udp->host == defaultHost); } cout << "ok" << endl; cout << "testing connection information... " << flush; { Ice::ConnectionPtr connection = base->ice_getConnection(); connection->setBufferSize(1024, 2048); Ice::TCPConnectionInfoPtr info = getTCPConnectionInfo(connection->getInfo()); test(info); test(!info->incoming); test(info->adapterName.empty()); test(info->localPort > 0); test(info->remotePort == port); if(defaultHost == "127.0.0.1") { test(info->remoteAddress == defaultHost); test(info->localAddress == defaultHost); } #if !defined(ICE_OS_UWP) test(info->rcvSize >= 1024); test(info->sndSize >= 2048); #endif ostringstream os; Ice::Context ctx = testIntf->getConnectionInfoAsContext(); test(ctx["incoming"] == "true"); test(ctx["adapterName"] == "TestAdapter"); test(ctx["remoteAddress"] == info->localAddress); test(ctx["localAddress"] == info->remoteAddress); os.str(""); os << info->localPort; test(ctx["remotePort"] == os.str()); os.str(""); os << info->remotePort; test(ctx["localPort"] == os.str()); if(base->ice_getConnection()->type() == "ws" || base->ice_getConnection()->type() == "wss") { Ice::HeaderDict headers; Ice::WSConnectionInfoPtr wsinfo = ICE_DYNAMIC_CAST(Ice::WSConnectionInfo, connection->getInfo()); test(wsinfo); headers = wsinfo->headers; if(base->ice_getConnection()->type() == "wss") { IceSSL::ConnectionInfoPtr wssinfo = ICE_DYNAMIC_CAST(IceSSL::ConnectionInfo, wsinfo->underlying); test(wssinfo->verified); #if !defined(ICE_OS_UWP) && TARGET_OS_IPHONE==0 test(!wssinfo->certs.empty()); #endif } test(headers["Upgrade"] == "websocket"); test(headers["Connection"] == "Upgrade"); test(headers["Sec-WebSocket-Protocol"] == "ice.zeroc.com"); test(headers.find("Sec-WebSocket-Accept") != headers.end()); test(ctx["ws.Upgrade"] == "websocket"); test(ctx["ws.Connection"] == "Upgrade"); test(ctx["ws.Sec-WebSocket-Protocol"] == "ice.zeroc.com"); test(ctx["ws.Sec-WebSocket-Version"] == "13"); test(ctx.find("ws.Sec-WebSocket-Key") != ctx.end()); } connection = base->ice_datagram()->ice_getConnection(); connection->setBufferSize(2048, 1024); Ice::UDPConnectionInfoPtr udpinfo = ICE_DYNAMIC_CAST(Ice::UDPConnectionInfo, connection->getInfo()); test(!udpinfo->incoming); test(udpinfo->adapterName.empty()); test(udpinfo->localPort > 0); test(udpinfo->remotePort == port); if(defaultHost == "127.0.0.1") { test(udpinfo->remoteAddress == defaultHost); test(udpinfo->localAddress == defaultHost); } #if !defined(ICE_OS_UWP) test(udpinfo->rcvSize >= 2048); test(udpinfo->sndSize >= 1024); #endif } cout << "ok" << endl; testIntf->shutdown(); communicator->shutdown(); communicator->waitForShutdown(); }
RoutableReferencePtr IceInternal::ReferenceFactory::create(const Identity& ident, const string& facet, Reference::Mode mode, bool secure, const Ice::ProtocolVersion& protocol, const Ice::EncodingVersion& encoding, const vector<EndpointIPtr>& endpoints, const string& adapterId, const string& propertyPrefix) { DefaultsAndOverridesPtr defaultsAndOverrides = _instance->defaultsAndOverrides(); // // Default local proxy options. // LocatorInfoPtr locatorInfo; if(_defaultLocator) { if(_defaultLocator->ice_getEncodingVersion() != encoding) { locatorInfo = _instance->locatorManager()->get(_defaultLocator->ice_encodingVersion(encoding)); } else { locatorInfo = _instance->locatorManager()->get(_defaultLocator); } } RouterInfoPtr routerInfo = _instance->routerManager()->get(_defaultRouter); bool collocationOptimized = defaultsAndOverrides->defaultCollocationOptimization; bool cacheConnection = true; bool preferSecure = defaultsAndOverrides->defaultPreferSecure; Ice::EndpointSelectionType endpointSelection = defaultsAndOverrides->defaultEndpointSelection; int locatorCacheTimeout = defaultsAndOverrides->defaultLocatorCacheTimeout; int invocationTimeout = defaultsAndOverrides->defaultInvocationTimeout; Ice::Context ctx; // // Override the defaults with the proxy properties if a property prefix is defined. // if(!propertyPrefix.empty()) { PropertiesPtr properties = _instance->initializationData().properties; if(properties->getPropertyAsIntWithDefault("Ice.Warn.UnknownProperties", 1) > 0) { checkForUnknownProperties(propertyPrefix); } string property; property = propertyPrefix + ".Locator"; LocatorPrx locator = LocatorPrx::uncheckedCast(_communicator->propertyToProxy(property)); if(locator) { if(locator->ice_getEncodingVersion() != encoding) { locatorInfo = _instance->locatorManager()->get(locator->ice_encodingVersion(encoding)); } else { locatorInfo = _instance->locatorManager()->get(locator); } } property = propertyPrefix + ".Router"; RouterPrx router = RouterPrx::uncheckedCast(_communicator->propertyToProxy(property)); if(router) { if(propertyPrefix.size() > 7 && propertyPrefix.substr(propertyPrefix.size() - 7, 7) == ".Router") { Warning out(_instance->initializationData().logger); out << "`" << property << "=" << properties->getProperty(property) << "': cannot set a router on a router; setting ignored"; } else { routerInfo = _instance->routerManager()->get(router); } } property = propertyPrefix + ".CollocationOptimized"; collocationOptimized = properties->getPropertyAsIntWithDefault(property, collocationOptimized) > 0; property = propertyPrefix + ".ConnectionCached"; cacheConnection = properties->getPropertyAsIntWithDefault(property, cacheConnection) > 0; property = propertyPrefix + ".PreferSecure"; preferSecure = properties->getPropertyAsIntWithDefault(property, preferSecure) > 0; property = propertyPrefix + ".EndpointSelection"; if(!properties->getProperty(property).empty()) { string type = properties->getProperty(property); if(type == "Random") { endpointSelection = Random; } else if(type == "Ordered") { endpointSelection = Ordered; } else { EndpointSelectionTypeParseException ex(__FILE__, __LINE__); ex.str = "illegal value `" + type + "'; expected `Random' or `Ordered'"; throw ex; } } property = propertyPrefix + ".LocatorCacheTimeout"; string value = properties->getProperty(property); if(!value.empty()) { locatorCacheTimeout = properties->getPropertyAsIntWithDefault(property, locatorCacheTimeout); if(locatorCacheTimeout < -1) { locatorCacheTimeout = -1; Warning out(_instance->initializationData().logger); out << "invalid value for " << property << "`" << properties->getProperty(property) << "'" << ": defaulting to -1"; } } property = propertyPrefix + ".InvocationTimeout"; value = properties->getProperty(property); if(!value.empty()) { invocationTimeout = properties->getPropertyAsIntWithDefault(property, invocationTimeout); if(invocationTimeout < 1 && invocationTimeout != -1) { invocationTimeout = -1; Warning out(_instance->initializationData().logger); out << "invalid value for " << property << "`" << properties->getProperty(property) << "'" << ": defaulting to -1"; } } property = propertyPrefix + ".Context."; PropertyDict contexts = properties->getPropertiesForPrefix(property); for(PropertyDict::const_iterator p = contexts.begin(); p != contexts.end(); ++p) { ctx.insert(make_pair(p->first.substr(property.length()), p->second)); } } // // Create new reference // return new RoutableReference(_instance, _communicator, ident, facet, mode, secure, protocol, encoding, endpoints, adapterId, locatorInfo, routerInfo, collocationOptimized, cacheConnection, preferSecure, endpointSelection, locatorCacheTimeout, invocationTimeout, ctx); }
void twoways(const Ice::CommunicatorPtr& communicator, const Test::MyClassPrxPtr& p) { { p->ice_ping(); } { #ifdef ICE_CPP11_MAPPING test(Test::MyClassPrx::ice_staticId() == Test::MyClassDisp::ice_staticId()); #else test(Test::MyClassPrx::ice_staticId() == Test::MyClass::ice_staticId()); #endif test(Ice::ObjectPrx::ice_staticId() == Ice::Object::ice_staticId()); } { test(p->ice_isA(Test::MyClass::ice_staticId())); } { test(p->ice_id() == Test::MyDerivedClass::ice_staticId()); } { Ice::StringSeq ids = p->ice_ids(); test(ids.size() == 3); test(ids[0] == "::Ice::Object"); test(ids[1] == "::Test::MyClass"); test(ids[2] == "::Test::MyDerivedClass"); } { p->opVoid(); } { Ice::Byte b; Ice::Byte r; r = p->opByte(Ice::Byte(0xff), Ice::Byte(0x0f), b); test(b == Ice::Byte(0xf0)); test(r == Ice::Byte(0xff)); } { bool b; bool r; r = p->opBool(true, false, b); test(b); test(!r); } { Ice::Short s; Ice::Int i; Ice::Long l; Ice::Long r; r = p->opShortIntLong(10, 11, 12, s, i, l); test(s == 10); test(i == 11); test(l == 12); test(r == 12); r = p->opShortIntLong(numeric_limits<Ice::Short>::min(), numeric_limits<Ice::Int>::min(), numeric_limits<Ice::Long>::min(), s, i, l); test(s == numeric_limits<Ice::Short>::min()); test(i == numeric_limits<Ice::Int>::min()); test(l == numeric_limits<Ice::Long>::min()); test(r == numeric_limits<Ice::Long>::min()); r = p->opShortIntLong(numeric_limits<Ice::Short>::max(), numeric_limits<Ice::Int>::max(), numeric_limits<Ice::Long>::max(), s, i, l); test(s == numeric_limits<Ice::Short>::max()); test(i == numeric_limits<Ice::Int>::max()); test(l == numeric_limits<Ice::Long>::max()); test(r == numeric_limits<Ice::Long>::max()); } { Ice::Float f; Ice::Double d; Ice::Double r; r = p->opFloatDouble(Ice::Float(3.14), Ice::Double(1.1E10), f, d); test(f == Ice::Float(3.14)); test(d == Ice::Double(1.1E10)); test(r == Ice::Double(1.1E10)); r = p->opFloatDouble(numeric_limits<Ice::Float>::min(), numeric_limits<Ice::Double>::min(), f, d); test(f == numeric_limits<Ice::Float>::min()); test(d == numeric_limits<Ice::Double>::min()); test(r == numeric_limits<Ice::Double>::min()); r = p->opFloatDouble(numeric_limits<Ice::Float>::max(), numeric_limits<Ice::Double>::max(), f, d); test(f == numeric_limits<Ice::Float>::max()); test(d == numeric_limits<Ice::Double>::max()); test(r == numeric_limits<Ice::Double>::max()); } { string s; string r; r = p->opString("hello", "world", s); test(s == "world hello"); test(r == "hello world"); } { Test::MyEnum e; Test::MyEnum r; r = p->opMyEnum(ICE_ENUM(MyEnum, enum2), e); test(e == ICE_ENUM(MyEnum, enum2)); test(r == ICE_ENUM(MyEnum, enum3)); } { Test::MyClassPrxPtr c1; Test::MyClassPrxPtr c2; Test::MyClassPrxPtr r; r = p->opMyClass(p, c1, c2); test(Ice::proxyIdentityAndFacetEqual(c1, p)); test(!Ice::proxyIdentityAndFacetEqual(c2, p)); test(Ice::proxyIdentityAndFacetEqual(r, p)); test(c1->ice_getIdentity() == communicator->stringToIdentity("test")); test(c2->ice_getIdentity() == communicator->stringToIdentity("noSuchIdentity")); test(r->ice_getIdentity() == communicator->stringToIdentity("test")); r->opVoid(); c1->opVoid(); try { c2->opVoid(); test(false); } catch(const Ice::ObjectNotExistException&) { } r = p->opMyClass(0, c1, c2); test(c1 == 0); test(c2 != 0); test(Ice::proxyIdentityAndFacetEqual(r, p)); r->opVoid(); } { Test::Structure si1; si1.p = p; si1.e = ICE_ENUM(MyEnum, enum3); si1.s.s = "abc"; Test::Structure si2; si2.p = 0; si2.e = ICE_ENUM(MyEnum, enum2); si2.s.s = "def"; Test::Structure so; Test::Structure rso = p->opStruct(si1, si2, so); test(rso.p == 0); test(rso.e == ICE_ENUM(MyEnum, enum2)); test(rso.s.s == "def"); #ifdef ICE_CPP11_MAPPING test(Ice::targetEquals(so.p, p)); #else test(so.p == p); #endif test(so.e == ICE_ENUM(MyEnum, enum3)); test(so.s.s == "a new string"); so.p->opVoid(); } { Test::ByteS bsi1; Test::ByteS bsi2; bsi1.push_back(Ice::Byte(0x01)); bsi1.push_back(Ice::Byte(0x11)); bsi1.push_back(Ice::Byte(0x12)); bsi1.push_back(Ice::Byte(0x22)); bsi2.push_back(Ice::Byte(0xf1)); bsi2.push_back(Ice::Byte(0xf2)); bsi2.push_back(Ice::Byte(0xf3)); bsi2.push_back(Ice::Byte(0xf4)); Test::ByteS bso; Test::ByteS rso; rso = p->opByteS(bsi1, bsi2, bso); test(bso.size() == 4); test(bso[0] == Ice::Byte(0x22)); test(bso[1] == Ice::Byte(0x12)); test(bso[2] == Ice::Byte(0x11)); test(bso[3] == Ice::Byte(0x01)); test(rso.size() == 8); test(rso[0] == Ice::Byte(0x01)); test(rso[1] == Ice::Byte(0x11)); test(rso[2] == Ice::Byte(0x12)); test(rso[3] == Ice::Byte(0x22)); test(rso[4] == Ice::Byte(0xf1)); test(rso[5] == Ice::Byte(0xf2)); test(rso[6] == Ice::Byte(0xf3)); test(rso[7] == Ice::Byte(0xf4)); } { Test::BoolS bsi1; Test::BoolS bsi2; bsi1.push_back(true); bsi1.push_back(true); bsi1.push_back(false); bsi2.push_back(false); Test::BoolS bso; Test::BoolS rso; rso = p->opBoolS(bsi1, bsi2, bso); test(bso.size() == 4); test(bso[0]); test(bso[1]); test(!bso[2]); test(!bso[3]); test(rso.size() == 3); test(!rso[0]); test(rso[1]); test(rso[2]); } { Test::ShortS ssi; Test::IntS isi; Test::LongS lsi; ssi.push_back(1); ssi.push_back(2); ssi.push_back(3); isi.push_back(5); isi.push_back(6); isi.push_back(7); isi.push_back(8); lsi.push_back(10); lsi.push_back(30); lsi.push_back(20); Test::ShortS sso; Test::IntS iso; Test::LongS lso; Test::LongS rso; rso = p->opShortIntLongS(ssi, isi, lsi, sso, iso, lso); test(sso.size() == 3); test(sso[0] == 1); test(sso[1] == 2); test(sso[2] == 3); test(iso.size() == 4); test(iso[0] == 8); test(iso[1] == 7); test(iso[2] == 6); test(iso[3] == 5); test(lso.size() == 6); test(lso[0] == 10); test(lso[1] == 30); test(lso[2] == 20); test(lso[3] == 10); test(lso[4] == 30); test(lso[5] == 20); test(rso.size() == 3); test(rso[0] == 10); test(rso[1] == 30); test(rso[2] == 20); } { Test::FloatS fsi; Test::DoubleS dsi; fsi.push_back(Ice::Float(3.14)); fsi.push_back(Ice::Float(1.11)); dsi.push_back(Ice::Double(1.1E10)); dsi.push_back(Ice::Double(1.2E10)); dsi.push_back(Ice::Double(1.3E10)); Test::FloatS fso; Test::DoubleS dso; Test::DoubleS rso; rso = p->opFloatDoubleS(fsi, dsi, fso, dso); test(fso.size() == 2); test(fso[0] == ::Ice::Float(3.14)); test(fso[1] == ::Ice::Float(1.11)); test(dso.size() == 3); test(dso[0] == ::Ice::Double(1.3E10)); test(dso[1] == ::Ice::Double(1.2E10)); test(dso[2] == ::Ice::Double(1.1E10)); test(rso.size() == 5); test(rso[0] == ::Ice::Double(1.1E10)); test(rso[1] == ::Ice::Double(1.2E10)); test(rso[2] == ::Ice::Double(1.3E10)); test(::Ice::Float(rso[3]) == ::Ice::Float(3.14)); test(::Ice::Float(rso[4]) == ::Ice::Float(1.11)); } { Test::StringS ssi1; Test::StringS ssi2; ssi1.push_back("abc"); ssi1.push_back("de"); ssi1.push_back("fghi"); ssi2.push_back("xyz"); Test::StringS sso; Test::StringS rso; rso = p->opStringS(ssi1, ssi2, sso); test(sso.size() == 4); test(sso[0] == "abc"); test(sso[1] == "de"); test(sso[2] == "fghi"); test(sso[3] == "xyz"); test(rso.size() == 3); test(rso[0] == "fghi"); test(rso[1] == "de"); test(rso[2] == "abc"); } { Test::ByteSS bsi1; bsi1.resize(2); Test::ByteSS bsi2; bsi2.resize(2); bsi1[0].push_back(Ice::Byte(0x01)); bsi1[0].push_back(Ice::Byte(0x11)); bsi1[0].push_back(Ice::Byte(0x12)); bsi1[1].push_back(Ice::Byte(0xff)); bsi2[0].push_back(Ice::Byte(0x0e)); bsi2[1].push_back(Ice::Byte(0xf2)); bsi2[1].push_back(Ice::Byte(0xf1)); Test::ByteSS bso; Test::ByteSS rso; rso = p->opByteSS(bsi1, bsi2, bso); test(bso.size() == 2); test(bso[0].size() == 1); test(bso[0][0] == Ice::Byte(0xff)); test(bso[1].size() == 3); test(bso[1][0] == Ice::Byte(0x01)); test(bso[1][1] == Ice::Byte(0x11)); test(bso[1][2] == Ice::Byte(0x12)); test(rso.size() == 4); test(rso[0].size() == 3); test(rso[0][0] == Ice::Byte(0x01)); test(rso[0][1] == Ice::Byte(0x11)); test(rso[0][2] == Ice::Byte(0x12)); test(rso[1].size() == 1); test(rso[1][0] == Ice::Byte(0xff)); test(rso[2].size() == 1); test(rso[2][0] == Ice::Byte(0x0e)); test(rso[3].size() == 2); test(rso[3][0] == Ice::Byte(0xf2)); test(rso[3][1] == Ice::Byte(0xf1)); } { Test::BoolSS bsi1; bsi1.resize(3); Test::BoolSS bsi2; bsi2.resize(1); bsi1[0].push_back(true); bsi1[1].push_back(false); bsi1[2].push_back(true); bsi1[2].push_back(true); bsi2[0].push_back(false); bsi2[0].push_back(false); bsi2[0].push_back(true); Test::BoolSS bso; Test::BoolSS rso; rso = p->opBoolSS(bsi1, bsi2, bso); test(bso.size() == 4); test(bso[0].size() == 1); test(bso[0][0]); test(bso[1].size() == 1); test(!bso[1][0]); test(bso[2].size() == 2); test(bso[2][0]); test(bso[2][1]); test(bso[3].size() == 3); test(!bso[3][0]); test(!bso[3][1]); test(bso[3][2]); test(rso.size() == 3); test(rso[0].size() == 2); test(rso[0][0]); test(rso[0][1]); test(rso[1].size() == 1); test(!rso[1][0]); test(rso[2].size() == 1); test(rso[2][0]); } { Test::ShortSS ssi; ssi.resize(3); Test::IntSS isi; isi.resize(2); Test::LongSS lsi; lsi.resize(1); ssi[0].push_back(1); ssi[0].push_back(2); ssi[0].push_back(5); ssi[1].push_back(13); isi[0].push_back(24); isi[0].push_back(98); isi[1].push_back(42); lsi[0].push_back(496); lsi[0].push_back(1729); Test::LongSS rso; Test::ShortSS sso; Test::IntSS iso; Test::LongSS lso; rso = p->opShortIntLongSS(ssi, isi, lsi, sso, iso, lso); test(rso.size() == 1); test(rso[0].size() == 2); test(rso[0][0] == 496); test(rso[0][1] == 1729); test(sso.size() == 3); test(sso[0].size() == 3); test(sso[0][0] == 1); test(sso[0][1] == 2); test(sso[0][2] == 5); test(sso[1].size() == 1); test(sso[1][0] == 13); test(sso[2].size() == 0); test(iso.size() == 2); test(iso[0].size() == 1); test(iso[0][0] == 42); test(iso[1].size() == 2); test(iso[1][0] == 24); test(iso[1][1] == 98); test(lso.size() == 2); test(lso[0].size() == 2); test(lso[0][0] == 496); test(lso[0][1] == 1729); test(lso[1].size() == 2); test(lso[1][0] == 496); test(lso[1][1] == 1729); } { Test::FloatSS fsi; fsi.resize(3); Test::DoubleSS dsi; dsi.resize(1); fsi[0].push_back(Ice::Float(3.14)); fsi[1].push_back(Ice::Float(1.11)); dsi[0].push_back(Ice::Double(1.1E10)); dsi[0].push_back(Ice::Double(1.2E10)); dsi[0].push_back(Ice::Double(1.3E10)); Test::FloatSS fso; Test::DoubleSS dso; Test::DoubleSS rso; rso = p->opFloatDoubleSS(fsi, dsi, fso, dso); test(fso.size() == 3); test(fso[0].size() == 1); test(fso[0][0] == ::Ice::Float(3.14)); test(fso[1].size() == 1); test(fso[1][0] == ::Ice::Float(1.11)); test(fso[2].size() == 0); test(dso.size() == 1); test(dso[0].size() == 3); test(dso[0][0] == ::Ice::Double(1.1E10)); test(dso[0][1] == ::Ice::Double(1.2E10)); test(dso[0][2] == ::Ice::Double(1.3E10)); test(rso.size() == 2); test(rso[0].size() == 3); test(rso[0][0] == ::Ice::Double(1.1E10)); test(rso[0][1] == ::Ice::Double(1.2E10)); test(rso[0][2] == ::Ice::Double(1.3E10)); test(rso[1].size() == 3); test(rso[1][0] == ::Ice::Double(1.1E10)); test(rso[1][1] == ::Ice::Double(1.2E10)); test(rso[1][2] == ::Ice::Double(1.3E10)); } { Test::StringSS ssi1; ssi1.resize(2); Test::StringSS ssi2; ssi2.resize(3); ssi1[0].push_back("abc"); ssi1[1].push_back("de"); ssi1[1].push_back("fghi"); ssi2[2].push_back("xyz"); Test::StringSS sso; Test::StringSS rso; rso = p->opStringSS(ssi1, ssi2, sso); test(sso.size() == 5); test(sso[0].size() == 1); test(sso[0][0] == "abc"); test(sso[1].size() == 2); test(sso[1][0] == "de"); test(sso[1][1] == "fghi"); test(sso[2].size() == 0); test(sso[3].size() == 0); test(sso[4].size() == 1); test(sso[4][0] == "xyz"); test(rso.size() == 3); test(rso[0].size() == 1); test(rso[0][0] == "xyz"); test(rso[1].size() == 0); test(rso[2].size() == 0); } { Test::StringSSS sssi1; sssi1.resize(2); sssi1[0].resize(2); sssi1[0][0].push_back("abc"); sssi1[0][0].push_back("de"); sssi1[0][1].push_back("xyz"); sssi1[1].resize(1); sssi1[1][0].push_back("hello"); Test::StringSSS sssi2; sssi2.resize(3); sssi2[0].resize(2); sssi2[0][0].push_back(""); sssi2[0][0].push_back(""); sssi2[0][1].push_back("abcd"); sssi2[1].resize(1); sssi2[1][0].push_back(""); Test::StringSSS ssso; Test::StringSSS rsso; rsso = p->opStringSSS(sssi1, sssi2, ssso); test(ssso.size() == 5); test(ssso[0].size() == 2); test(ssso[0][0].size() == 2); test(ssso[0][1].size() == 1); test(ssso[1].size() == 1); test(ssso[1][0].size() == 1); test(ssso[2].size() == 2); test(ssso[2][0].size() == 2); test(ssso[2][1].size() == 1); test(ssso[3].size() == 1); test(ssso[3][0].size() == 1); test(ssso[4].size() == 0); test(ssso[0][0][0] == "abc"); test(ssso[0][0][1] == "de"); test(ssso[0][1][0] == "xyz"); test(ssso[1][0][0] == "hello"); test(ssso[2][0][0] == ""); test(ssso[2][0][1] == ""); test(ssso[2][1][0] == "abcd"); test(ssso[3][0][0] == ""); test(rsso.size() == 3); test(rsso[0].size() == 0); test(rsso[1].size() == 1); test(rsso[1][0].size() == 1); test(rsso[2].size() == 2); test(rsso[2][0].size() == 2); test(rsso[2][1].size() == 1); test(rsso[1][0][0] == ""); test(rsso[2][0][0] == ""); test(rsso[2][0][1] == ""); test(rsso[2][1][0] == "abcd"); } { Test::ByteBoolD di1; di1[10] = true; di1[100] = false; Test::ByteBoolD di2; di2[10] = true; di2[11] = false; di2[101] = true; Test::ByteBoolD _do; Test::ByteBoolD ro = p->opByteBoolD(di1, di2, _do); test(_do == di1); test(ro.size() == 4); test(ro[10] == true); test(ro[11] == false); test(ro[100] == false); test(ro[101] == true); } { Test::ShortIntD di1; di1[110] = -1; di1[1100] = 123123; Test::ShortIntD di2; di2[110] = -1; di2[111] = -100; di2[1101] = 0; Test::ShortIntD _do; Test::ShortIntD ro = p->opShortIntD(di1, di2, _do); test(_do == di1); test(ro.size() == 4); test(ro[110] == -1); test(ro[111] == -100); test(ro[1100] == 123123); test(ro[1101] == 0); } { Test::LongFloatD di1; di1[999999110] = Ice::Float(-1.1); di1[999999111] = Ice::Float(123123.2); Test::LongFloatD di2; di2[999999110] = Ice::Float(-1.1); di2[999999120] = Ice::Float(-100.4); di2[999999130] = Ice::Float(0.5); Test::LongFloatD _do; Test::LongFloatD ro = p->opLongFloatD(di1, di2, _do); test(_do == di1); test(ro.size() == 4); test(ro[999999110] == Ice::Float(-1.1)); test(ro[999999120] == Ice::Float(-100.4)); test(ro[999999111] == Ice::Float(123123.2)); test(ro[999999130] == Ice::Float(0.5)); } { Test::StringStringD di1; di1["foo"] = "abc -1.1"; di1["bar"] = "abc 123123.2"; Test::StringStringD di2; di2["foo"] = "abc -1.1"; di2["FOO"] = "abc -100.4"; di2["BAR"] = "abc 0.5"; Test::StringStringD _do; Test::StringStringD ro = p->opStringStringD(di1, di2, _do); test(_do == di1); test(ro.size() == 4); test(ro["foo"] == "abc -1.1"); test(ro["FOO"] == "abc -100.4"); test(ro["bar"] == "abc 123123.2"); test(ro["BAR"] == "abc 0.5"); } { Test::StringMyEnumD di1; di1["abc"] = ICE_ENUM(MyEnum, enum1); di1[""] = ICE_ENUM(MyEnum, enum2); Test::StringMyEnumD di2; di2["abc"] = ICE_ENUM(MyEnum, enum1); di2["qwerty"] = ICE_ENUM(MyEnum, enum3); di2["Hello!!"] = ICE_ENUM(MyEnum, enum2); Test::StringMyEnumD _do; Test::StringMyEnumD ro = p->opStringMyEnumD(di1, di2, _do); test(_do == di1); test(ro.size() == 4); test(ro["abc"] == ICE_ENUM(MyEnum, enum1)); test(ro["qwerty"] == ICE_ENUM(MyEnum, enum3)); test(ro[""] == ICE_ENUM(MyEnum, enum2)); test(ro["Hello!!"] == ICE_ENUM(MyEnum, enum2)); } { Test::MyEnumStringD di1; di1[ICE_ENUM(MyEnum, enum1)] = "abc"; Test::MyEnumStringD di2; di2[ICE_ENUM(MyEnum, enum2)] = "Hello!!"; di2[ICE_ENUM(MyEnum, enum3)] = "qwerty"; Test::MyEnumStringD _do; Test::MyEnumStringD ro = p->opMyEnumStringD(di1, di2, _do); test(_do == di1); test(ro.size() == 3); test(ro[ICE_ENUM(MyEnum, enum1)] == "abc"); test(ro[ICE_ENUM(MyEnum, enum2)] == "Hello!!"); test(ro[ICE_ENUM(MyEnum, enum3)] == "qwerty"); } { Test::MyStruct s11 = { 1, 1 }; Test::MyStruct s12 = { 1, 2 }; Test::MyStructMyEnumD di1; di1[s11] = ICE_ENUM(MyEnum, enum1); di1[s12] = ICE_ENUM(MyEnum, enum2); Test::MyStruct s22 = { 2, 2 }; Test::MyStruct s23 = { 2, 3 }; Test::MyStructMyEnumD di2; di2[s11] = ICE_ENUM(MyEnum, enum1); di2[s22] = ICE_ENUM(MyEnum, enum3); di2[s23] = ICE_ENUM(MyEnum, enum2); Test::MyStructMyEnumD _do; Test::MyStructMyEnumD ro = p->opMyStructMyEnumD(di1, di2, _do); test(_do == di1); test(ro.size() == 4); test(ro[s11] == ICE_ENUM(MyEnum, enum1)); test(ro[s12] == ICE_ENUM(MyEnum, enum2)); test(ro[s22] == ICE_ENUM(MyEnum, enum3)); test(ro[s23] == ICE_ENUM(MyEnum, enum2)); } { Test::ByteBoolDS dsi1; dsi1.resize(2); Test::ByteBoolDS dsi2; dsi2.resize(1); Test::ByteBoolD di1; di1[10] = true; di1[100] = false; Test::ByteBoolD di2; di2[10] = true; di2[11] = false; di2[101] = true; Test::ByteBoolD di3; di3[100] = false; di3[101] = false; dsi1[0] = di1; dsi1[1] = di2; dsi2[0] = di3; try { Test::ByteBoolDS _do; Test::ByteBoolDS ro = p->opByteBoolDS(dsi1, dsi2, _do); test(ro.size() == 2); test(ro[0].size() == 3); test(ro[0][10] == true); test(ro[0][11] == false); test(ro[0][101] == true); test(ro[1].size() == 2); test(ro[1][10] == true); test(ro[1][100] == false); test(_do.size() == 3); test(_do[0].size() == 2); test(_do[0][100] == false); test(_do[0][101] == false); test(_do[1].size() == 2); test(_do[1][10] == true); test(_do[1][100] == false); test(_do[2].size() == 3); test(_do[2][10] == true); test(_do[2][11] == false); test(_do[2][101] == true); } catch(const Ice::OperationNotExistException&) { } } { Test::ShortIntDS dsi1; dsi1.resize(2); Test::ShortIntDS dsi2; dsi2.resize(1); Test::ShortIntD di1; di1[110] = -1; di1[1100] = 123123; Test::ShortIntD di2; di2[110] = -1; di2[111] = -100; di2[1101] = 0; Test::ShortIntD di3; di3[100] = -1001; dsi1[0] = di1; dsi1[1] = di2; dsi2[0] = di3; try { Test::ShortIntDS _do; Test::ShortIntDS ro = p->opShortIntDS(dsi1, dsi2, _do); test(ro.size() == 2); test(ro[0].size() == 3); test(ro[0][110] == -1); test(ro[0][111] == -100); test(ro[0][1101] == 0); test(ro[1].size() == 2); test(ro[1][110] == -1); test(ro[1][1100] == 123123); test(_do.size() == 3); test(_do[0].size() == 1); test(_do[0][100] == -1001); test(_do[1].size() == 2); test(_do[1][110] == -1); test(_do[1][1100] == 123123); test(_do[2].size() == 3); test(_do[2][110] == -1); test(_do[2][111] == -100); test(_do[2][1101] == 0); } catch(const Ice::OperationNotExistException&) { } } { Test::LongFloatDS dsi1; dsi1.resize(2); Test::LongFloatDS dsi2; dsi2.resize(1); Test::LongFloatD di1; di1[999999110] = Ice::Float(-1.1); di1[999999111] = Ice::Float(123123.2); Test::LongFloatD di2; di2[999999110] = Ice::Float(-1.1); di2[999999120] = Ice::Float(-100.4); di2[999999130] = Ice::Float(0.5); Test::LongFloatD di3; di3[999999140] = Ice::Float(3.14); dsi1[0] = di1; dsi1[1] = di2; dsi2[0] = di3; try { Test::LongFloatDS _do; Test::LongFloatDS ro = p->opLongFloatDS(dsi1, dsi2, _do); test(ro.size() == 2); test(ro[0].size() == 3); test(ro[0][999999110] == Ice::Float(-1.1)); test(ro[0][999999120] == Ice::Float(-100.4)); test(ro[0][999999130] == Ice::Float(0.5)); test(ro[1].size() == 2); test(ro[1][999999110] == Ice::Float(-1.1)); test(ro[1][999999111] == Ice::Float(123123.2)); test(_do.size() == 3); test(_do[0].size() == 1); test(_do[0][999999140] == Ice::Float(3.14)); test(_do[1].size() == 2); test(_do[1][999999110] == Ice::Float(-1.1)); test(_do[1][999999111] == Ice::Float(123123.2)); test(_do[2].size() == 3); test(_do[2][999999110] == Ice::Float(-1.1)); test(_do[2][999999120] == Ice::Float(-100.4)); test(_do[2][999999130] == Ice::Float(0.5)); } catch(const Ice::OperationNotExistException&) { } } { Test::StringStringDS dsi1; dsi1.resize(2); Test::StringStringDS dsi2; dsi2.resize(1); Test::StringStringD di1; di1["foo"] = "abc -1.1"; di1["bar"] = "abc 123123.2"; Test::StringStringD di2; di2["foo"] = "abc -1.1"; di2["FOO"] = "abc -100.4"; di2["BAR"] = "abc 0.5"; Test::StringStringD di3; di3["f00"] = "ABC -3.14"; dsi1[0] = di1; dsi1[1] = di2; dsi2[0] = di3; try { Test::StringStringDS _do; Test::StringStringDS ro = p->opStringStringDS(dsi1, dsi2, _do); test(ro.size() == 2); test(ro[0].size() == 3); test(ro[0]["foo"] == "abc -1.1"); test(ro[0]["FOO"] == "abc -100.4"); test(ro[0]["BAR"] == "abc 0.5"); test(ro[1].size() == 2); test(ro[1]["foo"] == "abc -1.1"); test(ro[1]["bar"] == "abc 123123.2"); test(_do.size() == 3); test(_do[0].size() == 1); test(_do[0]["f00"] == "ABC -3.14"); test(_do[1].size() == 2); test(_do[1]["foo"] == "abc -1.1"); test(_do[1]["bar"] == "abc 123123.2"); test(_do[2].size() == 3); test(_do[2]["foo"] == "abc -1.1"); test(_do[2]["FOO"] == "abc -100.4"); test(_do[2]["BAR"] == "abc 0.5"); } catch(const Ice::OperationNotExistException&) { } } { Test::StringMyEnumDS dsi1; dsi1.resize(2); Test::StringMyEnumDS dsi2; dsi2.resize(1); Test::StringMyEnumD di1; di1["abc"] = ICE_ENUM(MyEnum, enum1); di1[""] = ICE_ENUM(MyEnum, enum2); Test::StringMyEnumD di2; di2["abc"] = ICE_ENUM(MyEnum, enum1); di2["qwerty"] = ICE_ENUM(MyEnum, enum3); di2["Hello!!"] = ICE_ENUM(MyEnum, enum2); Test::StringMyEnumD di3; di3["Goodbye"] = ICE_ENUM(MyEnum, enum1); dsi1[0] = di1; dsi1[1] = di2; dsi2[0] = di3; try { Test::StringMyEnumDS _do; Test::StringMyEnumDS ro = p->opStringMyEnumDS(dsi1, dsi2, _do); test(ro.size() == 2); test(ro[0].size() == 3); test(ro[0]["abc"] == ICE_ENUM(MyEnum, enum1)); test(ro[0]["qwerty"] == ICE_ENUM(MyEnum, enum3)); test(ro[0]["Hello!!"] == ICE_ENUM(MyEnum, enum2)); test(ro[1].size() == 2); test(ro[1]["abc"] == ICE_ENUM(MyEnum, enum1)); test(ro[1][""] == ICE_ENUM(MyEnum, enum2)); test(_do.size() == 3); test(_do[0].size() == 1); test(_do[0]["Goodbye"] == ICE_ENUM(MyEnum, enum1)); test(_do[1].size() == 2); test(_do[1]["abc"] == ICE_ENUM(MyEnum, enum1)); test(_do[1][""] == ICE_ENUM(MyEnum, enum2)); test(_do[2].size() == 3); test(_do[2]["abc"] == ICE_ENUM(MyEnum, enum1)); test(_do[2]["qwerty"] == ICE_ENUM(MyEnum, enum3)); test(_do[2]["Hello!!"] == ICE_ENUM(MyEnum, enum2)); } catch(const Ice::OperationNotExistException&) { } } { Test::MyEnumStringDS dsi1; dsi1.resize(2); Test::MyEnumStringDS dsi2; dsi2.resize(1); Test::MyEnumStringD di1; di1[ICE_ENUM(MyEnum, enum1)] = "abc"; Test::MyEnumStringD di2; di2[ICE_ENUM(MyEnum, enum2)] = "Hello!!"; di2[ICE_ENUM(MyEnum, enum3)] = "qwerty"; Test::MyEnumStringD di3; di3[ICE_ENUM(MyEnum, enum1)] = "Goodbye"; dsi1[0] = di1; dsi1[1] = di2; dsi2[0] = di3; try { Test::MyEnumStringDS _do; Test::MyEnumStringDS ro = p->opMyEnumStringDS(dsi1, dsi2, _do); test(ro.size() == 2); test(ro[0].size() == 2); test(ro[0][ICE_ENUM(MyEnum, enum2)] == "Hello!!"); test(ro[0][ICE_ENUM(MyEnum, enum3)] == "qwerty"); test(ro[1].size() == 1); test(ro[1][ICE_ENUM(MyEnum, enum1)] == "abc"); test(_do.size() == 3); test(_do[0].size() == 1); test(_do[0][ICE_ENUM(MyEnum, enum1)] == "Goodbye"); test(_do[1].size() == 1); test(_do[1][ICE_ENUM(MyEnum, enum1)] == "abc"); test(_do[2].size() == 2); test(_do[2][ICE_ENUM(MyEnum, enum2)] == "Hello!!"); test(_do[2][ICE_ENUM(MyEnum, enum3)] == "qwerty"); } catch(const Ice::OperationNotExistException&) { } } { Test::MyStructMyEnumDS dsi1; dsi1.resize(2); Test::MyStructMyEnumDS dsi2; dsi2.resize(1); Test::MyStruct s11 = { 1, 1 }; Test::MyStruct s12 = { 1, 2 }; Test::MyStructMyEnumD di1; di1[s11] = ICE_ENUM(MyEnum, enum1); di1[s12] = ICE_ENUM(MyEnum, enum2); Test::MyStruct s22 = { 2, 2 }; Test::MyStruct s23 = { 2, 3 }; Test::MyStructMyEnumD di2; di2[s11] = ICE_ENUM(MyEnum, enum1); di2[s22] = ICE_ENUM(MyEnum, enum3); di2[s23] = ICE_ENUM(MyEnum, enum2); Test::MyStructMyEnumD di3; di3[s23] = ICE_ENUM(MyEnum, enum3); dsi1[0] = di1; dsi1[1] = di2; dsi2[0] = di3; try { Test::MyStructMyEnumDS _do; Test::MyStructMyEnumDS ro = p->opMyStructMyEnumDS(dsi1, dsi2, _do); test(ro.size() == 2); test(ro[0].size() == 3); test(ro[0][s11] == ICE_ENUM(MyEnum, enum1)); test(ro[0][s22] == ICE_ENUM(MyEnum, enum3)); test(ro[0][s23] == ICE_ENUM(MyEnum, enum2)); test(ro[1].size() == 2); test(ro[1][s11] == ICE_ENUM(MyEnum, enum1)); test(ro[1][s12] == ICE_ENUM(MyEnum, enum2)); test(_do.size() == 3); test(_do[0].size() == 1); test(_do[0][s23] == ICE_ENUM(MyEnum, enum3)); test(_do[1].size() == 2); test(_do[1][s11] == ICE_ENUM(MyEnum, enum1)); test(_do[1][s12] == ICE_ENUM(MyEnum, enum2)); test(_do[2].size() == 3); test(_do[2][s11] == ICE_ENUM(MyEnum, enum1)); test(_do[2][s22] == ICE_ENUM(MyEnum, enum3)); test(_do[2][s23] == ICE_ENUM(MyEnum, enum2)); } catch(const Ice::OperationNotExistException&) { } } { Test::ByteByteSD sdi1; Test::ByteByteSD sdi2; Test::ByteS si1; Test::ByteS si2; Test::ByteS si3; si1.push_back(Ice::Byte(0x01)); si1.push_back(Ice::Byte(0x11)); si2.push_back(Ice::Byte(0x12)); si3.push_back(Ice::Byte(0xf2)); si3.push_back(Ice::Byte(0xf3)); sdi1[Ice::Byte(0x01)] = si1; sdi1[Ice::Byte(0x22)] = si2; sdi2[Ice::Byte(0xf1)] = si3; try { Test::ByteByteSD _do; Test::ByteByteSD ro = p->opByteByteSD(sdi1, sdi2, _do); test(_do == sdi2); test(ro.size() == 3); test(ro[Ice::Byte(0x01)].size() == 2); test(ro[Ice::Byte(0x01)][0] == Ice::Byte(0x01)); test(ro[Ice::Byte(0x01)][1] == Ice::Byte(0x11)); test(ro[Ice::Byte(0x22)].size() == 1); test(ro[Ice::Byte(0x22)][0] == Ice::Byte(0x12)); test(ro[Ice::Byte(0xf1)].size() == 2); test(ro[Ice::Byte(0xf1)][0] == Ice::Byte(0xf2)); test(ro[Ice::Byte(0xf1)][1] == Ice::Byte(0xf3)); } catch(const Ice::OperationNotExistException&) { } } { Test::BoolBoolSD sdi1; Test::BoolBoolSD sdi2; Test::BoolS si1; Test::BoolS si2; si1.push_back(true); si1.push_back(false); si2.push_back(false); si2.push_back(true); si2.push_back(true); sdi1[false] = si1; sdi1[true] = si2; sdi2[false] = si1; try { Test::BoolBoolSD _do; Test::BoolBoolSD ro = p->opBoolBoolSD(sdi1, sdi2, _do); test(_do == sdi2); test(ro.size() == 2); test(ro[false].size() == 2); test(ro[false][0] == true); test(ro[false][1] == false); test(ro[true].size() == 3); test(ro[true][0] == false); test(ro[true][1] == true); test(ro[true][2] == true); } catch(const Ice::OperationNotExistException&) { } } { Test::ShortShortSD sdi1; Test::ShortShortSD sdi2; Test::ShortS si1; Test::ShortS si2; Test::ShortS si3; si1.push_back(1); si1.push_back(2); si1.push_back(3); si2.push_back(4); si2.push_back(5); si3.push_back(6); si3.push_back(7); sdi1[1] = si1; sdi1[2] = si2; sdi2[4] = si3; try { Test::ShortShortSD _do; Test::ShortShortSD ro = p->opShortShortSD(sdi1, sdi2, _do); test(_do == sdi2); test(ro.size() == 3); test(ro[1].size() == 3); test(ro[1][0] == 1); test(ro[1][1] == 2); test(ro[1][2] == 3); test(ro[2].size() == 2); test(ro[2][0] == 4); test(ro[2][1] == 5); test(ro[4].size() == 2); test(ro[4][0] == 6); test(ro[4][1] == 7); } catch(const Ice::OperationNotExistException&) { } } { Test::IntIntSD sdi1; Test::IntIntSD sdi2; Test::IntS si1; Test::IntS si2; Test::IntS si3; si1.push_back(100); si1.push_back(200); si1.push_back(300); si2.push_back(400); si2.push_back(500); si3.push_back(600); si3.push_back(700); sdi1[100] = si1; sdi1[200] = si2; sdi2[400] = si3; try { Test::IntIntSD _do; Test::IntIntSD ro = p->opIntIntSD(sdi1, sdi2, _do); test(_do == sdi2); test(ro.size() == 3); test(ro[100].size() == 3); test(ro[100][0] == 100); test(ro[100][1] == 200); test(ro[100][2] == 300); test(ro[200].size() == 2); test(ro[200][0] == 400); test(ro[200][1] == 500); test(ro[400].size() == 2); test(ro[400][0] == 600); test(ro[400][1] == 700); } catch(const Ice::OperationNotExistException&) { } } { Test::LongLongSD sdi1; Test::LongLongSD sdi2; Test::LongS si1; Test::LongS si2; Test::LongS si3; si1.push_back(999999110); si1.push_back(999999111); si1.push_back(999999110); si2.push_back(999999120); si2.push_back(999999130); si3.push_back(999999110); si3.push_back(999999120); sdi1[999999990] = si1; sdi1[999999991] = si2; sdi2[999999992] = si3; try { Test::LongLongSD _do; Test::LongLongSD ro = p->opLongLongSD(sdi1, sdi2, _do); test(_do == sdi2); test(ro.size() == 3); test(ro[999999990].size() == 3); test(ro[999999990][0] == 999999110); test(ro[999999990][1] == 999999111); test(ro[999999990][2] == 999999110); test(ro[999999991].size() == 2); test(ro[999999991][0] == 999999120); test(ro[999999991][1] == 999999130); test(ro[999999992].size() == 2); test(ro[999999992][0] == 999999110); test(ro[999999992][1] == 999999120); } catch(const Ice::OperationNotExistException&) { } } { Test::StringFloatSD sdi1; Test::StringFloatSD sdi2; Test::FloatS si1; Test::FloatS si2; Test::FloatS si3; si1.push_back(Ice::Float(-1.1)); si1.push_back(Ice::Float(123123.2)); si1.push_back(Ice::Float(100.0)); si2.push_back(Ice::Float(42.24)); si2.push_back(Ice::Float(-1.61)); si3.push_back(Ice::Float(-3.14)); si3.push_back(Ice::Float(3.14)); sdi1["abc"] = si1; sdi1["ABC"] = si2; sdi2["aBc"] = si3; try { Test::StringFloatSD _do; Test::StringFloatSD ro = p->opStringFloatSD(sdi1, sdi2, _do); test(_do == sdi2); test(ro.size() == 3); test(ro["abc"].size() == 3); test(ro["abc"][0] == Ice::Float(-1.1)); test(ro["abc"][1] == Ice::Float(123123.2)); test(ro["abc"][2] == Ice::Float(100.0)); test(ro["ABC"].size() == 2); test(ro["ABC"][0] == Ice::Float(42.24)); test(ro["ABC"][1] == Ice::Float(-1.61)); test(ro["aBc"].size() == 2); test(ro["aBc"][0] == Ice::Float(-3.14)); test(ro["aBc"][1] == Ice::Float(3.14)); } catch(const Ice::OperationNotExistException&) { } } { Test::StringDoubleSD sdi1; Test::StringDoubleSD sdi2; Test::DoubleS si1; Test::DoubleS si2; Test::DoubleS si3; si1.push_back(Ice::Double(1.1E10)); si1.push_back(Ice::Double(1.2E10)); si1.push_back(Ice::Double(1.3E10)); si2.push_back(Ice::Double(1.4E10)); si2.push_back(Ice::Double(1.5E10)); si3.push_back(Ice::Double(1.6E10)); si3.push_back(Ice::Double(1.7E10)); sdi1["Hello!!"] = si1; sdi1["Goodbye"] = si2; sdi2[""] = si3; try { Test::StringDoubleSD _do; Test::StringDoubleSD ro = p->opStringDoubleSD(sdi1, sdi2, _do); test(_do == sdi2); test(ro.size() == 3); test(ro["Hello!!"].size() == 3); test(ro["Hello!!"][0] == Ice::Double(1.1E10)); test(ro["Hello!!"][1] == Ice::Double(1.2E10)); test(ro["Hello!!"][2] == Ice::Double(1.3E10)); test(ro["Goodbye"].size() == 2); test(ro["Goodbye"][0] == Ice::Double(1.4E10)); test(ro["Goodbye"][1] == Ice::Double(1.5E10)); test(ro[""].size() == 2); test(ro[""][0] == Ice::Double(1.6E10)); test(ro[""][1] == Ice::Double(1.7E10)); } catch(const Ice::OperationNotExistException&) { } } { Test::StringStringSD sdi1; Test::StringStringSD sdi2; Test::StringS si1; Test::StringS si2; Test::StringS si3; si1.push_back("abc"); si1.push_back("de"); si1.push_back("fghi"); si2.push_back("xyz"); si2.push_back("or"); si3.push_back("and"); si3.push_back("xor"); sdi1["abc"] = si1; sdi1["def"] = si2; sdi2["ghi"] = si3; try { Test::StringStringSD _do; Test::StringStringSD ro = p->opStringStringSD(sdi1, sdi2, _do); test(_do == sdi2); test(ro.size() == 3); test(ro["abc"].size() == 3); test(ro["abc"][0] == "abc"); test(ro["abc"][1] == "de"); test(ro["abc"][2] == "fghi"); test(ro["def"].size() == 2); test(ro["def"][0] == "xyz"); test(ro["def"][1] == "or"); test(ro["ghi"].size() == 2); test(ro["ghi"][0] == "and"); test(ro["ghi"][1] == "xor"); } catch(const Ice::OperationNotExistException&) { } } { Test::MyEnumMyEnumSD sdi1; Test::MyEnumMyEnumSD sdi2; Test::MyEnumS si1; Test::MyEnumS si2; Test::MyEnumS si3; si1.push_back(ICE_ENUM(MyEnum, enum1)); si1.push_back(ICE_ENUM(MyEnum, enum1)); si1.push_back(ICE_ENUM(MyEnum, enum2)); si2.push_back(ICE_ENUM(MyEnum, enum1)); si2.push_back(ICE_ENUM(MyEnum, enum2)); si3.push_back(ICE_ENUM(MyEnum, enum3)); si3.push_back(ICE_ENUM(MyEnum, enum3)); sdi1[ICE_ENUM(MyEnum, enum3)] = si1; sdi1[ICE_ENUM(MyEnum, enum2)] = si2; sdi2[ICE_ENUM(MyEnum, enum1)] = si3; try { Test::MyEnumMyEnumSD _do; Test::MyEnumMyEnumSD ro = p->opMyEnumMyEnumSD(sdi1, sdi2, _do); test(_do == sdi2); test(ro.size() == 3); test(ro[ICE_ENUM(MyEnum, enum3)].size() == 3); test(ro[ICE_ENUM(MyEnum, enum3)][0] == ICE_ENUM(MyEnum, enum1)); test(ro[ICE_ENUM(MyEnum, enum3)][1] == ICE_ENUM(MyEnum, enum1)); test(ro[ICE_ENUM(MyEnum, enum3)][2] == ICE_ENUM(MyEnum, enum2)); test(ro[ICE_ENUM(MyEnum, enum2)].size() == 2); test(ro[ICE_ENUM(MyEnum, enum2)][0] == ICE_ENUM(MyEnum, enum1)); test(ro[ICE_ENUM(MyEnum, enum2)][1] == ICE_ENUM(MyEnum, enum2)); test(ro[ICE_ENUM(MyEnum, enum1)].size() == 2); test(ro[ICE_ENUM(MyEnum, enum1)][0] == ICE_ENUM(MyEnum, enum3)); test(ro[ICE_ENUM(MyEnum, enum1)][1] == ICE_ENUM(MyEnum, enum3)); } catch(const Ice::OperationNotExistException&) { } } { const int lengths[] = { 0, 1, 2, 126, 127, 128, 129, 253, 254, 255, 256, 257, 1000 }; for(unsigned int l = 0; l != sizeof(lengths) / sizeof(*lengths); ++l) { Test::IntS s; for(int i = 0; i < lengths[l]; ++i) { s.push_back(i); } Test::IntS r = p->opIntS(s); test(r.size() == static_cast<size_t>(lengths[l])); for(int j = 0; j < static_cast<int>(r.size()); ++j) { test(r[j] == -j); } } } { Ice::Context ctx; ctx["one"] = "ONE"; ctx["two"] = "TWO"; ctx["three"] = "THREE"; { Test::StringStringD r = p->opContext(); test(p->ice_getContext().empty()); test(r != ctx); } { Test::StringStringD r = p->opContext(ctx); test(p->ice_getContext().empty()); test(r == ctx); } { Test::MyClassPrxPtr p2 = ICE_CHECKED_CAST(Test::MyClassPrx, p->ice_context(ctx)); test(p2->ice_getContext() == ctx); Test::StringStringD r = p2->opContext(); test(r == ctx); r = p2->opContext(ctx); test(r == ctx); } #ifndef ICE_OS_WINRT if(p->ice_getConnection() && communicator->getProperties()->getProperty("Ice.Default.Protocol") != "bt") { // // Test implicit context propagation // string impls[] = {"Shared", "PerThread"}; for(int i = 0; i < 2; i++) { Ice::InitializationData initData; initData.properties = communicator->getProperties()->clone(); initData.properties->setProperty("Ice.ImplicitContext", impls[i]); Ice::CommunicatorPtr ic = Ice::initialize(initData); Ice::Context ctx; ctx["one"] = "ONE"; ctx["two"] = "TWO"; ctx["three"] = "THREE"; Test::MyClassPrxPtr p = ICE_UNCHECKED_CAST(Test::MyClassPrx, ic->stringToProxy("test:" + getTestEndpoint(ic, 0))); ic->getImplicitContext()->setContext(ctx); test(ic->getImplicitContext()->getContext() == ctx); test(p->opContext() == ctx); test(ic->getImplicitContext()->containsKey("zero") == false); string r = ic->getImplicitContext()->put("zero", "ZERO"); test(r == ""); test(ic->getImplicitContext()->containsKey("zero") == true); test(ic->getImplicitContext()->get("zero") == "ZERO"); ctx = ic->getImplicitContext()->getContext(); test(p->opContext() == ctx); Ice::Context prxContext; prxContext["one"] = "UN"; prxContext["four"] = "QUATRE"; Ice::Context combined = prxContext; combined.insert(ctx.begin(), ctx.end()); test(combined["one"] == "UN"); p = ICE_UNCHECKED_CAST(Test::MyClassPrx, p->ice_context(prxContext)); ic->getImplicitContext()->setContext(Ice::Context()); test(p->opContext() == prxContext); ic->getImplicitContext()->setContext(ctx); test(p->opContext() == combined); test(ic->getImplicitContext()->remove("one") == "ONE"); if(impls[i] == "PerThread") { IceUtil::ThreadPtr thread = new PerThreadContextInvokeThread(p->ice_context(Ice::Context())); thread->start(); thread->getThreadControl().join(); } ic->getImplicitContext()->setContext(Ice::Context()); // Clear the context to avoid leak report. ic->destroy(); } } #endif } { Ice::Double d = 1278312346.0 / 13.0; Test::DoubleS ds(5, d); p->opDoubleMarshaling(d, ds); } p->opIdempotent(); p->opNonmutating(); test(p->opByte1(0xFF) == 0xFF); test(p->opShort1(0x7FFF) == 0x7FFF); test(p->opInt1(0x7FFFFFFF) == 0x7FFFFFFF); test(p->opLong1(0x7FFFFFFFFFFFFFFFLL) == 0x7FFFFFFFFFFFFFFFLL); test(p->opFloat1(1.0) == 1.0); test(p->opDouble1(1.0) == 1.0); test(p->opString1("opString1") == "opString1"); Test::MyDerivedClassPrxPtr d = ICE_UNCHECKED_CAST(Test::MyDerivedClassPrx, p); Test::MyStruct1 s; s.tesT = "Test::MyStruct1::s"; s.myClass = 0; s.myStruct1 = "Test::MyStruct1::myStruct1"; s = d->opMyStruct1(s); test(s.tesT == "Test::MyStruct1::s"); test(s.myClass == 0); test(s.myStruct1 == "Test::MyStruct1::myStruct1"); Test::MyClass1Ptr c = ICE_MAKE_SHARED(Test::MyClass1); c->tesT = "Test::MyClass1::testT"; c->myClass = 0; c->myClass1 = "Test::MyClass1::myClass1"; c = d->opMyClass1(c); test(c->tesT == "Test::MyClass1::testT"); test(c->myClass == 0); test(c->myClass1 == "Test::MyClass1::myClass1"); Test::StringS seq; p->opStringS1(seq); Test::ByteBoolD dict; p->opByteBoolD1(dict); }
Ice::AsyncResultPtr Glacier2::Request::invoke(const Callback_Object_ice_invokePtr& cb) { pair<const Byte*, const Byte*> inPair; if(_inParams.size() == 0) { inPair.first = inPair.second = 0; } else { inPair.first = &_inParams[0]; inPair.second = inPair.first + _inParams.size(); } if(_proxy->ice_isBatchOneway() || _proxy->ice_isBatchDatagram()) { ByteSeq outParams; if(_forwardContext) { if(_sslContext.size() > 0) { Ice::Context ctx = _current.ctx; ctx.insert(_sslContext.begin(), _sslContext.end()); _proxy->ice_invoke(_current.operation, _current.mode, inPair, outParams, ctx); } else { _proxy->ice_invoke(_current.operation, _current.mode, inPair, outParams, _current.ctx); } } else { if(_sslContext.size() > 0) { _proxy->ice_invoke(_current.operation, _current.mode, inPair, outParams, _sslContext); } else { _proxy->ice_invoke(_current.operation, _current.mode, inPair, outParams); } } return 0; } else { Ice::AsyncResultPtr result; if(_forwardContext) { if(_sslContext.size() > 0) { Ice::Context ctx = _current.ctx; ctx.insert(_sslContext.begin(), _sslContext.end()); result = _proxy->begin_ice_invoke(_current.operation, _current.mode, inPair, ctx, cb, this); } else { result = _proxy->begin_ice_invoke(_current.operation, _current.mode, inPair, _current.ctx, cb, this); } } else { if(_sslContext.size() > 0) { result = _proxy->begin_ice_invoke(_current.operation, _current.mode, inPair, _sslContext, cb, this); } else { result = _proxy->begin_ice_invoke(_current.operation, _current.mode, inPair, cb, this); } } return result; } }
Test::MyClassPrx allTests(const Ice::CommunicatorPtr& communicator) { tprintf("testing stringToProxy... "); string ref = "test:default -p 12010 -t 10000"; Ice::ObjectPrx base = communicator->stringToProxy(ref); test(base); Ice::ObjectPrx b1 = communicator->stringToProxy("test:tcp"); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category.empty() && b1->ice_getAdapterId().empty() && b1->ice_getFacet().empty()); b1 = communicator->stringToProxy("test :tcp"); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category.empty() && b1->ice_getFacet().empty()); b1 = communicator->stringToProxy(" test :tcp"); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category.empty() && b1->ice_getFacet().empty()); b1 = communicator->stringToProxy(" test:tcp"); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category.empty() && b1->ice_getFacet().empty()); b1 = communicator->stringToProxy("'test -f facet':tcp"); test(b1->ice_getIdentity().name == "test -f facet" && b1->ice_getIdentity().category.empty() && b1->ice_getFacet().empty()); try { b1 = communicator->stringToProxy("\"test -f facet':tcp"); test(false); } catch(const Ice::ProxyParseException&) { } b1 = communicator->stringToProxy("\"test -f facet\""); test(b1->ice_getIdentity().name == "test -f facet" && b1->ice_getIdentity().category.empty() && b1->ice_getFacet().empty()); b1 = communicator->stringToProxy("\"test -f facet@test\""); test(b1->ice_getIdentity().name == "test -f facet@test" && b1->ice_getIdentity().category.empty() && b1->ice_getFacet().empty()); b1 = communicator->stringToProxy("\"test -f facet@test @test\""); test(b1->ice_getIdentity().name == "test -f facet@test @test" && b1->ice_getIdentity().category.empty() && b1->ice_getFacet().empty()); try { b1 = communicator->stringToProxy("test test:tcp"); test(false); } catch(const Ice::ProxyParseException&) { } b1 = communicator->stringToProxy("test\\040test:tcp"); test(b1->ice_getIdentity().name == "test test" && b1->ice_getIdentity().category.empty()); try { b1 = communicator->stringToProxy("test\\777"); test(false); } catch(const Ice::IdentityParseException&) { } b1 = communicator->stringToProxy("test\\40test"); test(b1->ice_getIdentity().name == "test test"); // Test some octal and hex corner cases. b1 = communicator->stringToProxy("test\\4test"); test(b1->ice_getIdentity().name == "test\4test"); b1 = communicator->stringToProxy("test\\04test"); test(b1->ice_getIdentity().name == "test\4test"); b1 = communicator->stringToProxy("test\\004test"); test(b1->ice_getIdentity().name == "test\4test"); b1 = communicator->stringToProxy("test\\1114test"); test(b1->ice_getIdentity().name == "test\1114test"); b1 = communicator->stringToProxy("test\\b\\f\\n\\r\\t\\'\\\"\\\\test"); test(b1->ice_getIdentity().name == "test\b\f\n\r\t\'\"\\test" && b1->ice_getIdentity().category.empty()); b1 = communicator->stringToProxy("category/test"); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category == "category"); b1 = communicator->stringToProxy("test@adapter"); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category.empty() && b1->ice_getAdapterId() == "adapter"); try { b1 = communicator->stringToProxy("id@adapter test"); test(false); } catch(const Ice::ProxyParseException&) { } b1 = communicator->stringToProxy("category/test@adapter"); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category == "category" && b1->ice_getAdapterId() == "adapter"); b1 = communicator->stringToProxy("category/test@adapter:tcp"); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category == "category" && b1->ice_getAdapterId() == "adapter:tcp"); b1 = communicator->stringToProxy("'category 1/test'@adapter"); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category == "category 1" && b1->ice_getAdapterId() == "adapter"); b1 = communicator->stringToProxy("'category/test 1'@adapter"); test(b1->ice_getIdentity().name == "test 1" && b1->ice_getIdentity().category == "category" && b1->ice_getAdapterId() == "adapter"); b1 = communicator->stringToProxy("'category/test'@'adapter 1'"); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category == "category" && b1->ice_getAdapterId() == "adapter 1"); b1 = communicator->stringToProxy("\"category \\/test@foo/test\"@adapter"); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category == "category /test@foo" && b1->ice_getAdapterId() == "adapter"); b1 = communicator->stringToProxy("\"category \\/test@foo/test\"@\"adapter:tcp\""); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category == "category /test@foo" && b1->ice_getAdapterId() == "adapter:tcp"); b1 = communicator->stringToProxy("id -f facet:tcp"); test(b1->ice_getIdentity().name == "id" && b1->ice_getIdentity().category.empty() && b1->ice_getFacet() == "facet"); b1 = communicator->stringToProxy("id -f 'facet x':tcp"); test(b1->ice_getIdentity().name == "id" && b1->ice_getIdentity().category.empty() && b1->ice_getFacet() == "facet x"); b1 = communicator->stringToProxy("id -f \"facet x\":tcp"); test(b1->ice_getIdentity().name == "id" && b1->ice_getIdentity().category.empty() && b1->ice_getFacet() == "facet x"); try { b1 = communicator->stringToProxy("id -f \"facet x"); test(false); } catch(const Ice::ProxyParseException&) { } try { b1 = communicator->stringToProxy("id -f \'facet x"); test(false); } catch(const Ice::ProxyParseException&) { } b1 = communicator->stringToProxy("test -f facet:tcp"); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category.empty() && b1->ice_getFacet() == "facet" && b1->ice_getAdapterId().empty()); b1 = communicator->stringToProxy("test -f \"facet:tcp\""); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category.empty() && b1->ice_getFacet() == "facet:tcp" && b1->ice_getAdapterId().empty()); b1 = communicator->stringToProxy("test -f facet@test"); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category.empty() && b1->ice_getFacet() == "facet" && b1->ice_getAdapterId() == "test"); b1 = communicator->stringToProxy("test -f 'facet@test'"); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category.empty() && b1->ice_getFacet() == "facet@test" && b1->ice_getAdapterId().empty()); b1 = communicator->stringToProxy("test -f 'facet@test'@test"); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category.empty() && b1->ice_getFacet() == "facet@test" && b1->ice_getAdapterId() == "test"); try { b1 = communicator->stringToProxy("test -f facet@test @test"); test(false); } catch(const Ice::ProxyParseException&) { } b1 = communicator->stringToProxy("test"); test(b1->ice_isTwoway()); b1 = communicator->stringToProxy("test -t"); test(b1->ice_isTwoway()); b1 = communicator->stringToProxy("test -o"); test(b1->ice_isOneway()); b1 = communicator->stringToProxy("test -O"); test(b1->ice_isBatchOneway()); b1 = communicator->stringToProxy("test -d"); test(b1->ice_isDatagram()); b1 = communicator->stringToProxy("test -D"); test(b1->ice_isBatchDatagram()); b1 = communicator->stringToProxy("test"); test(!b1->ice_isSecure()); b1 = communicator->stringToProxy("test -s"); test(b1->ice_isSecure()); try { b1 = communicator->stringToProxy("test:tcp@adapterId"); test(false); } catch(const Ice::EndpointParseException&) { } // This is an unknown endpoint warning, not a parse exception. // //try //{ // b1 = communicator->stringToProxy("test -f the:facet:tcp"); // test(false); //} //catch(const Ice::EndpointParseException&) //{ //} try { b1 = communicator->stringToProxy("test::tcp"); test(false); } catch(const Ice::EndpointParseException&) { } tprintf("ok\n"); tprintf("testing propertyToProxy... "); Ice::PropertiesPtr prop = communicator->getProperties(); string propertyPrefix = "Foo.Proxy"; prop->setProperty(propertyPrefix, "test:default -p 12010 -t 10000"); b1 = communicator->propertyToProxy(propertyPrefix); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category.empty() && b1->ice_getAdapterId().empty() && b1->ice_getFacet().empty()); string property; #ifdef ICEE_HAS_LOCATOR property = propertyPrefix + ".Locator"; test(!b1->ice_getLocator()); prop->setProperty(property, "locator:default -p 10000"); b1 = communicator->propertyToProxy(propertyPrefix); test(b1->ice_getLocator() && b1->ice_getLocator()->ice_getIdentity().name == "locator"); prop->setProperty(property, ""); #endif // Now retest with an indirect proxy. #ifdef ICEE_HAS_LOCATOR prop->setProperty(propertyPrefix, "test"); property = propertyPrefix + ".Locator"; prop->setProperty(property, "locator:default -p 10000"); b1 = communicator->propertyToProxy(propertyPrefix); test(b1->ice_getLocator() && b1->ice_getLocator()->ice_getIdentity().name == "locator"); prop->setProperty(property, ""); #endif prop->setProperty(propertyPrefix, "test:default -p 12010 -t 10000"); #ifdef ICEE_HAS_ROUTER property = propertyPrefix + ".Router"; test(!b1->ice_getRouter()); prop->setProperty(property, "router:default -p 10000"); b1 = communicator->propertyToProxy(propertyPrefix); test(b1->ice_getRouter() && b1->ice_getRouter()->ice_getIdentity().name == "router"); prop->setProperty(property, ""); #endif tprintf("ok\n"); tprintf("testing ice_getCommunicator... "); test(base->ice_getCommunicator() == communicator); tprintf("ok\n"); tprintf("testing proxy methods... "); test(communicator->identityToString(base->ice_identity(communicator->stringToIdentity("other"))->ice_getIdentity()) == "other"); test(base->ice_facet("facet")->ice_getFacet() == "facet"); test(base->ice_adapterId("id")->ice_getAdapterId() == "id"); test(base->ice_twoway()->ice_isTwoway()); test(base->ice_oneway()->ice_isOneway()); test(base->ice_batchOneway()->ice_isBatchOneway()); test(base->ice_datagram()->ice_isDatagram()); test(base->ice_batchDatagram()->ice_isBatchDatagram()); test(base->ice_secure(true)->ice_isSecure()); test(!base->ice_secure(false)->ice_isSecure()); tprintf("ok\n"); tprintf("testing proxy comparison... "); test(communicator->stringToProxy("foo") == communicator->stringToProxy("foo")); test(communicator->stringToProxy("foo") != communicator->stringToProxy("foo2")); test(communicator->stringToProxy("foo") < communicator->stringToProxy("foo2")); test(!(communicator->stringToProxy("foo2") < communicator->stringToProxy("foo"))); Ice::ObjectPrx compObj = communicator->stringToProxy("foo"); test(compObj->ice_facet("facet") == compObj->ice_facet("facet")); test(compObj->ice_facet("facet") != compObj->ice_facet("facet1")); test(compObj->ice_facet("facet") < compObj->ice_facet("facet1")); test(!(compObj->ice_facet("facet") < compObj->ice_facet("facet"))); test(compObj->ice_oneway() == compObj->ice_oneway()); test(compObj->ice_oneway() != compObj->ice_twoway()); test(compObj->ice_twoway() < compObj->ice_oneway()); test(!(compObj->ice_oneway() < compObj->ice_twoway())); test(compObj->ice_secure(true) == compObj->ice_secure(true)); test(compObj->ice_secure(false) != compObj->ice_secure(true)); test(compObj->ice_secure(false) < compObj->ice_secure(true)); test(!(compObj->ice_secure(true) < compObj->ice_secure(false))); test(compObj->ice_timeout(20) == compObj->ice_timeout(20)); test(compObj->ice_timeout(10) != compObj->ice_timeout(20)); test(compObj->ice_timeout(10) < compObj->ice_timeout(20)); test(!(compObj->ice_timeout(20) < compObj->ice_timeout(10))); #ifdef ICEE_HAS_LOCATOR Ice::LocatorPrx loc1 = Ice::LocatorPrx::uncheckedCast(communicator->stringToProxy("loc1:default -p 10000")); Ice::LocatorPrx loc2 = Ice::LocatorPrx::uncheckedCast(communicator->stringToProxy("loc2:default -p 10000")); test(compObj->ice_locator(0) == compObj->ice_locator(0)); test(compObj->ice_locator(loc1) == compObj->ice_locator(loc1)); test(compObj->ice_locator(loc1) != compObj->ice_locator(0)); test(compObj->ice_locator(0) != compObj->ice_locator(loc2)); test(compObj->ice_locator(loc1) != compObj->ice_locator(loc2)); test(compObj->ice_locator(0) < compObj->ice_locator(loc1)); test(!(compObj->ice_locator(loc1) < compObj->ice_locator(0))); test(compObj->ice_locator(loc1) < compObj->ice_locator(loc2)); test(!(compObj->ice_locator(loc2) < compObj->ice_locator(loc1))); #endif #ifdef ICEE_HAS_ROUTER Ice::RouterPrx rtr1 = Ice::RouterPrx::uncheckedCast(communicator->stringToProxy("rtr1:default -p 10000")); Ice::RouterPrx rtr2 = Ice::RouterPrx::uncheckedCast(communicator->stringToProxy("rtr2:default -p 10000")); test(compObj->ice_router(0) == compObj->ice_router(0)); test(compObj->ice_router(rtr1) == compObj->ice_router(rtr1)); test(compObj->ice_router(rtr1) != compObj->ice_router(0)); test(compObj->ice_router(0) != compObj->ice_router(rtr2)); test(compObj->ice_router(rtr1) != compObj->ice_router(rtr2)); test(compObj->ice_router(0) < compObj->ice_router(rtr1)); test(!(compObj->ice_router(rtr1) < compObj->ice_router(0))); test(compObj->ice_router(rtr1) < compObj->ice_router(rtr2)); test(!(compObj->ice_router(rtr2) < compObj->ice_router(rtr1))); #endif Ice::Context ctx1; ctx1["ctx1"] = "v1"; Ice::Context ctx2; ctx2["ctx2"] = "v2"; test(compObj->ice_context(Ice::Context()) == compObj->ice_context(Ice::Context())); test(compObj->ice_context(ctx1) == compObj->ice_context(ctx1)); test(compObj->ice_context(ctx1) != compObj->ice_context(Ice::Context())); test(compObj->ice_context(Ice::Context()) != compObj->ice_context(ctx2)); test(compObj->ice_context(ctx1) != compObj->ice_context(ctx2)); test(compObj->ice_context(ctx1) < compObj->ice_context(ctx2)); test(!(compObj->ice_context(ctx2) < compObj->ice_context(ctx1))); Ice::ObjectPrx compObj1 = communicator->stringToProxy("foo:tcp -h 127.0.0.1 -p 10000"); Ice::ObjectPrx compObj2 = communicator->stringToProxy("foo:tcp -h 127.0.0.1 -p 10001"); test(compObj1 != compObj2); test(compObj1 < compObj2); test(!(compObj2 < compObj1)); compObj1 = communicator->stringToProxy("foo@MyAdapter1"); compObj2 = communicator->stringToProxy("foo@MyAdapter2"); test(compObj1 != compObj2); test(compObj1 < compObj2); test(!(compObj2 < compObj1)); #ifdef ICEE_HAS_LOCATOR compObj1 = communicator->stringToProxy("foo:tcp -h 127.0.0.1 -p 1000"); compObj2 = communicator->stringToProxy("foo@MyAdapter1"); test(compObj1 != compObj2); test(compObj1 < compObj2); test(!(compObj2 < compObj1)); #endif // // TODO: Ideally we should also test comparison of fixed proxies. // tprintf("ok\n"); tprintf("testing checked cast... "); Test::MyClassPrx cl = Test::MyClassPrx::checkedCast(base); test(cl); Test::MyDerivedClassPrx derived = Test::MyDerivedClassPrx::checkedCast(cl); test(derived); test(cl == base); test(derived == base); test(cl == derived); #ifdef ICEE_HAS_LOCATOR Ice::LocatorPrx loc = Ice::LocatorPrx::checkedCast(base); test(loc == 0); #endif // // Upcasting // Test::MyClassPrx cl2 = Test::MyClassPrx::checkedCast(derived); Ice::ObjectPrx obj = Ice::ObjectPrx::checkedCast(derived); test(cl2); test(obj); test(cl2 == obj); test(cl2 == derived); // // Now with alternate API // cl = checkedCast<Test::MyClassPrx>(base); test(cl); derived = checkedCast<Test::MyDerivedClassPrx>(cl); test(derived); test(cl == base); test(derived == base); test(cl == derived); #ifdef ICEE_HAS_LOCATOR loc = checkedCast<Ice::LocatorPrx>(base); test(loc == 0); #endif cl2 = checkedCast<Test::MyClassPrx>(derived); obj = checkedCast<Ice::ObjectPrx>(derived); test(cl2); test(obj); test(cl2 == obj); test(cl2 == derived); tprintf("ok\n"); tprintf("testing checked cast with context... "); Ice::Context c = cl->getContext(); test(c.size() == 0); c["one"] = "hello"; c["two"] = "world"; cl = Test::MyClassPrx::checkedCast(base, c); Ice::Context c2 = cl->getContext(); test(c == c2); // // Now with alternate API // cl = checkedCast<Test::MyClassPrx>(base); c = cl->getContext(); test(c.size() == 0); cl = checkedCast<Test::MyClassPrx>(base, c); c2 = cl->getContext(); test(c == c2); tprintf("ok\n"); #ifdef ICEE_HAS_OPAQUE_ENDPOINTS tprintf("testing opaque endpoints... "); try { // Invalid -x option Ice::ObjectPrx p = communicator->stringToProxy("id:opaque -t 99 -v abc -x abc"); test(false); } catch(const Ice::EndpointParseException&) { } try { // Missing -t and -v Ice::ObjectPrx p = communicator->stringToProxy("id:opaque"); test(false); } catch(const Ice::EndpointParseException&) { } try { // Repeated -t Ice::ObjectPrx p = communicator->stringToProxy("id:opaque -t 1 -t 1 -v abc"); test(false); } catch(const Ice::EndpointParseException&) { } try { // Repeated -v Ice::ObjectPrx p = communicator->stringToProxy("id:opaque -t 1 -v abc -v abc"); test(false); } catch(const Ice::EndpointParseException&) { } try { // Missing -t Ice::ObjectPrx p = communicator->stringToProxy("id:opaque -v abc"); test(false); } catch(const Ice::EndpointParseException&) { } try { // Missing -v Ice::ObjectPrx p = communicator->stringToProxy("id:opaque -t 1"); test(false); } catch(const Ice::EndpointParseException&) { } try { // Missing arg for -t Ice::ObjectPrx p = communicator->stringToProxy("id:opaque -t -v abc"); test(false); } catch(const Ice::EndpointParseException&) { } try { // Missing arg for -v Ice::ObjectPrx p = communicator->stringToProxy("id:opaque -t 1 -v"); test(false); } catch(const Ice::EndpointParseException&) { } try { // Not a number for -t Ice::ObjectPrx p = communicator->stringToProxy("id:opaque -t x -v abc"); test(false); } catch(const Ice::EndpointParseException&) { } try { // < 0 for -t Ice::ObjectPrx p = communicator->stringToProxy("id:opaque -t -1 -v abc"); test(false); } catch(const Ice::EndpointParseException&) { } try { // Invalid char for -v Ice::ObjectPrx p = communicator->stringToProxy("id:opaque -t 99 -v x?c"); test(false); } catch(const Ice::EndpointParseException&) { } // Legal TCP endpoint expressed as opaque endpoint Ice::ObjectPrx p1 = communicator->stringToProxy("test:opaque -t 1 -v CTEyNy4wLjAuMeouAAAQJwAAAA=="); string pstr = communicator->proxyToString(p1); test(pstr == "test -t:tcp -h 127.0.0.1 -p 12010 -t 10000"); // Working? p1->ice_ping(); // Two legal TCP endpoints expressed as opaque endpoints p1 = communicator->stringToProxy("test:opaque -t 1 -v CTEyNy4wLjAuMeouAAAQJwAAAA==:opaque -t 1 -v CTEyNy4wLjAuMusuAAAQJwAAAA=="); pstr = communicator->proxyToString(p1); test(pstr == "test -t:tcp -h 127.0.0.1 -p 12010 -t 10000:tcp -h 127.0.0.2 -p 12011 -t 10000"); // // Test that an SSL endpoint and a nonsense endpoint get written // back out as an opaque endpoint. // p1 = communicator->stringToProxy("test:opaque -t 2 -v CTEyNy4wLjAuMREnAAD/////AA==:opaque -t 99 -v abch"); pstr = communicator->proxyToString(p1); test(pstr == "test -t:opaque -t 2 -v CTEyNy4wLjAuMREnAAD/////AA==:opaque -t 99 -v abch"); // // Try to invoke on the SSL endpoint to verify that we get a // NoEndpointException. // try { p1->ice_ping(); test(false); } catch(const Ice::NoEndpointException&) { } // // Test that the proxy with an SSL endpoint and a nonsense // endpoint (which the server doesn't understand either) can be // sent over the wire and returned by the server without losing // the opaque endpoints. // Ice::ObjectPrx p2 = derived->echo(p1); pstr = communicator->proxyToString(p2); test(pstr == "test -t:opaque -t 2 -v CTEyNy4wLjAuMREnAAD/////AA==:opaque -t 99 -v abch"); tprintf("ok\n"); #endif return cl; }