int run(int, char**, const Ice::CommunicatorPtr& communicator, const Ice::InitializationData&) { Test::MyClassPrx allTests(const Ice::CommunicatorPtr&, bool); Test::MyClassPrx myClass = allTests(communicator, false); #ifndef ICE_OS_WINRT cout << "testing server shutdown... " << flush; myClass->shutdown(); try { myClass->opVoid(); test(false); } catch(const Ice::LocalException&) { cout << "ok" << endl; } #else // // When using SSL the run.py script starts a new server after shutdown // and the call to opVoid will success. // myClass->shutdown(); #endif return EXIT_SUCCESS; }
int run(int, char**, const Ice::CommunicatorPtr& communicator, const Ice::InitializationData&) { Test::MyClassPrx allTests(const Ice::CommunicatorPtr&); Test::MyClassPrx myClass = allTests(communicator); myClass->shutdown(); return EXIT_SUCCESS; }
void batchOneways(const Test::MyClassPrx& p) { const Test::ByteS bs1(10 * 1024); const Test::ByteS bs2(99 * 1024); const Test::ByteS bs3(100 * 1024); try { p->opByteSOneway(bs1); test(true); } catch(const Ice::MemoryLimitException&) { test(false); } try { p->opByteSOneway(bs2); test(true); } catch(const Ice::MemoryLimitException&) { test(false); } try { p->opByteSOneway(bs3); test(false); } catch(const Ice::MemoryLimitException&) { test(true); } Test::MyClassPrx batch = Test::MyClassPrx::uncheckedCast(p->ice_batchOneway()); int i; for(i = 0 ; i < 30 ; ++i) { try { batch->opByteSOneway(bs1); test(true); } catch(const Ice::MemoryLimitException&) { test(false); } } batch->ice_getConnection()->flushBatchRequests(); }
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 batchOnewaysAMI(const Test::MyClassPrx& p) { const Test::ByteS bs1(10 * 1024); const Test::ByteS bs2(99 * 1024); const Test::ByteS bs3(100 * 1024); CallbackPtr cb = new Callback(); p->begin_opByteSOneway(bs1, Test::newCallback_MyClass_opByteSOneway(new Callback_ByteSOneway1(cb), &Callback_ByteSOneway1::response, &Callback_ByteSOneway1::exception)); cb->check(); p->begin_opByteSOneway(bs2, Test::newCallback_MyClass_opByteSOneway(new Callback_ByteSOneway1(cb), &Callback_ByteSOneway1::response, &Callback_ByteSOneway1::exception)); cb->check(); Test::MyClassPrx batch = Test::MyClassPrx::uncheckedCast(p->ice_batchOneway()); batch->end_ice_flushBatchRequests(batch->begin_ice_flushBatchRequests()); int i; for(i = 0 ; i < 30 ; ++i) { p->begin_opByteSOneway(bs1, Test::newCallback_MyClass_opByteSOneway(new Callback_ByteSOneway3(), &Callback_ByteSOneway3::response, &Callback_ByteSOneway3::exception)); } if(batch->ice_getConnection()) { batch->ice_getConnection()->end_flushBatchRequests(batch->ice_getConnection()->begin_flushBatchRequests()); Test::MyClassPrx batch2 = Test::MyClassPrx::uncheckedCast(p->ice_batchOneway()); batch->begin_ice_ping(); batch2->begin_ice_ping(); batch->end_ice_flushBatchRequests(batch->begin_ice_flushBatchRequests()); batch->ice_getConnection()->close(false); batch->begin_ice_ping(); batch2->begin_ice_ping(); batch->ice_getConnection(); batch2->ice_getConnection(); batch->begin_ice_ping(); batch->ice_getConnection()->close(false); batch->begin_ice_ping(Ice::newCallback_Object_ice_ping(new Callback_ping(cb), &Callback_ping::response, &Callback_ping::exception)); cb->check(); batch2->begin_ice_ping(Ice::newCallback_Object_ice_ping(new Callback_ping(cb), &Callback_ping::response, &Callback_ping::exception)); cb->check(); batch->begin_ice_ping(); batch2->begin_ice_ping(); } Ice::Identity identity; identity.name = "invalid"; Ice::ObjectPrx batch3 = batch->ice_identity(identity); batch3->begin_ice_ping(); batch3->end_ice_flushBatchRequests(batch3->begin_ice_flushBatchRequests()); // Make sure that a bogus batch request doesn't cause troubles to other ones. batch3->begin_ice_ping(); batch->begin_ice_ping(); batch->end_ice_flushBatchRequests(batch->begin_ice_flushBatchRequests()); batch->begin_ice_ping(); }
void onewaysAMI(const Ice::CommunicatorPtr&, const Test::MyClassPrx& proxy) { Test::MyClassPrx p = Test::MyClassPrx::uncheckedCast(proxy->ice_oneway()); { CallbackPtr cb = new Callback; Ice::Callback_Object_ice_pingPtr callback = Ice::newCallback_Object_ice_ping(cb, &Callback::noException, &Callback::sent); p->begin_ice_ping(callback); cb->check(); } { try { p->begin_ice_isA(Test::MyClass::ice_staticId()); test(false); } catch(const IceUtil::IllegalArgumentException&) { } } { try { p->begin_ice_id(); test(false); } catch(const IceUtil::IllegalArgumentException&) { } } { try { p->begin_ice_ids(); test(false); } catch(const IceUtil::IllegalArgumentException&) { } } { CallbackPtr cb = new Callback; Test::Callback_MyClass_opVoidPtr callback = Test::newCallback_MyClass_opVoid(cb, &Callback::noException, &Callback::sent); p->begin_opVoid(callback); cb->check(); } { CallbackPtr cb = new Callback; Test::Callback_MyClass_opIdempotentPtr callback = Test::newCallback_MyClass_opIdempotent(cb, &Callback::noException, &Callback::sent); p->begin_opIdempotent(callback); cb->check(); } { CallbackPtr cb = new Callback; Test::Callback_MyClass_opNonmutatingPtr callback = Test::newCallback_MyClass_opNonmutating(cb, &Callback::noException, &Callback::sent); p->begin_opNonmutating(callback); cb->check(); } { try { p->begin_opByte(Ice::Byte(0xff), Ice::Byte(0x0f)); test(false); } catch(const IceUtil::IllegalArgumentException&) { } } #ifdef ICE_CPP11 { CallbackPtr cb = new Callback; p->begin_ice_ping(nullptr, [=](const Ice::Exception& ex){ cb->noException(ex); }, [=](bool sent){ cb->sent(sent); }); cb->check(); } { try { p->begin_ice_isA(Test::MyClass::ice_staticId(), [=](bool){ test(false); }); test(false); } catch(const IceUtil::IllegalArgumentException&) { } } { try { p->begin_ice_id([=](const string&){ test(false); }); test(false); } catch(const IceUtil::IllegalArgumentException&) { } } { try { p->begin_ice_ids([=](const Ice::StringSeq&){ test(false); }); test(false); } catch(const IceUtil::IllegalArgumentException&) { } } { CallbackPtr cb = new Callback; p->begin_opVoid(nullptr, [=](const Ice::Exception& ex){ cb->noException(ex); }, [=](bool sent){ cb->sent(sent); }); cb->check(); } { CallbackPtr cb = new Callback; p->begin_opIdempotent(nullptr, [=](const Ice::Exception& ex){ cb->noException(ex); }, [=](bool sent){ cb->sent(sent); }); cb->check(); } { CallbackPtr cb = new Callback; p->begin_opNonmutating(nullptr, [=](const Ice::Exception& ex){ cb->noException(ex); }, [=](bool sent){ cb->sent(sent); }); cb->check(); } { try { p->begin_opByte(Ice::Byte(0xff), Ice::Byte(0x0f), [=](const Ice::Byte&, const Ice::Byte&){ test(false); }); test(false); } catch(const IceUtil::IllegalArgumentException&) { } } #endif }
void oneways(const Ice::CommunicatorPtr& communicator, const Test::MyClassPrx& proxy) { Test::MyClassPrx p = Test::MyClassPrx::uncheckedCast(proxy->ice_oneway()); { p->ice_ping(); } { try { p->ice_isA("dummy"); test(false); } catch(const Ice::TwowayOnlyException&) { } } { try { p->ice_id(); test(false); } catch(const Ice::TwowayOnlyException&) { } } { try { p->ice_ids(); test(false); } catch(const Ice::TwowayOnlyException&) { } } { p->opVoid(); } { p->opIdempotent(); } { p->opNonmutating(); } { Ice::Byte b; try { p->opByte(Ice::Byte(0xff), Ice::Byte(0x0f), b); test(false); } catch(const Ice::TwowayOnlyException&) { } } }
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; }
Test::MyClassPrx allTests(const Ice::CommunicatorPtr& communicator) { string ref = "test:default -p 12010"; Ice::ObjectPrx base = communicator->stringToProxy(ref); test(base); Test::MyClassPrx cl = Test::MyClassPrx::checkedCast(base); test(cl); Test::MyClassPrx oneway = cl->ice_oneway(); void (Callback::*nullEx)(const Ice::Exception&) = 0; void (Callback::*nullExWC)(const Ice::Exception&, const CookiePtr&) = 0; cout << "testing ice_invoke... " << flush; { Ice::ByteSeq inParams, outParams; if(!oneway->ice_invoke("opOneway", Ice::Normal, inParams, outParams)) { test(false); } Ice::OutputStreamPtr out = Ice::createOutputStream(communicator); out->write(testString); out->finished(inParams); // ice_invoke if(cl->ice_invoke("opString", Ice::Normal, inParams, outParams)) { Ice::InputStreamPtr in = Ice::createInputStream(communicator, outParams); string s; in->read(s); test(s == testString); in->read(s); test(s == testString); } else { test(false); } // ice_invoke with array mapping pair<const ::Ice::Byte*, const ::Ice::Byte*> inPair(&inParams[0], &inParams[0] + inParams.size()); if(cl->ice_invoke("opString", Ice::Normal, inPair, outParams)) { Ice::InputStreamPtr in = Ice::createInputStream(communicator, outParams); string s; in->read(s); test(s == testString); in->read(s); test(s == testString); } else { test(false); } } { Ice::ByteSeq inParams, outParams; if(cl->ice_invoke("opException", Ice::Normal, inParams, outParams)) { test(false); } else { Ice::InputStreamPtr in = Ice::createInputStream(communicator, outParams); try { in->throwException(); } catch(const Test::MyException&) { } catch(...) { test(false); } } } cout << "ok" << endl; cout << "testing asynchronous ice_invoke... " << flush; { CookiePtr cookie = new Cookie(); Ice::ByteSeq inParams, outParams; Ice::AsyncResultPtr result = oneway->begin_ice_invoke("opOneway", Ice::Normal, inParams); if(!oneway->end_ice_invoke(outParams, result)) { test(false); } Ice::OutputStreamPtr out = Ice::createOutputStream(communicator); out->write(testString); out->finished(inParams); // begin_ice_invoke with no callback result = cl->begin_ice_invoke("opString", Ice::Normal, inParams); if(cl->end_ice_invoke(outParams, result)) { Ice::InputStreamPtr in = Ice::createInputStream(communicator, outParams); string s; in->read(s); test(s == testString); in->read(s); test(s == testString); } else { test(false); }; // begin_ice_invoke with no callback and array mapping pair<const ::Ice::Byte*, const ::Ice::Byte*> inPair(&inParams[0], &inParams[0] + inParams.size()); result = cl->begin_ice_invoke("opString", Ice::Normal, inPair); if(cl->end_ice_invoke(outParams, result)) { Ice::InputStreamPtr in = Ice::createInputStream(communicator, outParams); string s; in->read(s); test(s == testString); in->read(s); test(s == testString); } else { test(false); }; // begin_ice_invoke with Callback CallbackPtr cb = new Callback(communicator, false); cl->begin_ice_invoke("opString", Ice::Normal, inParams, Ice::newCallback(cb, &Callback::opString)); cb->check(); // begin_ice_invoke with Callback and Cookie cb = new Callback(communicator, true); cl->begin_ice_invoke("opString", Ice::Normal, inParams, Ice::newCallback(cb, &Callback::opString), cookie); cb->check(); // begin_ice_invoke with Callback_Object_ice_invoke cb = new Callback(communicator, false); Ice::Callback_Object_ice_invokePtr d = Ice::newCallback_Object_ice_invoke(cb, &Callback::opStringNC, nullEx); cl->begin_ice_invoke("opString", Ice::Normal, inParams, d); cb->check(); // begin_ice_invoke with Callback_Object_ice_invoke with Cookie cb = new Callback(communicator, false); d = Ice::newCallback_Object_ice_invoke(cb, &Callback::opStringWC, nullExWC); cl->begin_ice_invoke("opString", Ice::Normal, inParams, d, cookie); cb->check(); // begin_ice_invoke with Callback_Object_ice_invoke and array mapping cb = new Callback(communicator, false); d = Ice::newCallback_Object_ice_invoke(cb, &Callback::opStringNC, nullEx); cl->begin_ice_invoke("opString", Ice::Normal, inPair, d); cb->check(); // begin_ice_invoke with Callback_Object_ice_invoke and array mapping with Cookie cb = new Callback(communicator, false); d = Ice::newCallback_Object_ice_invoke(cb, &Callback::opStringWC, nullExWC); cl->begin_ice_invoke("opString", Ice::Normal, inPair, d, cookie); cb->check(); } { CookiePtr cookie = new Cookie(); Ice::ByteSeq inParams, outParams; // begin_ice_invoke with no callback Ice::AsyncResultPtr result = cl->begin_ice_invoke("opException", Ice::Normal, inParams); if(cl->end_ice_invoke(outParams, result)) { test(false); } else { Ice::InputStreamPtr in = Ice::createInputStream(communicator, outParams); try { in->throwException(); } catch(const Test::MyException&) { } catch(...) { test(false); } } // begin_ice_invoke with Callback CallbackPtr cb = new Callback(communicator, false); cl->begin_ice_invoke("opException", Ice::Normal, inParams, Ice::newCallback(cb, &Callback::opException)); cb->check(); // begin_ice_invoke with Callback and Cookie cb = new Callback(communicator, true); cl->begin_ice_invoke("opException", Ice::Normal, inParams, Ice::newCallback(cb, &Callback::opException), cookie); cb->check(); // begin_ice_invoke with Callback_Object_ice_invoke cb = new Callback(communicator, false); Ice::Callback_Object_ice_invokePtr d = Ice::newCallback_Object_ice_invoke(cb, &Callback::opExceptionNC, nullEx); cl->begin_ice_invoke("opException", Ice::Normal, inParams, d); cb->check(); // begin_ice_invoke with Callback_Object_ice_invoke with Cookie cb = new Callback(communicator, false); d = Ice::newCallback_Object_ice_invoke(cb, &Callback::opExceptionWC, nullExWC); cl->begin_ice_invoke("opException", Ice::Normal, inParams, d, cookie); cb->check(); } cout << "ok" << endl; return cl; }