def allTests(communicator): sys.stdout.write("testing proxy endpoint information... ") sys.stdout.flush() 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") endps = p1.ice_getEndpoints() endpoint = endps[0].getInfo() tcpEndpoint = getTCPEndpointInfo(endpoint) test(isinstance(tcpEndpoint, Ice.TCPEndpointInfo)) test(tcpEndpoint.host == "tcphost") test(tcpEndpoint.port == 10000) test(tcpEndpoint.sourceAddress == "10.10.10.10") test(tcpEndpoint.timeout == 1200) test(tcpEndpoint.compress) test(not tcpEndpoint.datagram()) test((tcpEndpoint.type() == Ice.TCPEndpointType and not tcpEndpoint.secure()) or (tcpEndpoint.type() == Ice.SSLEndpointType and tcpEndpoint.secure()) or # SSL (tcpEndpoint.type() == Ice.WSEndpointType and not tcpEndpoint.secure()) or # WS (tcpEndpoint.type() == Ice.WSSEndpointType and tcpEndpoint.secure())) # WS test((tcpEndpoint.type() == Ice.TCPEndpointType and isinstance(endpoint, Ice.TCPEndpointInfo)) or (tcpEndpoint.type() == Ice.SSLEndpointType and isinstance(endpoint, Ice.SSLEndpointInfo)) or (tcpEndpoint.type() == Ice.WSEndpointType and isinstance(endpoint, Ice.WSEndpointInfo)) or (tcpEndpoint.type() == Ice.WSSEndpointType and isinstance(endpoint, Ice.WSEndpointInfo))) udpEndpoint = endps[1].getInfo() test(isinstance(udpEndpoint, Ice.UDPEndpointInfo)) test(udpEndpoint.host == "udphost") test(udpEndpoint.port == 10001) test(udpEndpoint.sourceAddress == "10.10.10.10") test(udpEndpoint.mcastInterface == "eth0") test(udpEndpoint.mcastTtl == 5) test(udpEndpoint.timeout == -1) test(not udpEndpoint.compress) test(not udpEndpoint.secure()) test(udpEndpoint.datagram()) test(udpEndpoint.type() == Ice.UDPEndpointType) opaqueEndpoint = endps[2].getInfo() test(isinstance(opaqueEndpoint, Ice.OpaqueEndpointInfo)) test(opaqueEndpoint.rawEncoding == Ice.EncodingVersion(1, 8)) print("ok") defaultHost = communicator.getProperties().getProperty("Ice.Default.Host") sys.stdout.write("test object adapter endpoint information... ") sys.stdout.flush() communicator.getProperties().setProperty("TestAdapter.Endpoints", "default -t 15000:udp") adapter = communicator.createObjectAdapter("TestAdapter") endpoints = adapter.getEndpoints() test(len(endpoints) == 2) publishedEndpoints = adapter.getPublishedEndpoints() test(endpoints == publishedEndpoints) tcpEndpoint = getTCPEndpointInfo(endpoints[0].getInfo()) test(tcpEndpoint.type() == Ice.TCPEndpointType or tcpEndpoint.type() == 2 or tcpEndpoint.type() == 4 or tcpEndpoint.type() == 5) test(tcpEndpoint.host == defaultHost) test(tcpEndpoint.port > 0) test(tcpEndpoint.timeout == 15000) udpEndpoint = endpoints[1].getInfo() test(udpEndpoint.host == defaultHost) test(udpEndpoint.datagram()) test(udpEndpoint.port > 0) endpoints = (endpoints[0], ) test(len(endpoints) == 1) adapter.setPublishedEndpoints(endpoints) publishedEndpoints = adapter.getPublishedEndpoints() test(endpoints == publishedEndpoints) adapter.destroy() communicator.getProperties().setProperty("TestAdapter.Endpoints", "default -h * -p 12020") communicator.getProperties().setProperty("TestAdapter.PublishedEndpoints", "default -h 127.0.0.1 -p 12020") adapter = communicator.createObjectAdapter("TestAdapter") endpoints = adapter.getEndpoints() test(len(endpoints) >= 1) publishedEndpoints = adapter.getPublishedEndpoints() test(len(publishedEndpoints) == 1) for i in range(0, len(endpoints)): tcpEndpoint = getTCPEndpointInfo(endpoints[i].getInfo()) test(tcpEndpoint.port == 12020) tcpEndpoint = getTCPEndpointInfo(publishedEndpoints[0].getInfo()) test(tcpEndpoint.host == "127.0.0.1") test(tcpEndpoint.port == 12020) adapter.destroy() print("ok") base = communicator.stringToProxy("test:default -p 12010:udp -p 12010") testIntf = Test.TestIntfPrx.checkedCast(base) sys.stdout.write("test connection endpoint information... ") sys.stdout.flush() tcpinfo = getTCPEndpointInfo(base.ice_getConnection().getEndpoint().getInfo()) test(tcpinfo.port == 12010) test(not tcpinfo.compress) test(tcpinfo.host == defaultHost) ctx = testIntf.getEndpointInfoAsContext() test(ctx["host"] == tcpinfo.host) test(ctx["compress"] == "false") port = int(ctx["port"]) test(port > 0) udp = base.ice_datagram().ice_getConnection().getEndpoint().getInfo() test(udp.port == 12010) test(udp.host == defaultHost) print("ok") sys.stdout.write("testing connection information... ") sys.stdout.flush() connection = base.ice_getConnection() connection.setBufferSize(1024, 2048) info = connection.getInfo() tcpinfo = getTCPConnectionInfo(info) test(not info.incoming) test(len(info.adapterName) == 0) test(tcpinfo.remotePort == 12010) if defaultHost == '127.0.0.1': test(tcpinfo.remoteAddress == defaultHost) test(tcpinfo.localAddress == defaultHost) test(tcpinfo.rcvSize >= 1024) test(tcpinfo.sndSize >= 2048) ctx = testIntf.getConnectionInfoAsContext() test(ctx["incoming"] == "true") test(ctx["adapterName"] == "TestAdapter") test(ctx["remoteAddress"] == tcpinfo.localAddress) test(ctx["localAddress"] == tcpinfo.remoteAddress) test(ctx["remotePort"] == str(tcpinfo.localPort)) test(ctx["localPort"] == str(tcpinfo.remotePort)) if(base.ice_getConnection().type() == "ws" or base.ice_getConnection().type() == "wss"): test(isinstance(info, Ice.WSConnectionInfo)) test(info.headers["Upgrade"] == "websocket") test(info.headers["Connection"] == "Upgrade") test(info.headers["Sec-WebSocket-Protocol"] == "ice.zeroc.com") test("Sec-WebSocket-Accept" in info.headers); 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("ws.Sec-WebSocket-Key" in ctx) print("ok") testIntf.shutdown() communicator.shutdown() communicator.waitForShutdown()
def allTests(communicator, collocated): sys.stdout.write("testing stringToProxy... ") sys.stdout.flush() # # Test nil proxies. # p = communicator.stringToProxy('') test(p == None) p = communicator.propertyToProxy('bogus') test(p == None) ref = "test:default -p 12010" base = communicator.stringToProxy(ref) test(base) b1 = communicator.stringToProxy("test") test(b1.ice_getIdentity().name == "test" and len(b1.ice_getIdentity().category) == 0 and \ len(b1.ice_getAdapterId()) == 0 and len(b1.ice_getFacet()) == 0) b1 = communicator.stringToProxy("test ") test(b1.ice_getIdentity().name == "test" and len(b1.ice_getIdentity().category) == 0 and \ len(b1.ice_getFacet()) == 0) b1 = communicator.stringToProxy(" test ") test(b1.ice_getIdentity().name == "test" and len(b1.ice_getIdentity().category) == 0 and \ len(b1.ice_getFacet()) == 0) b1 = communicator.stringToProxy(" test") test(b1.ice_getIdentity().name == "test" and len(b1.ice_getIdentity().category) == 0 and \ len(b1.ice_getFacet()) == 0) b1 = communicator.stringToProxy("'test -f facet'") test(b1.ice_getIdentity().name == "test -f facet" and len(b1.ice_getIdentity().category) == 0 and \ len(b1.ice_getFacet()) == 0) try: b1 = communicator.stringToProxy("\"test -f facet'") test(False) except Ice.ProxyParseException: pass b1 = communicator.stringToProxy("\"test -f facet\"") test(b1.ice_getIdentity().name == "test -f facet" and len(b1.ice_getIdentity().category) == 0 and \ len(b1.ice_getFacet()) == 0) b1 = communicator.stringToProxy("\"test -f facet@test\"") test(b1.ice_getIdentity().name == "test -f facet@test" and len(b1.ice_getIdentity().category) == 0 and \ len(b1.ice_getFacet()) == 0) b1 = communicator.stringToProxy("\"test -f facet@test @test\"") test(b1.ice_getIdentity().name == "test -f facet@test @test" and len(b1.ice_getIdentity().category) == 0 and \ len(b1.ice_getFacet()) == 0) try: b1 = communicator.stringToProxy("test test") test(False) except Ice.ProxyParseException: pass b1 = communicator.stringToProxy("test\\040test") test(b1.ice_getIdentity().name == "test test" and len(b1.ice_getIdentity().category) == 0) try: b1 = communicator.stringToProxy("test\\777") test(False) except Ice.IdentityParseException: pass 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" and len(b1.ice_getIdentity().category) == 0) b1 = communicator.stringToProxy("category/test") test(b1.ice_getIdentity().name == "test" and b1.ice_getIdentity().category == "category" and \ len(b1.ice_getAdapterId()) == 0) b1 = communicator.stringToProxy("test@adapter") test(b1.ice_getIdentity().name == "test" and len(b1.ice_getIdentity().category) == 0 and \ b1.ice_getAdapterId() == "adapter") try: b1 = communicator.stringToProxy("id@adapter test") test(False) except Ice.ProxyParseException: pass b1 = communicator.stringToProxy("category/test@adapter") test(b1.ice_getIdentity().name == "test" and b1.ice_getIdentity().category == "category" and \ b1.ice_getAdapterId() == "adapter") b1 = communicator.stringToProxy("category/test@adapter:tcp") test(b1.ice_getIdentity().name == "test" and b1.ice_getIdentity().category == "category" and \ b1.ice_getAdapterId() == "adapter:tcp") b1 = communicator.stringToProxy("'category 1/test'@adapter") test(b1.ice_getIdentity().name == "test" and b1.ice_getIdentity().category == "category 1" and \ b1.ice_getAdapterId() == "adapter") b1 = communicator.stringToProxy("'category/test 1'@adapter") test(b1.ice_getIdentity().name == "test 1" and b1.ice_getIdentity().category == "category" and \ b1.ice_getAdapterId() == "adapter") b1 = communicator.stringToProxy("'category/test'@'adapter 1'") test(b1.ice_getIdentity().name == "test" and b1.ice_getIdentity().category == "category" and \ b1.ice_getAdapterId() == "adapter 1") b1 = communicator.stringToProxy("\"category \\/test@foo/test\"@adapter") test(b1.ice_getIdentity().name == "test" and b1.ice_getIdentity().category == "category /test@foo" and \ b1.ice_getAdapterId() == "adapter") b1 = communicator.stringToProxy( "\"category \\/test@foo/test\"@\"adapter:tcp\"") test(b1.ice_getIdentity().name == "test" and b1.ice_getIdentity().category == "category /test@foo" and \ b1.ice_getAdapterId() == "adapter:tcp") b1 = communicator.stringToProxy("id -f facet") test(b1.ice_getIdentity().name == "id" and len(b1.ice_getIdentity().category) == 0 and \ b1.ice_getFacet() == "facet") b1 = communicator.stringToProxy("id -f 'facet x'") test(b1.ice_getIdentity().name == "id" and len(b1.ice_getIdentity().category) == 0 and \ b1.ice_getFacet() == "facet x") b1 = communicator.stringToProxy("id -f \"facet x\"") test(b1.ice_getIdentity().name == "id" and len(b1.ice_getIdentity().category) == 0 and \ b1.ice_getFacet() == "facet x") try: b1 = communicator.stringToProxy("id -f \"facet x") test(False) except Ice.ProxyParseException: pass try: b1 = communicator.stringToProxy("id -f \'facet x") test(False) except Ice.ProxyParseException: pass b1 = communicator.stringToProxy("test -f facet:tcp") test(b1.ice_getIdentity().name == "test" and len(b1.ice_getIdentity().category) == 0 and \ b1.ice_getFacet() == "facet" and len(b1.ice_getAdapterId()) == 0) b1 = communicator.stringToProxy("test -f \"facet:tcp\"") test(b1.ice_getIdentity().name == "test" and len(b1.ice_getIdentity().category) == 0 and \ b1.ice_getFacet() == "facet:tcp" and len(b1.ice_getAdapterId()) == 0) b1 = communicator.stringToProxy("test -f facet@test") test(b1.ice_getIdentity().name == "test" and len(b1.ice_getIdentity().category) == 0 and \ b1.ice_getFacet() == "facet" and b1.ice_getAdapterId() == "test") b1 = communicator.stringToProxy("test -f 'facet@test'") test(b1.ice_getIdentity().name == "test" and len(b1.ice_getIdentity().category) == 0 and \ b1.ice_getFacet() == "facet@test" and len(b1.ice_getAdapterId()) == 0) b1 = communicator.stringToProxy("test -f 'facet@test'@test") test(b1.ice_getIdentity().name == "test" and len(b1.ice_getIdentity().category) == 0 and \ b1.ice_getFacet() == "facet@test" and b1.ice_getAdapterId() == "test") try: b1 = communicator.stringToProxy("test -f facet@test @test") test(False) except Ice.ProxyParseException: pass 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(not b1.ice_isSecure()) b1 = communicator.stringToProxy("test -s") test(b1.ice_isSecure()) try: b1 = communicator.stringToProxy("test:tcp@adapterId") test(False) except Ice.EndpointParseException: pass # This is an unknown endpoint warning, not a parse exception. # #try: # b1 = communicator.stringToProxy("test -f the:facet:tcp") # test(False) #except Ice.EndpointParseException: # pass try: b1 = communicator.stringToProxy("test::tcp") test(False) except Ice.EndpointParseException: pass print("ok") sys.stdout.write("testing propertyToProxy... ") sys.stdout.flush() prop = communicator.getProperties() propertyPrefix = "Foo.Proxy" prop.setProperty(propertyPrefix, "test:default -p 12010") b1 = communicator.propertyToProxy(propertyPrefix) test(b1.ice_getIdentity().name == "test" and len(b1.ice_getIdentity().category) == 0 and \ len(b1.ice_getAdapterId()) == 0 and len(b1.ice_getFacet()) == 0) property = propertyPrefix + ".Locator" test(not b1.ice_getLocator()) prop.setProperty(property, "locator:default -p 10000") b1 = communicator.propertyToProxy(propertyPrefix) test(b1.ice_getLocator() and 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() and 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(not b1.ice_getRouter()) prop.setProperty(property, "router:default -p 10000") b1 = communicator.propertyToProxy(propertyPrefix) test(b1.ice_getRouter() and b1.ice_getRouter().ice_getIdentity().name == "router") prop.setProperty(property, "") property = propertyPrefix + ".PreferSecure" test(not 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(not 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.EndpointSelectionType.Random) prop.setProperty(property, "Random") b1 = communicator.propertyToProxy(propertyPrefix) test(b1.ice_getEndpointSelection() == Ice.EndpointSelectionType.Random) prop.setProperty(property, "Ordered") b1 = communicator.propertyToProxy(propertyPrefix) test(b1.ice_getEndpointSelection() == Ice.EndpointSelectionType.Ordered) prop.setProperty(property, "") property = propertyPrefix + ".CollocationOptimized" test(b1.ice_isCollocationOptimized()) prop.setProperty(property, "0") b1 = communicator.propertyToProxy(propertyPrefix) test(not b1.ice_isCollocationOptimized()) prop.setProperty(property, "") print("ok") sys.stdout.write("testing proxyToProperty... ") sys.stdout.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.EndpointSelectionType.Ordered) b1 = b1.ice_locatorCacheTimeout(100) b1 = b1.ice_invocationTimeout(1234) b1 = b1.ice_encodingVersion(Ice.EncodingVersion(1, 0)) router = communicator.stringToProxy("router") router = router.ice_collocationOptimized(False) router = router.ice_connectionCached(True) router = router.ice_preferSecure(True) router = router.ice_endpointSelection(Ice.EndpointSelectionType.Random) router = router.ice_locatorCacheTimeout(200) router = router.ice_invocationTimeout(1500) locator = communicator.stringToProxy("locator") locator = locator.ice_collocationOptimized(True) locator = locator.ice_connectionCached(False) locator = locator.ice_preferSecure(True) locator = locator.ice_endpointSelection(Ice.EndpointSelectionType.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)) proxyProps = communicator.proxyToProperty(b1, "Test") test(len(proxyProps) == 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())) 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") print("ok") sys.stdout.write("testing ice_getCommunicator... ") sys.stdout.flush() test(base.ice_getCommunicator() == communicator) print("ok") sys.stdout.write("testing proxy methods... ") sys.stdout.flush() test(communicator.identityToString(base.ice_identity(communicator.stringToIdentity("other")).ice_getIdentity()) \ == "other") # # Verify that ToStringMode is passed correctly # ident = Ice.Identity("test", "\x7F\xE2\x82\xAC") idStr = Ice.identityToString(ident, Ice.ToStringMode.Unicode) test(idStr == "\\u007f\xE2\x82\xAC/test") ident2 = Ice.stringToIdentity(idStr) test(ident == ident2) test(Ice.identityToString(ident) == idStr) idStr = Ice.identityToString(ident, Ice.ToStringMode.ASCII) test(idStr == "\\u007f\\u20ac/test") ident2 = Ice.stringToIdentity(idStr) test(ident == ident2) idStr = Ice.identityToString(ident, Ice.ToStringMode.Compat) test(idStr == "\\177\\342\\202\\254/test") ident2 = Ice.stringToIdentity(idStr) test(ident == ident2) ident2 = Ice.stringToIdentity(communicator.identityToString(ident)) test(ident == ident2) 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(not base.ice_secure(False).ice_isSecure()) test(base.ice_collocationOptimized(True).ice_isCollocationOptimized()) test(not base.ice_collocationOptimized(False).ice_isCollocationOptimized()) test(base.ice_preferSecure(True).ice_isPreferSecure()) test(not 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) except RuntimeError: pass try: base.ice_timeout(-1) except RuntimeError: test(False) try: base.ice_timeout(-2) test(False) except RuntimeError: pass try: base.ice_invocationTimeout(0) test(False) except RuntimeError: pass try: base.ice_invocationTimeout(-1) except RuntimeError: test(False) try: base.ice_invocationTimeout(-2) test(False) except RuntimeError: pass try: base.ice_locatorCacheTimeout(0) except RuntimeError: test(False) try: base.ice_locatorCacheTimeout(-1) except RuntimeError: test(False) try: base.ice_locatorCacheTimeout(-2) test(False) except RuntimeError: pass print("ok") sys.stdout.write("testing proxy comparison... ") sys.stdout.flush() test( communicator.stringToProxy("foo") == communicator.stringToProxy("foo")) test( communicator.stringToProxy("foo") != communicator.stringToProxy("foo2") ) test( communicator.stringToProxy("foo") < communicator.stringToProxy("foo2")) test(not (communicator.stringToProxy("foo2") < communicator.stringToProxy( "foo"))) 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(not (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(not (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(not (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(not (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(not (compObj.ice_connectionCached(True) < compObj.ice_connectionCached(False))) test(compObj.ice_endpointSelection(Ice.EndpointSelectionType.Random) == \ compObj.ice_endpointSelection(Ice.EndpointSelectionType.Random)) test(compObj.ice_endpointSelection(Ice.EndpointSelectionType.Random) != \ compObj.ice_endpointSelection(Ice.EndpointSelectionType.Ordered)) test(compObj.ice_endpointSelection(Ice.EndpointSelectionType.Random) < \ compObj.ice_endpointSelection(Ice.EndpointSelectionType.Ordered)) test(not (compObj.ice_endpointSelection(Ice.EndpointSelectionType.Ordered) < \ compObj.ice_endpointSelection(Ice.EndpointSelectionType.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(not ( 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(not (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(not (compObj.ice_timeout(20) < compObj.ice_timeout(10))) loc1 = Ice.LocatorPrx.uncheckedCast( communicator.stringToProxy("loc1:default -p 10000")) loc2 = Ice.LocatorPrx.uncheckedCast( communicator.stringToProxy("loc2:default -p 10000")) test(compObj.ice_locator(None) == compObj.ice_locator(None)) test(compObj.ice_locator(loc1) == compObj.ice_locator(loc1)) test(compObj.ice_locator(loc1) != compObj.ice_locator(None)) test(compObj.ice_locator(None) != compObj.ice_locator(loc2)) test(compObj.ice_locator(loc1) != compObj.ice_locator(loc2)) test(compObj.ice_locator(None) < compObj.ice_locator(loc1)) test(not (compObj.ice_locator(loc1) < compObj.ice_locator(None))) test(compObj.ice_locator(loc1) < compObj.ice_locator(loc2)) test(not (compObj.ice_locator(loc2) < compObj.ice_locator(loc1))) rtr1 = Ice.RouterPrx.uncheckedCast( communicator.stringToProxy("rtr1:default -p 10000")) rtr2 = Ice.RouterPrx.uncheckedCast( communicator.stringToProxy("rtr2:default -p 10000")) test(compObj.ice_router(None) == compObj.ice_router(None)) test(compObj.ice_router(rtr1) == compObj.ice_router(rtr1)) test(compObj.ice_router(rtr1) != compObj.ice_router(None)) test(compObj.ice_router(None) != compObj.ice_router(rtr2)) test(compObj.ice_router(rtr1) != compObj.ice_router(rtr2)) test(compObj.ice_router(None) < compObj.ice_router(rtr1)) test(not (compObj.ice_router(rtr1) < compObj.ice_router(None))) test(compObj.ice_router(rtr1) < compObj.ice_router(rtr2)) test(not (compObj.ice_router(rtr2) < compObj.ice_router(rtr1))) ctx1 = {} ctx1["ctx1"] = "v1" ctx2 = {} ctx2["ctx2"] = "v2" test(compObj.ice_context({}) == compObj.ice_context({})) test(compObj.ice_context(ctx1) == compObj.ice_context(ctx1)) test(compObj.ice_context(ctx1) != compObj.ice_context({})) test(compObj.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(not (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(not ( compObj.ice_preferSecure(True) < compObj.ice_preferSecure(False))) compObj1 = communicator.stringToProxy("foo:tcp -h 127.0.0.1 -p 10000") compObj2 = communicator.stringToProxy("foo:tcp -h 127.0.0.1 -p 10001") test(compObj1 != compObj2) test(compObj1 < compObj2) test(not (compObj2 < compObj1)) compObj1 = communicator.stringToProxy("foo@MyAdapter1") compObj2 = communicator.stringToProxy("foo@MyAdapter2") test(compObj1 != compObj2) test(compObj1 < compObj2) test(not (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(not (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(not (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(not (compObj2 < compObj1)) endpts1 = communicator.stringToProxy( "foo:tcp -h 127.0.0.1 -p 10000").ice_getEndpoints() endpts2 = communicator.stringToProxy( "foo:tcp -h 127.0.0.1 -p 10001").ice_getEndpoints() test(endpts1 != endpts2) test(endpts1 < endpts2) test(not (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(not (compObj.ice_encodingVersion(Ice.Encoding_1_1) < compObj.ice_encodingVersion(Ice.Encoding_1_0))) # # TODO: Ideally we should also test comparison of fixed proxies. # print("ok") sys.stdout.write("testing checked cast... ") sys.stdout.flush() cl = Test.MyClassPrx.checkedCast(base) test(cl) derived = Test.MyDerivedClassPrx.checkedCast(cl) test(derived) test(cl == base) test(derived == base) test(cl == derived) loc = Ice.LocatorPrx.checkedCast(base) test(loc == None) # # Upcasting # cl2 = Test.MyClassPrx.checkedCast(derived) obj = Ice.ObjectPrx.checkedCast(derived) test(cl2) test(obj) test(cl2 == obj) test(cl2 == derived) print("ok") sys.stdout.write("testing checked cast with context... ") sys.stdout.flush() tccp = Test.MyClassPrx.checkedCast(base) c = tccp.getContext() test(c == None or len(c) == 0) c = {} c["one"] = "hello" c["two"] = "world" tccp = Test.MyClassPrx.checkedCast(base, c) c2 = tccp.getContext() test(c == c2) print("ok") sys.stdout.write("testing encoding versioning... ") sys.stdout.flush() ref20 = "test -e 2.0:default -p 12010" cl20 = Test.MyClassPrx.uncheckedCast(communicator.stringToProxy(ref20)) try: cl20.ice_ping() test(false) except Ice.UnsupportedEncodingException: # Server 2.0 endpoint doesn't support 1.1 version. pass ref10 = "test -e 1.0:default -p 12010" 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 ref13 = "test -e 1.3:default -p 12010" cl13 = Test.MyClassPrx.uncheckedCast(communicator.stringToProxy(ref13)) cl13.ice_ping() print("ok") sys.stdout.write("testing opaque endpoints... ") sys.stdout.flush() try: # Invalid -x option p = communicator.stringToProxy("id:opaque -t 99 -v abc -x abc") test(False) except Ice.EndpointParseException: pass try: # Missing -t and -v p = communicator.stringToProxy("id:opaque") test(False) except Ice.EndpointParseException: pass try: # Repeated -t p = communicator.stringToProxy("id:opaque -t 1 -t 1 -v abc") test(False) except Ice.EndpointParseException: pass try: # Repeated -v p = communicator.stringToProxy("id:opaque -t 1 -v abc -v abc") test(False) except Ice.EndpointParseException: pass try: # Missing -t p = communicator.stringToProxy("id:opaque -v abc") test(False) except Ice.EndpointParseException: pass try: # Missing -v p = communicator.stringToProxy("id:opaque -t 1") test(False) except Ice.EndpointParseException: pass try: # Missing arg for -t p = communicator.stringToProxy("id:opaque -t -v abc") test(False) except Ice.EndpointParseException: pass try: # Missing arg for -v p = communicator.stringToProxy("id:opaque -t 1 -v") test(False) except Ice.EndpointParseException: pass try: # Not a number for -t p = communicator.stringToProxy("id:opaque -t x -v abc") test(False) except Ice.EndpointParseException: pass try: # < 0 for -t p = communicator.stringToProxy("id:opaque -t -1 -v abc") test(False) except Ice.EndpointParseException: pass try: # Invalid char for -v p = communicator.stringToProxy("id:opaque -t 99 -v x?c") test(False) except Ice.EndpointParseException: pass # Legal TCP endpoint expressed as opaque endpoint p1 = communicator.stringToProxy( "test -e 1.1:opaque -t 1 -e 1.0 -v CTEyNy4wLjAuMeouAAAQJwAAAA==") 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. 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? ssl = communicator.getProperties().getProperty( "Ice.Default.Protocol") == "ssl" 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 -t 1 -e 1.0 -v CTEyNy4wLjAuMeouAAAQJwAAAA==:opaque -t 1 -e 1.0 -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 -t 2 -e 1.0 -v CTEyNy4wLjAuMREnAAD/////AA==:opaque -t 99 -e 1.0 -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" ) elif 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 SSL endpoint to verify that we get a # NoEndpointException (or ConnectionRefusedException when # running with SSL). # try: p1.ice_encodingVersion(Ice.Encoding_1_0).ice_ping() test(False) except Ice.NoEndpointException: test(not ssl) except Ice.ConnectFailedException: test(not tcp) # # 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. # 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" ) elif 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" ) print("ok") return cl
def allTests(communicator, collocated): sys.stdout.write("testing proxy endpoint information... ") sys.stdout.flush() p1 = communicator.stringToProxy("test -t:default -h tcphost -p 10000 -t 1200 -z:" + \ "udp -h udphost -p 10001 --interface eth0 --ttl 5:" + \ "opaque -e 1.8 -t 100 -v ABCD") endps = p1.ice_getEndpoints() ipEndpoint = endps[0].getInfo() test(isinstance(ipEndpoint, Ice.IPEndpointInfo)) test(ipEndpoint.host == "tcphost") test(ipEndpoint.port == 10000) test(ipEndpoint.timeout == 1200) test(ipEndpoint.compress) test(not ipEndpoint.datagram()) test((ipEndpoint.type() == Ice.TCPEndpointType and not ipEndpoint.secure()) or (ipEndpoint.type() == 2 and ipEndpoint.secure())) # SSL test((ipEndpoint.type() == Ice.TCPEndpointType and isinstance(ipEndpoint, Ice.TCPEndpointInfo)) or (ipEndpoint.type() == 2)) # SSL udpEndpoint = endps[1].getInfo() test(isinstance(udpEndpoint, Ice.UDPEndpointInfo)) test(udpEndpoint.host == "udphost") test(udpEndpoint.port == 10001) test(udpEndpoint.mcastInterface == "eth0") test(udpEndpoint.mcastTtl == 5) test(udpEndpoint.timeout == -1) test(not udpEndpoint.compress) test(not udpEndpoint.secure()) test(udpEndpoint.datagram()) test(udpEndpoint.type() == Ice.UDPEndpointType) opaqueEndpoint = endps[2].getInfo() test(isinstance(opaqueEndpoint, Ice.OpaqueEndpointInfo)) test(opaqueEndpoint.rawEncoding == Ice.EncodingVersion(1, 8)) print("ok") defaultHost = communicator.getProperties().getProperty("Ice.Default.Host") sys.stdout.write("test object adapter endpoint information... ") sys.stdout.flush() communicator.getProperties().setProperty("TestAdapter.Endpoints", "default -t 15000:udp") adapter = communicator.createObjectAdapter("TestAdapter") endpoints = adapter.getEndpoints() test(len(endpoints) == 2) publishedEndpoints = adapter.getPublishedEndpoints() test(endpoints == publishedEndpoints) ipEndpoint = endpoints[0].getInfo() test(ipEndpoint.type() == Ice.TCPEndpointType or ipEndpoint.type() == 2) test(ipEndpoint.host == defaultHost) test(ipEndpoint.port > 0) test(ipEndpoint.timeout == 15000) udpEndpoint = endpoints[1].getInfo() test(udpEndpoint.host == defaultHost) test(udpEndpoint.datagram()) test(udpEndpoint.port > 0) adapter.destroy() communicator.getProperties().setProperty("TestAdapter.Endpoints", "default -h * -p 12020") communicator.getProperties().setProperty("TestAdapter.PublishedEndpoints", "default -h 127.0.0.1 -p 12020") adapter = communicator.createObjectAdapter("TestAdapter") endpoints = adapter.getEndpoints() test(len(endpoints) >= 1) publishedEndpoints = adapter.getPublishedEndpoints() test(len(publishedEndpoints) == 1) for i in range(0, len(endpoints)): ipEndpoint = endpoints[i].getInfo() test(ipEndpoint.port == 12020) ipEndpoint = publishedEndpoints[0].getInfo() test(ipEndpoint.host == "127.0.0.1") test(ipEndpoint.port == 12020) adapter.destroy() print("ok") base = communicator.stringToProxy("test:default -p 12010:udp -p 12010") testIntf = Test.TestIntfPrx.checkedCast(base) sys.stdout.write("test connection endpoint information... ") sys.stdout.flush() ipinfo = base.ice_getConnection().getEndpoint().getInfo() test(ipinfo.port == 12010) test(not ipinfo.compress) test(ipinfo.host == defaultHost) ctx = testIntf.getEndpointInfoAsContext() test(ctx["host"] == ipinfo.host) test(ctx["compress"] == "false") port = int(ctx["port"]) test(port > 0) udp = base.ice_datagram().ice_getConnection().getEndpoint().getInfo() test(udp.port == 12010) test(udp.host == defaultHost) print("ok") sys.stdout.write("testing connection information... ") sys.stdout.flush() info = base.ice_getConnection().getInfo() test(not info.incoming) test(len(info.adapterName) == 0) test(info.remotePort == 12010) test(info.remoteAddress == defaultHost) test(info.localAddress == defaultHost) ctx = testIntf.getConnectionInfoAsContext() test(ctx["incoming"] == "true") test(ctx["adapterName"] == "TestAdapter") test(ctx["remoteAddress"] == info.localAddress) test(ctx["localAddress"] == info.remoteAddress) test(ctx["remotePort"] == str(info.localPort)) test(ctx["localPort"] == str(info.remotePort)) print("ok") testIntf.shutdown() communicator.shutdown() communicator.waitForShutdown()