public static int Main(string[] args) { int status = 0; Ice.Communicator communicator = null; try { Console.Error.Write("testing proxy & endpoint hash algorithm collisions... "); Console.Error.Flush(); Dictionary <int, Ice.ObjectPrx> seenProxy = new Dictionary <int, Ice.ObjectPrx>(); Dictionary <int, Ice.Endpoint> seenEndpoint = new Dictionary <int, Ice.Endpoint>(); int proxyCollisions = 0; int endpointCollisions = 0; int i = 0; int maxCollisions = 10; int maxIterations = 10000; Ice.InitializationData initData = new Ice.InitializationData(); initData.properties = Ice.Util.createProperties(ref args); //initData.properties.setProperty("Ice.Plugin.IceSSL", "IceSSL:IceSSL.PluginFactory"); communicator = Ice.Util.initialize(ref args, initData); { Random rand = new Random(); for (i = 0; proxyCollisions < maxCollisions && endpointCollisions < maxCollisions && i < maxIterations; ++i) { System.IO.StringWriter sw = new System.IO.StringWriter(); sw.Write(i); sw.Write(":tcp -p "); sw.Write(rand.Next(65536)); sw.Write(" -t 10"); sw.Write(rand.Next(1000000)); sw.Write(":udp -p "); sw.Write(rand.Next(65536)); sw.Write(" -h "); sw.Write(rand.Next(100)); Ice.ObjectPrx obj = communicator.stringToProxy(sw.ToString()); List <Ice.Endpoint> endpoints = new List <Ice.Endpoint>(obj.ice_getEndpoints()); if (seenProxy.ContainsKey(obj.GetHashCode())) { if (obj.Equals(seenProxy[obj.GetHashCode()])) { continue; } ++proxyCollisions; } else { seenProxy[obj.GetHashCode()] = obj; } foreach (Ice.Endpoint endpoint in endpoints) { if (seenEndpoint.ContainsKey(endpoint.GetHashCode())) { if (endpoint.Equals(seenEndpoint[endpoint.GetHashCode()])) { continue; } ++endpointCollisions; } else { seenEndpoint[endpoint.GetHashCode()] = endpoint; } // // Check the same endpoint produce always the same hash // test(endpoint.GetHashCode() == endpoint.GetHashCode()); } // // Check the same proxy produce always the same hash // test(obj.GetHashCode() == obj.GetHashCode()); } test(proxyCollisions < maxCollisions); test(endpointCollisions < maxCollisions); { Ice.ProxyIdentityKey comparer = new Ice.ProxyIdentityKey(); proxyCollisions = 0; seenProxy = new Dictionary <int, Ice.ObjectPrx>(); for (i = 0; proxyCollisions < maxCollisions && i < maxIterations; ++i) { System.IO.StringWriter sw = new System.IO.StringWriter(); sw.Write(i); sw.Write(":tcp -p "); sw.Write(rand.Next(65536)); sw.Write(" -t 10"); sw.Write(rand.Next(1000000)); sw.Write(":udp -p "); sw.Write(rand.Next(65536)); sw.Write(" -h "); sw.Write(rand.Next(100)); Ice.ObjectPrx obj = communicator.stringToProxy(sw.ToString()); if (seenProxy.ContainsKey(comparer.GetHashCode(obj))) { ++proxyCollisions; } else { seenProxy[comparer.GetHashCode(obj)] = obj; } // // Check the same proxy produce always the same hash // test(comparer.GetHashCode(obj) == comparer.GetHashCode(obj)); } test(proxyCollisions < maxCollisions); } } { Random rand = new Random(); Ice.ProxyIdentityFacetKey comparer = new Ice.ProxyIdentityFacetKey(); proxyCollisions = 0; seenProxy = new Dictionary <int, Ice.ObjectPrx>(); for (i = 0; proxyCollisions < maxCollisions && i < maxIterations; ++i) { System.IO.StringWriter sw = new System.IO.StringWriter(); sw.Write(i); sw.Write(" -f demo:tcp -p "); sw.Write(rand.Next(65536)); sw.Write(" -t 10"); sw.Write(rand.Next(1000000)); sw.Write(":udp -p "); sw.Write(rand.Next(65536)); sw.Write(" -h "); sw.Write(rand.Next(100)); Ice.ObjectPrx obj = communicator.stringToProxy(sw.ToString()); if (seenProxy.ContainsKey(comparer.GetHashCode(obj))) { ++proxyCollisions; } else { seenProxy[comparer.GetHashCode(obj)] = obj; } // // Check the same proxy produce always the same hash // test(comparer.GetHashCode(obj) == comparer.GetHashCode(obj)); } test(proxyCollisions < maxCollisions); } Ice.ProxyIdentityFacetKey iComparer = new Ice.ProxyIdentityFacetKey(); Ice.ProxyIdentityFacetKey ifComparer = new Ice.ProxyIdentityFacetKey(); Ice.ObjectPrx prx1 = communicator.stringToProxy("Glacier2/router:tcp -p 10010"); //Ice.ObjectPrx prx2 = communicator.stringToProxy("Glacier2/router:ssl -p 10011"); Ice.ObjectPrx prx3 = communicator.stringToProxy("Glacier2/router:udp -p 10012"); Ice.ObjectPrx prx4 = communicator.stringToProxy("Glacier2/router:tcp -h zeroc.com -p 10010"); //Ice.ObjectPrx prx5 = communicator.stringToProxy("Glacier2/router:ssl -h zeroc.com -p 10011"); Ice.ObjectPrx prx6 = communicator.stringToProxy("Glacier2/router:udp -h zeroc.com -p 10012"); Ice.ObjectPrx prx7 = communicator.stringToProxy("Glacier2/router:tcp -p 10010 -t 10000"); //Ice.ObjectPrx prx8 = communicator.stringToProxy("Glacier2/router:ssl -p 10011 -t 10000"); Ice.ObjectPrx prx9 = communicator.stringToProxy("Glacier2/router:tcp -h zeroc.com -p 10010 -t 10000"); //Ice.ObjectPrx prx10 = communicator.stringToProxy("Glacier2/router:ssl -h zeroc.com -p 10011 -t 10000"); Dictionary <string, int> proxyMap = new Dictionary <string, int>(); proxyMap["prx1"] = prx1.GetHashCode(); //proxyMap["prx2"] = prx2.GetHashCode(); proxyMap["prx3"] = prx3.GetHashCode(); proxyMap["prx4"] = prx4.GetHashCode(); //proxyMap["prx5"] = prx5.GetHashCode(); proxyMap["prx6"] = prx6.GetHashCode(); proxyMap["prx7"] = prx7.GetHashCode(); //proxyMap["prx8"] = prx8.GetHashCode(); proxyMap["prx9"] = prx9.GetHashCode(); //proxyMap["prx10"] = prx10.GetHashCode(); test(communicator.stringToProxy("Glacier2/router:tcp -p 10010").GetHashCode() == proxyMap["prx1"]); //test(communicator.stringToProxy("Glacier2/router:ssl -p 10011").GetHashCode() == proxyMap["prx2"]); test(communicator.stringToProxy("Glacier2/router:udp -p 10012").GetHashCode() == proxyMap["prx3"]); test(communicator.stringToProxy("Glacier2/router:tcp -h zeroc.com -p 10010").GetHashCode() == proxyMap["prx4"]); //test(communicator.stringToProxy("Glacier2/router:ssl -h zeroc.com -p 10011").GetHashCode() == proxyMap["prx5"]); test(communicator.stringToProxy("Glacier2/router:udp -h zeroc.com -p 10012").GetHashCode() == proxyMap["prx6"]); test(communicator.stringToProxy("Glacier2/router:tcp -p 10010 -t 10000").GetHashCode() == proxyMap["prx7"]); //test(communicator.stringToProxy("Glacier2/router:ssl -p 10011 -t 10000").GetHashCode() == proxyMap["prx8"]); test(communicator.stringToProxy("Glacier2/router:tcp -h zeroc.com -p 10010 -t 10000").GetHashCode() == proxyMap["prx9"]); //test(communicator.stringToProxy("Glacier2/router:ssl -h zeroc.com -p 10011 -t 10000").GetHashCode() == proxyMap["prx10"]); test(iComparer.GetHashCode(prx1) == iComparer.GetHashCode(prx1)); test(ifComparer.GetHashCode(prx1) == ifComparer.GetHashCode(prx1)); test(iComparer.GetHashCode(prx3) == iComparer.GetHashCode(prx3)); test(ifComparer.GetHashCode(prx3) == ifComparer.GetHashCode(prx3)); test(iComparer.GetHashCode(prx4) == iComparer.GetHashCode(prx4)); test(ifComparer.GetHashCode(prx4) == ifComparer.GetHashCode(prx4)); test(iComparer.GetHashCode(prx6) == iComparer.GetHashCode(prx6)); test(ifComparer.GetHashCode(prx6) == ifComparer.GetHashCode(prx6)); test(iComparer.GetHashCode(prx7) == iComparer.GetHashCode(prx7)); test(ifComparer.GetHashCode(prx7) == ifComparer.GetHashCode(prx7)); test(iComparer.GetHashCode(prx9) == iComparer.GetHashCode(prx9)); test(ifComparer.GetHashCode(prx9) == ifComparer.GetHashCode(prx9)); Console.Error.WriteLine("ok"); Console.Error.Write("testing exceptions hash algorithm collisions... "); { Dictionary <int, Test.OtherException> seenException = new Dictionary <int, Test.OtherException>(); Random rand = new Random(); int exceptionCollisions = 0; for (i = 0; i < maxIterations && exceptionCollisions < maxCollisions; ++i) { Test.OtherException ex = new Test.OtherException(rand.Next(100), rand.Next(100), 0, false); if (seenException.ContainsKey(ex.GetHashCode())) { if (ex.Equals(seenException[ex.GetHashCode()])) { continue; // same object } exceptionCollisions++; } else { seenException[ex.GetHashCode()] = ex; } // // Check the same exception produce always the same hash // test(ex.GetHashCode() == ex.GetHashCode()); } test(exceptionCollisions < maxCollisions); } // // Same as above but with numbers in high ranges // { Dictionary <int, Test.OtherException> seenException = new Dictionary <int, Test.OtherException>(); Random rand = new Random(); int exceptionCollisions = 0; for (i = 0; i < maxIterations && exceptionCollisions < maxCollisions; ++i) { Test.OtherException ex = new Test.OtherException(rand.Next(100) * 2 ^ 30, rand.Next(100) * 2 ^ 30, rand.Next(100) * 2 ^ 30, false); if (seenException.ContainsKey(ex.GetHashCode())) { if (ex.Equals(seenException[ex.GetHashCode()])) { continue; // same object } exceptionCollisions++; } else { seenException[ex.GetHashCode()] = ex; } // // Check the same exception produce always the same hash // test(ex.GetHashCode() == ex.GetHashCode()); } test(exceptionCollisions < maxCollisions); } { Dictionary <int, Test.BaseException> seenException = new Dictionary <int, Test.BaseException>(); Random rand = new Random(); int exceptionCollisions = 0; for (i = 0; i < maxIterations && exceptionCollisions < maxCollisions; ++i) { int v = rand.Next(1000); Test.BaseException ex = new Test.InvalidPointException(v); if (seenException.ContainsKey(ex.GetHashCode())) { if (ex.Equals(seenException[ex.GetHashCode()])) { continue; // same object } exceptionCollisions++; } else { seenException[ex.GetHashCode()] = ex; } // // Check the same exception produce always the same hash // test(ex.GetHashCode() == ex.GetHashCode()); ex = new Test.InvalidLengthException(v); if (seenException.ContainsKey(ex.GetHashCode())) { if (ex.Equals(seenException[ex.GetHashCode()])) { continue; // same object } exceptionCollisions++; } else { seenException[ex.GetHashCode()] = ex; } // // Check the same exception produce always the same hash // test(ex.GetHashCode() == ex.GetHashCode()); } test(exceptionCollisions < maxCollisions); } Console.Error.WriteLine("ok"); Console.Error.Write("testing struct hash algorithm collisions... "); { Dictionary <int, Test.PointF> seenPointF = new Dictionary <int, Test.PointF>(); Random rand = new Random(); int structCollisions = 0; for (i = 0; i < maxIterations && structCollisions < maxCollisions; ++i) { Test.PointF pf = new Test.PointF((float)rand.NextDouble(), (float)rand.NextDouble(), (float)rand.NextDouble()); if (seenPointF.ContainsKey(pf.GetHashCode())) { if (pf.Equals(seenPointF[pf.GetHashCode()])) { continue; // same object } structCollisions++; } else { seenPointF[pf.GetHashCode()] = pf; } // // Check the same struct produce always the same hash // test(pf.GetHashCode() == pf.GetHashCode()); } test(structCollisions < maxCollisions); Dictionary <int, Test.PointD> seenPointD = new Dictionary <int, Test.PointD>(); structCollisions = 0; for (i = 0; i < maxIterations && structCollisions < maxCollisions; ++i) { Test.PointD pd = new Test.PointD(rand.NextDouble(), rand.NextDouble(), rand.NextDouble()); if (seenPointD.ContainsKey(pd.GetHashCode())) { if (pd.Equals(seenPointD[pd.GetHashCode()])) { continue; // same object } structCollisions++; } else { seenPointD[pd.GetHashCode()] = pd; } // // Check the same struct produce always the same hash // test(pd.GetHashCode() == pd.GetHashCode()); } test(structCollisions < maxCollisions); Dictionary <int, Test.Polyline> seenPolyline = new Dictionary <int, Test.Polyline>(); structCollisions = 0; for (i = 0; i < maxIterations && structCollisions < maxCollisions; ++i) { Test.Polyline polyline = new Test.Polyline(); List <Test.Point> vertices = new List <Test.Point>(); for (int j = 0; j < 100; ++j) { vertices.Add(new Test.Point(rand.Next(100), rand.Next(100))); } polyline.vertices = vertices.ToArray(); if (seenPolyline.ContainsKey(polyline.GetHashCode())) { if (polyline.Equals(seenPolyline[polyline.GetHashCode()])) { continue; // same object } structCollisions++; } else { seenPolyline[polyline.GetHashCode()] = polyline; } // // Check the same struct produce always the same hash // test(polyline.GetHashCode() == polyline.GetHashCode()); } test(structCollisions < maxCollisions); Dictionary <int, Test.ColorPalette> seenColorPalette = new Dictionary <int, Test.ColorPalette>(); structCollisions = 0; for (i = 0; i < maxIterations && structCollisions < maxCollisions; ++i) { Test.ColorPalette colorPalette = new Test.ColorPalette(); colorPalette.colors = new Dictionary <int, Test.Color>(); for (int j = 0; j < 100; ++j) { colorPalette.colors[j] = new Test.Color(rand.Next(255), rand.Next(255), rand.Next(255), rand.Next(255)); } if (seenColorPalette.ContainsKey(colorPalette.GetHashCode())) { if (colorPalette.Equals(seenColorPalette[colorPalette.GetHashCode()])) { continue; // same object } structCollisions++; } else { seenColorPalette[colorPalette.GetHashCode()] = colorPalette; } // // Check the same struct produce always the same hash // test(colorPalette.GetHashCode() == colorPalette.GetHashCode()); } test(structCollisions < maxCollisions); Dictionary <int, Test.Color> seenColor = new Dictionary <int, Test.Color>(); structCollisions = 0; for (i = 0; i < maxIterations && structCollisions < maxCollisions; ++i) { Test.Color c = new Test.Color(rand.Next(255), rand.Next(255), rand.Next(255), rand.Next(255)); if (seenColor.ContainsKey(c.GetHashCode())) { if (c.Equals(seenColor[c.GetHashCode()])) { continue; // same object } structCollisions++; } else { seenColor[c.GetHashCode()] = c; } // // Check the same struct produce always the same hash // test(c.GetHashCode() == c.GetHashCode()); } test(structCollisions < maxCollisions); structCollisions = 0; Dictionary <int, Test.Draw> seenDraw = new Dictionary <int, Test.Draw>(); structCollisions = 0; for (i = 0; i < maxIterations && structCollisions < maxCollisions; ++i) { Test.Draw draw = new Test.Draw( new Test.Color(rand.Next(255), rand.Next(255), rand.Next(255), rand.Next(255)), new Test.Pen(rand.Next(10), new Test.Color(rand.Next(255), rand.Next(255), rand.Next(255), rand.Next(255))), false); if (seenDraw.ContainsKey(draw.GetHashCode())) { if (draw.Equals(seenDraw[draw.GetHashCode()])) { continue; // same object } structCollisions++; } else { seenDraw[draw.GetHashCode()] = draw; } // // Check the same struct produce always the same hash // test(draw.GetHashCode() == draw.GetHashCode()); } test(structCollisions < maxCollisions); } Console.Error.WriteLine("ok"); if (communicator != null) { communicator.destroy(); } } catch (Exception ex) { Console.WriteLine(ex.ToString()); status = 1; } return(status); }
public static Test.TestIntfPrx allTests(global::Test.TestHelper helper) { Ice.Communicator communicator = helper.communicator(); var output = helper.getWriter(); output.Write("testing stringToProxy... "); output.Flush(); string @ref = "test:" + helper.getTestEndpoint(0); Ice.ObjectPrx @base = communicator.stringToProxy(@ref); test(@base != null); output.WriteLine("ok"); output.Write("testing checked cast... "); output.Flush(); var obj = Test.TestIntfPrxHelper.checkedCast(@base); test(obj != null); test(obj.Equals(@base)); output.WriteLine("ok"); { output.Write("creating/destroying/recreating object adapter... "); output.Flush(); Ice.ObjectAdapter adapter = communicator.createObjectAdapterWithEndpoints("TransientTestAdapter", "default"); try { communicator.createObjectAdapterWithEndpoints("TransientTestAdapter", "default"); test(false); } catch (Ice.AlreadyRegisteredException) { } adapter.destroy(); // // Use a different port than the first adapter to avoid an "address already in use" error. // adapter = communicator.createObjectAdapterWithEndpoints("TransientTestAdapter", "default"); adapter.destroy(); output.WriteLine("ok"); } output.Write("creating/activating/deactivating object adapter in one operation... "); output.Flush(); obj.transient(); obj.end_transient(obj.begin_transient()); output.WriteLine("ok"); { output.Write("testing connection closure... "); output.Flush(); for (int i = 0; i < 10; ++i) { Ice.InitializationData initData = new Ice.InitializationData(); initData.properties = communicator.getProperties().ice_clone_(); Ice.Communicator comm = Ice.Util.initialize(initData); comm.stringToProxy("test:" + helper.getTestEndpoint(0)).begin_ice_ping(); comm.destroy(); } output.WriteLine("ok"); } output.Write("testing object adapter published endpoints... "); output.Flush(); { communicator.getProperties().setProperty("PAdapter.PublishedEndpoints", "tcp -h localhost -p 12345 -t 30000"); Ice.ObjectAdapter adapter = communicator.createObjectAdapter("PAdapter"); test(adapter.getPublishedEndpoints().Length == 1); Ice.Endpoint endpt = adapter.getPublishedEndpoints()[0]; test(endpt.ToString().Equals("tcp -h localhost -p 12345 -t 30000")); Ice.ObjectPrx prx = communicator.stringToProxy("dummy:tcp -h localhost -p 12346 -t 20000:tcp -h localhost -p 12347 -t 10000"); adapter.setPublishedEndpoints(prx.ice_getEndpoints()); test(adapter.getPublishedEndpoints().Length == 2); Ice.Identity id = new Ice.Identity(); id.name = "dummy"; test(IceUtilInternal.Arrays.Equals(adapter.createProxy(id).ice_getEndpoints(), prx.ice_getEndpoints())); test(IceUtilInternal.Arrays.Equals(adapter.getPublishedEndpoints(), prx.ice_getEndpoints())); adapter.refreshPublishedEndpoints(); test(adapter.getPublishedEndpoints().Length == 1); test(adapter.getPublishedEndpoints()[0].Equals(endpt)); communicator.getProperties().setProperty("PAdapter.PublishedEndpoints", "tcp -h localhost -p 12345 -t 20000"); adapter.refreshPublishedEndpoints(); test(adapter.getPublishedEndpoints().Length == 1); test(adapter.getPublishedEndpoints()[0].ToString().Equals("tcp -h localhost -p 12345 -t 20000")); adapter.destroy(); test(adapter.getPublishedEndpoints().Length == 0); } output.WriteLine("ok"); if (obj.ice_getConnection() != null) { output.Write("testing object adapter with bi-dir connection... "); output.Flush(); Ice.ObjectAdapter adapter = communicator.createObjectAdapter(""); obj.ice_getConnection().setAdapter(adapter); obj.ice_getConnection().setAdapter(null); adapter.deactivate(); try { obj.ice_getConnection().setAdapter(adapter); test(false); } catch (Ice.ObjectAdapterDeactivatedException) { } output.WriteLine("ok"); } output.Write("testing object adapter with router... "); output.Flush(); { Ice.Identity routerId = new Ice.Identity(); routerId.name = "router"; Ice.RouterPrx router = Ice.RouterPrxHelper.uncheckedCast(@base.ice_identity(routerId).ice_connectionId("rc")); Ice.ObjectAdapter adapter = communicator.createObjectAdapterWithRouter("", router); test(adapter.getPublishedEndpoints().Length == 1); test(adapter.getPublishedEndpoints()[0].ToString().Equals("tcp -h localhost -p 23456 -t 30000")); adapter.refreshPublishedEndpoints(); test(adapter.getPublishedEndpoints().Length == 1); test(adapter.getPublishedEndpoints()[0].ToString().Equals("tcp -h localhost -p 23457 -t 30000")); try { adapter.setPublishedEndpoints(router.ice_getEndpoints()); test(false); } catch (ArgumentException) { // Expected. } adapter.destroy(); try { routerId.name = "test"; router = Ice.RouterPrxHelper.uncheckedCast(@base.ice_identity(routerId)); communicator.createObjectAdapterWithRouter("", router); test(false); } catch (Ice.OperationNotExistException) { // Expected: the "test" object doesn't implement Ice::Router! } try { router = Ice.RouterPrxHelper.uncheckedCast(communicator.stringToProxy("test:" + helper.getTestEndpoint(1))); communicator.createObjectAdapterWithRouter("", router); test(false); } catch (Ice.ConnectFailedException) { } } output.WriteLine("ok"); output.Write("testing object adapter creation with port in use... "); output.Flush(); { var adapter1 = communicator.createObjectAdapterWithEndpoints("Adpt1", helper.getTestEndpoint(10)); try { communicator.createObjectAdapterWithEndpoints("Adpt2", helper.getTestEndpoint(10)); test(false); } catch (Ice.LocalException) { // Expected can't re-use the same endpoint. } adapter1.destroy(); } output.WriteLine("ok"); output.Write("deactivating object adapter in the server... "); output.Flush(); obj.deactivate(); output.WriteLine("ok"); output.Write("testing whether server is gone... "); output.Flush(); try { obj.ice_timeout(100).ice_ping(); // Use timeout to speed up testing on Windows test(false); } catch (Ice.LocalException) { output.WriteLine("ok"); } return(obj); }
public static void allTests(TestCommon.Application app) { Ice.Communicator communicator = app.communicator(); Write("testing proxy endpoint information... "); Flush(); { Ice.ObjectPrx p1 = communicator.stringToProxy( "test -t:default -h tcphost -p 10000 -t 1200 -z --sourceAddress 10.10.10.10:" + "udp -h udphost -p 10001 --interface eth0 --ttl 5 --sourceAddress 10.10.10.10:" + "opaque -e 1.8 -t 100 -v ABCD"); Ice.Endpoint[] endps = p1.ice_getEndpoints(); Ice.EndpointInfo info = endps[0].getInfo(); Ice.TCPEndpointInfo tcpEndpoint = getTCPEndpointInfo(info); test(tcpEndpoint.host.Equals("tcphost")); test(tcpEndpoint.port == 10000); test(tcpEndpoint.sourceAddress.Equals("10.10.10.10")); test(tcpEndpoint.timeout == 1200); test(tcpEndpoint.compress); test(!tcpEndpoint.datagram()); test(tcpEndpoint.type() == Ice.TCPEndpointType.value && !tcpEndpoint.secure() || tcpEndpoint.type() == Ice.SSLEndpointType.value && tcpEndpoint.secure() || tcpEndpoint.type() == Ice.WSEndpointType.value && !tcpEndpoint.secure() || tcpEndpoint.type() == Ice.WSSEndpointType.value && tcpEndpoint.secure()); test(tcpEndpoint.type() == Ice.TCPEndpointType.value && info is Ice.TCPEndpointInfo || tcpEndpoint.type() == Ice.SSLEndpointType.value && info is IceSSL.EndpointInfo || tcpEndpoint.type() == Ice.WSEndpointType.value && info is Ice.WSEndpointInfo || tcpEndpoint.type() == Ice.WSSEndpointType.value && info is Ice.WSEndpointInfo); Ice.UDPEndpointInfo udpEndpoint = (Ice.UDPEndpointInfo)endps[1].getInfo(); test(udpEndpoint.host.Equals("udphost")); test(udpEndpoint.port == 10001); test(udpEndpoint.mcastInterface.Equals("eth0")); test(udpEndpoint.mcastTtl == 5); test(udpEndpoint.sourceAddress.Equals("10.10.10.10")); test(udpEndpoint.timeout == -1); test(!udpEndpoint.compress); test(!udpEndpoint.secure()); test(udpEndpoint.datagram()); test(udpEndpoint.type() == 3); Ice.OpaqueEndpointInfo opaqueEndpoint = (Ice.OpaqueEndpointInfo)endps[2].getInfo(); test(opaqueEndpoint.rawBytes.Length > 0); test(opaqueEndpoint.rawEncoding.Equals(new Ice.EncodingVersion(1, 8))); } WriteLine("ok"); Ice.ObjectAdapter adapter; Write("test object adapter endpoint information... "); Flush(); { string host = communicator.getProperties().getPropertyAsInt("Ice.IPv6") != 0 ? "::1" : "127.0.0.1"; communicator.getProperties().setProperty("TestAdapter.Endpoints", "tcp -h \"" + host + "\" -t 15000:udp -h \"" + host + "\""); adapter = communicator.createObjectAdapter("TestAdapter"); Ice.Endpoint[] endpoints = adapter.getEndpoints(); test(endpoints.Length == 2); Ice.Endpoint[] publishedEndpoints = adapter.getPublishedEndpoints(); test(IceUtilInternal.Arrays.Equals(endpoints, publishedEndpoints)); Ice.TCPEndpointInfo tcpEndpoint = getTCPEndpointInfo(endpoints[0].getInfo()); test(tcpEndpoint.type() == Ice.TCPEndpointType.value || tcpEndpoint.type() == Ice.SSLEndpointType.value || tcpEndpoint.type() == Ice.WSEndpointType.value || tcpEndpoint.type() == Ice.WSSEndpointType.value); test(tcpEndpoint.host.Equals(host)); test(tcpEndpoint.port > 0); test(tcpEndpoint.timeout == 15000); Ice.UDPEndpointInfo udpEndpoint = (Ice.UDPEndpointInfo)endpoints[1].getInfo(); test(udpEndpoint.host.Equals(host)); test(udpEndpoint.datagram()); test(udpEndpoint.port > 0); endpoints = new Ice.Endpoint[] { endpoints[0] }; test(endpoints.Length == 1); adapter.setPublishedEndpoints(endpoints); publishedEndpoints = adapter.getPublishedEndpoints(); test(IceUtilInternal.Arrays.Equals(endpoints, publishedEndpoints)); adapter.destroy(); int port = app.getTestPort(1); communicator.getProperties().setProperty("TestAdapter.Endpoints", "default -h * -p " + port); communicator.getProperties().setProperty("TestAdapter.PublishedEndpoints", app.getTestEndpoint(1)); adapter = communicator.createObjectAdapter("TestAdapter"); endpoints = adapter.getEndpoints(); test(endpoints.Length >= 1); publishedEndpoints = adapter.getPublishedEndpoints(); test(publishedEndpoints.Length == 1); foreach (Ice.Endpoint endpoint in endpoints) { tcpEndpoint = getTCPEndpointInfo(endpoint.getInfo()); test(tcpEndpoint.port == port); } tcpEndpoint = getTCPEndpointInfo(publishedEndpoints[0].getInfo()); test(tcpEndpoint.host.Equals("127.0.0.1")); test(tcpEndpoint.port == port); adapter.destroy(); } WriteLine("ok"); int endpointPort = app.getTestPort(0); Ice.ObjectPrx @base = communicator.stringToProxy("test:" + app.getTestEndpoint(0) + ":" + app.getTestEndpoint(0, "udp")); TestIntfPrx testIntf = TestIntfPrxHelper.checkedCast(@base); string defaultHost = communicator.getProperties().getProperty("Ice.Default.Host"); Write("test connection endpoint information... "); Flush(); { Ice.EndpointInfo info = @base.ice_getConnection().getEndpoint().getInfo(); Ice.TCPEndpointInfo tcpinfo = getTCPEndpointInfo(info); test(tcpinfo.port == endpointPort); test(!tcpinfo.compress); test(tcpinfo.host.Equals(defaultHost)); Dictionary <string, string> ctx = testIntf.getEndpointInfoAsContext(); test(ctx["host"].Equals(tcpinfo.host)); test(ctx["compress"].Equals("false")); int port = System.Int32.Parse(ctx["port"]); test(port > 0); info = @base.ice_datagram().ice_getConnection().getEndpoint().getInfo(); Ice.UDPEndpointInfo udp = (Ice.UDPEndpointInfo)info; test(udp.port == endpointPort); test(udp.host.Equals(defaultHost)); } WriteLine("ok"); Write("testing connection information... "); Flush(); { Ice.Connection connection = @base.ice_getConnection(); connection.setBufferSize(1024, 2048); Ice.ConnectionInfo info = connection.getInfo(); Ice.TCPConnectionInfo ipInfo = getTCPConnectionInfo(info); test(!info.incoming); test(info.adapterName.Length == 0); test(ipInfo.remotePort == endpointPort); test(ipInfo.localPort > 0); if (defaultHost.Equals("127.0.0.1")) { test(ipInfo.localAddress.Equals(defaultHost)); test(ipInfo.remoteAddress.Equals(defaultHost)); } test(ipInfo.rcvSize >= 1024); test(ipInfo.sndSize >= 2048); Dictionary <string, string> ctx = testIntf.getConnectionInfoAsContext(); test(ctx["incoming"].Equals("true")); test(ctx["adapterName"].Equals("TestAdapter")); test(ctx["remoteAddress"].Equals(ipInfo.localAddress)); test(ctx["localAddress"].Equals(ipInfo.remoteAddress)); test(ctx["remotePort"].Equals(ipInfo.localPort.ToString())); test(ctx["localPort"].Equals(ipInfo.remotePort.ToString())); if (@base.ice_getConnection().type().Equals("ws") || @base.ice_getConnection().type().Equals("wss")) { Dictionary <string, string> headers = ((Ice.WSConnectionInfo)info).headers; test(headers["Upgrade"].Equals("websocket")); test(headers["Connection"].Equals("Upgrade")); test(headers["Sec-WebSocket-Protocol"].Equals("ice.zeroc.com")); test(headers["Sec-WebSocket-Accept"] != null); test(ctx["ws.Upgrade"].Equals("websocket")); test(ctx["ws.Connection"].Equals("Upgrade")); test(ctx["ws.Sec-WebSocket-Protocol"].Equals("ice.zeroc.com")); test(ctx["ws.Sec-WebSocket-Version"].Equals("13")); test(ctx["ws.Sec-WebSocket-Key"] != null); } connection = @base.ice_datagram().ice_getConnection(); connection.setBufferSize(2048, 1024); Ice.UDPConnectionInfo udpInfo = (Ice.UDPConnectionInfo)connection.getInfo(); test(!udpInfo.incoming); test(udpInfo.adapterName.Length == 0); test(udpInfo.localPort > 0); test(udpInfo.remotePort == endpointPort); if (defaultHost.Equals("127.0.0.1")) { test(udpInfo.remoteAddress.Equals(defaultHost)); test(udpInfo.localAddress.Equals(defaultHost)); } test(udpInfo.rcvSize >= 2048); test(udpInfo.sndSize >= 1024); } WriteLine("ok"); testIntf.shutdown(); communicator.shutdown(); communicator.waitForShutdown(); }
public static void allTests(Ice.Communicator communicator) #endif { Write("testing proxy endpoint information... "); Flush(); { Ice.ObjectPrx p1 = communicator.stringToProxy( "test -t:default -h tcphost -p 10000 -t 1200 -z --sourceAddress 10.10.10.10:" + "udp -h udphost -p 10001 --interface eth0 --ttl 5 --sourceAddress 10.10.10.10:" + "opaque -e 1.8 -t 100 -v ABCD"); Ice.Endpoint[] endps = p1.ice_getEndpoints(); Ice.IPEndpointInfo ipEndpoint = (Ice.IPEndpointInfo)endps[0].getInfo(); test(ipEndpoint.host.Equals("tcphost")); test(ipEndpoint.port == 10000); test(ipEndpoint.sourceAddress.Equals("10.10.10.10")); test(ipEndpoint.timeout == 1200); test(ipEndpoint.compress); test(!ipEndpoint.datagram()); #if __MonoCS__ test(ipEndpoint.type() == Ice.TCPEndpointType.value && !ipEndpoint.secure() || ipEndpoint.type() == Ice.WSEndpointType.value && !ipEndpoint.secure()); test(ipEndpoint.type() == Ice.TCPEndpointType.value && ipEndpoint is Ice.TCPEndpointInfo || ipEndpoint.type() == Ice.WSEndpointType.value && ipEndpoint is Ice.WSEndpointInfo); #elif COMPACT || SILVERLIGHT test(ipEndpoint.type() == Ice.TCPEndpointType.value && !ipEndpoint.secure()); test(ipEndpoint.type() == Ice.TCPEndpointType.value && ipEndpoint is Ice.TCPEndpointInfo); #else test(ipEndpoint.type() == Ice.TCPEndpointType.value && !ipEndpoint.secure() || ipEndpoint.type() == IceSSL.EndpointType.value && ipEndpoint.secure() || ipEndpoint.type() == Ice.WSEndpointType.value && !ipEndpoint.secure() || ipEndpoint.type() == Ice.WSSEndpointType.value && ipEndpoint.secure()); test(ipEndpoint.type() == Ice.TCPEndpointType.value && ipEndpoint is Ice.TCPEndpointInfo || ipEndpoint.type() == IceSSL.EndpointType.value && ipEndpoint is IceSSL.EndpointInfo || ipEndpoint.type() == Ice.WSEndpointType.value && ipEndpoint is Ice.WSEndpointInfo || ipEndpoint.type() == Ice.WSSEndpointType.value && ipEndpoint is IceSSL.WSSEndpointInfo); #endif Ice.UDPEndpointInfo udpEndpoint = (Ice.UDPEndpointInfo)endps[1].getInfo(); test(udpEndpoint.host.Equals("udphost")); test(udpEndpoint.port == 10001); test(udpEndpoint.mcastInterface.Equals("eth0")); test(udpEndpoint.mcastTtl == 5); test(udpEndpoint.sourceAddress.Equals("10.10.10.10")); test(udpEndpoint.timeout == -1); test(!udpEndpoint.compress); test(!udpEndpoint.secure()); test(udpEndpoint.datagram()); test(udpEndpoint.type() == 3); Ice.OpaqueEndpointInfo opaqueEndpoint = (Ice.OpaqueEndpointInfo)endps[2].getInfo(); test(opaqueEndpoint.rawBytes.Length > 0); test(opaqueEndpoint.rawEncoding.Equals(new Ice.EncodingVersion(1, 8))); } WriteLine("ok"); string defaultHost = communicator.getProperties().getProperty("Ice.Default.Host"); #if !SILVERLIGHT Ice.ObjectAdapter adapter; Write("test object adapter endpoint information... "); Flush(); { communicator.getProperties().setProperty("TestAdapter.Endpoints", "default -t 15000:udp"); adapter = communicator.createObjectAdapter("TestAdapter"); Ice.Endpoint[] endpoints = adapter.getEndpoints(); test(endpoints.Length == 2); Ice.Endpoint[] publishedEndpoints = adapter.getPublishedEndpoints(); test(IceUtilInternal.Arrays.Equals(endpoints, publishedEndpoints)); Ice.IPEndpointInfo ipEndpoint = (Ice.IPEndpointInfo)endpoints[0].getInfo(); # if __MonoCS__ test(ipEndpoint.type() == Ice.TCPEndpointType.value || ipEndpoint.type() == Ice.WSEndpointType.value); # elif COMPACT