/// <summary> /// Start the pinger. It runs in a thread and returns the average response time. /// </summary> /// <param name="session">Session to ping. Note that this cannot be a UDP or /// one-way session, because it requires a response from the server to be /// effective.</param> public Pinger(Ice.ObjectPrx _session) { session = _session; Running = true; internalThread = new Thread(new ThreadStart(Run)); internalThread.Start(); }
public override void reply(Ice.ObjectPrx obj, Ice.Current current) { #if COMPACT _m.Lock(); try { if(_obj == null) { _obj = obj; } _m.Notify(); } finally { _m.Unlock(); } #else lock(this) { if(_obj == null) { _obj = obj; } Monitor.Pulse(this); } #endif }
public void ConnectServer() { try { Ice.InitializationData initData = new Ice.InitializationData(); initData.properties = Ice.Util.createProperties(); string strConfigFile = GetProcessPath() + @"\..\Config\IceClientConfig.txt"; try { initData.properties.load(strConfigFile); } catch (System.Exception ex) { Console.WriteLine(ex.Message); } communicator = Ice.Util.initialize(initData); string sProxy = strProxyKey + ".Proxy"; string strProxy = initData.properties.getProperty(sProxy); m_objectPrx = communicator.stringToProxy(strProxy); GetProxy(); } catch (System.Exception ex) { Console.WriteLine(ex.Message); } }
public override void ice_invoke_async(Ice.AMD_Object_ice_invoke amdCb, byte[] inEncaps, Ice.Current current) { bool twoway = current.requestId > 0; Ice.ObjectPrx obj = current.con.createProxy(current.id); if(!twoway) { if(_startBatch) { _startBatch = false; _batchProxy = obj.ice_batchOneway(); } if(_batchProxy != null) { obj = _batchProxy; } if(current.facet.Length != 0) { obj = obj.ice_facet(current.facet); } if(_batchProxy != null) { byte[] outEncaps; obj.ice_invoke(current.operation, current.mode, inEncaps, out outEncaps, current.ctx); amdCb.ice_response(true, new byte[0]); } else { Callback cb = new Callback(amdCb, false); obj.ice_oneway().begin_ice_invoke(current.operation, current.mode, inEncaps, current.ctx).whenCompleted(cb.response, cb.exception) .whenSent(cb.sent); } } else { if(current.facet.Length != 0) { obj = obj.ice_facet(current.facet); } Callback cb = new Callback(amdCb, true); obj.begin_ice_invoke(current.operation, current.mode, inEncaps, current.ctx).whenCompleted(cb.response, cb.exception).whenSent(cb.sent); } }
public override Task<Ice.Object_Ice_invokeResult> ice_invokeAsync(byte[] inEncaps, Ice.Current current) { bool twoway = current.requestId > 0; Ice.ObjectPrx obj = current.con.createProxy(current.id); if(!twoway) { if(_startBatch) { _startBatch = false; _batchProxy = obj.ice_batchOneway(); } if(_batchProxy != null) { obj = _batchProxy; } if(current.facet.Length != 0) { obj = obj.ice_facet(current.facet); } if(_batchProxy != null) { byte[] outEncaps; obj.ice_invoke(current.operation, current.mode, inEncaps, out outEncaps, current.ctx); return Task.FromResult(new Ice.Object_Ice_invokeResult(true, new byte[0])); } else { return obj.ice_oneway().ice_invokeAsync(current.operation, current.mode, inEncaps, current.ctx); } } else { if(current.facet.Length != 0) { obj = obj.ice_facet(current.facet); } return obj.ice_invokeAsync(current.operation, current.mode, inEncaps, current.ctx); } }
public override int run(string[] args) { string protocol = getTestProtocol(); string host = getTestHost(); _factory = new Glacier2.SessionFactoryHelper(_initData, new SessionCallback1(this)); // // Test to create a session with wrong userid/password // lock (this) { Console.Out.Write("testing SessionHelper connect with wrong userid/password... "); Console.Out.Flush(); _factory.setProtocol(protocol); _session = _factory.connect("userid", "xxx"); while (true) { try { Monitor.Wait(this, 30000); break; } catch (ThreadInterruptedException) { } } test(!_session.isConnected()); } _initData.properties.setProperty("Ice.Default.Router", ""); _factory = new Glacier2.SessionFactoryHelper(_initData, new SessionCallback4(this)); lock (this) { Console.Out.Write("testing SessionHelper connect interrupt... "); Console.Out.Flush(); _factory.setRouterHost(host); _factory.setPort(getTestPort(1)); _factory.setProtocol(protocol); _session = _factory.connect("userid", "abc123"); Thread.Sleep(100); _session.destroy(); while (true) { try { Monitor.Wait(this, 30000); break; } catch (ThreadInterruptedException) { } } test(!_session.isConnected()); } _factory = new Glacier2.SessionFactoryHelper(_initData, new SessionCallback2(this)); lock (this) { Console.Out.Write("testing SessionHelper connect... "); Console.Out.Flush(); _factory.setRouterHost(host); _factory.setPort(getTestPort(10)); _factory.setProtocol(protocol); _session = _factory.connect("userid", "abc123"); while (true) { try { Monitor.Wait(this, 30000); break; } catch (ThreadInterruptedException) { } } Console.Out.Write("testing SessionHelper isConnected after connect... "); Console.Out.Flush(); test(_session.isConnected()); Console.Out.WriteLine("ok"); Console.Out.Write("testing SessionHelper categoryForClient after connect... "); Console.Out.Flush(); try { test(!_session.categoryForClient().Equals("")); } catch (Glacier2.SessionNotExistException) { test(false); } Console.Out.WriteLine("ok"); // try // { // test(_session.session() != null); // } // catch(Glacier2.SessionNotExistException ex) // { // test(false); // } Console.Out.Write("testing stringToProxy for server object... "); Console.Out.Flush(); Ice.ObjectPrx @base = _session.communicator().stringToProxy("callback:" + getTestEndpoint(0)); Console.Out.WriteLine("ok"); Console.Out.Write("pinging server after session creation... "); Console.Out.Flush(); @base.ice_ping(); Console.Out.WriteLine("ok"); Console.Out.Write("testing checked cast for server object... "); Console.Out.Flush(); CallbackPrx twoway = CallbackPrxHelper.checkedCast(@base); test(twoway != null); Console.Out.WriteLine("ok"); Console.Out.Write("testing server shutdown... "); Console.Out.Flush(); twoway.shutdown(); Console.Out.WriteLine("ok"); test(_session.communicator() != null); Console.Out.Write("testing SessionHelper destroy... "); Console.Out.Flush(); _session.destroy(); while (true) { try { Monitor.Wait(this); break; } catch (ThreadInterruptedException) { } } Console.Out.Write("testing SessionHelper isConnected after destroy... "); Console.Out.Flush(); test(_session.isConnected() == false); Console.Out.WriteLine("ok"); Console.Out.Write("testing SessionHelper categoryForClient after destroy... "); Console.Out.Flush(); try { test(!_session.categoryForClient().Equals("")); test(false); } catch (Glacier2.SessionNotExistException) { } Console.Out.WriteLine("ok"); Console.Out.Write("testing SessionHelper session after destroy... "); try { _session.session(); test(false); } catch (Glacier2.SessionNotExistException) { } Console.Out.WriteLine("ok"); Console.Out.Write("testing SessionHelper communicator after destroy... "); Console.Out.Flush(); try { test(_session.communicator() != null); _session.communicator().stringToProxy("dummy"); test(false); } catch (Ice.CommunicatorDestroyedException) { } Console.Out.WriteLine("ok"); Console.Out.Write("uninstalling router with communicator... "); Console.Out.Flush(); communicator().setDefaultRouter(null); Console.Out.WriteLine("ok"); Ice.ObjectPrx processBase; { Console.Out.Write("testing stringToProxy for process object... "); processBase = communicator().stringToProxy("Glacier2/admin -f Process:" + getTestEndpoint(11)); Console.Out.WriteLine("ok"); } Ice.ProcessPrx process; { Console.Out.Write("testing checked cast for admin object... "); process = Ice.ProcessPrxHelper.checkedCast(processBase); test(process != null); Console.Out.WriteLine("ok"); } Console.Out.Write("testing Glacier2 shutdown... "); process.shutdown(); try { process.ice_ping(); test(false); } catch (Ice.LocalException) { Console.Out.WriteLine("ok"); } } _factory = new Glacier2.SessionFactoryHelper(_initData, new SessionCallback3(this)); lock (this) { Console.Out.Write("testing SessionHelper connect after router shutdown... "); Console.Out.Flush(); _factory.setRouterHost(host); _factory.setPort(getTestPort(10)); _factory.setProtocol(protocol); _session = _factory.connect("userid", "abc123"); while (true) { try { Monitor.Wait(this); break; } catch (ThreadInterruptedException) { } } Console.Out.Write("testing SessionHelper isConnect after connect failure... "); Console.Out.Flush(); test(_session.isConnected() == false); Console.Out.WriteLine("ok"); Console.Out.Write("testing SessionHelper communicator after connect failure... "); Console.Out.Flush(); try { test(_session.communicator() != null); _session.communicator().stringToProxy("dummy"); test(false); } catch (Ice.CommunicatorDestroyedException) { } Console.Out.WriteLine("ok"); Console.Out.Write("testing SessionHelper destroy after connect failure... "); Console.Out.Flush(); _session.destroy(); Console.Out.WriteLine("ok"); } return(0); }
public static MetricsPrx allTests(Ice.Communicator communicator, CommunicatorObserverI obsv) { MetricsPrx metrics = MetricsPrxHelper.checkedCast(communicator.stringToProxy("metrics:default -p 12010")); bool collocated = metrics.ice_getConnection() == null; Write("testing metrics admin facet checkedCast... "); Flush(); Ice.ObjectPrx admin = communicator.getAdmin(); Ice.PropertiesAdminPrx clientProps = Ice.PropertiesAdminPrxHelper.checkedCast(admin, "Properties"); IceMX.MetricsAdminPrx clientMetrics = IceMX.MetricsAdminPrxHelper.checkedCast(admin, "Metrics"); test(clientProps != null && clientMetrics != null); admin = metrics.getAdmin(); Ice.PropertiesAdminPrx serverProps = Ice.PropertiesAdminPrxHelper.checkedCast(admin, "Properties"); IceMX.MetricsAdminPrx serverMetrics = IceMX.MetricsAdminPrxHelper.checkedCast(admin, "Metrics"); test(serverProps != null && serverMetrics != null); UpdateCallbackI update = new UpdateCallbackI(serverProps); ((Ice.NativePropertiesAdmin)communicator.findAdminFacet("Properties")).addUpdateCallback(update); WriteLine("ok"); Dictionary <string, string> props = new Dictionary <string, string>(); Write("testing group by none..."); Flush(); props.Add("IceMX.Metrics.View.GroupBy", "none"); updateProps(clientProps, serverProps, update, props, ""); long timestamp; Dictionary <string, IceMX.Metrics[]> view = clientMetrics.getMetricsView("View", out timestamp); if (!collocated) { test(view["Connection"].Length == 1 && view["Connection"][0].current == 1 && view["Connection"][0].total == 1); } test(view["Thread"].Length == 1 && view["Thread"][0].current == 5 && view["Thread"][0].total == 5); WriteLine("ok"); Write("testing group by id..."); Flush(); props["IceMX.Metrics.View.GroupBy"] = "id"; updateProps(clientProps, serverProps, update, props, ""); metrics.ice_ping(); metrics.ice_ping(); metrics.ice_connectionId("Con1").ice_ping(); metrics.ice_connectionId("Con1").ice_ping(); metrics.ice_connectionId("Con1").ice_ping(); waitForCurrent(clientMetrics, "View", "Invocation", 0); view = clientMetrics.getMetricsView("View", out timestamp); test(view["Thread"].Length == 5); if (!collocated) { test(view["Connection"].Length == 2); } test(view["Invocation"].Length == 1); IceMX.InvocationMetrics invoke = (IceMX.InvocationMetrics)view["Invocation"][0]; test(invoke.id.IndexOf("[ice_ping]") > 0 && invoke.current == 0 && invoke.total == 5); if (!collocated) { test(invoke.remotes.Length == 2); test(invoke.remotes[0].total >= 2 && invoke.remotes[1].total >= 2); test((invoke.remotes[0].total + invoke.remotes[1].total) == 5); } else { test(invoke.collocated.Length == 1); test(invoke.collocated[0].total == 5); } view = serverMetrics.getMetricsView("View", out timestamp); // With Ice for .NET, a new dispatching thread isn't necessarily created. //test(view["Thread"].Length > 5); if (!collocated) { test(view["Connection"].Length == 2); } test(view["Dispatch"].Length == 1); test(view["Dispatch"][0].current <= 1 && view["Dispatch"][0].total == 5); test(view["Dispatch"][0].id.IndexOf("[ice_ping]") > 0); if (!collocated) { metrics.ice_getConnection().close(false); metrics.ice_connectionId("Con1").ice_getConnection().close(false); waitForCurrent(clientMetrics, "View", "Connection", 0); waitForCurrent(serverMetrics, "View", "Connection", 0); } clearView(clientProps, serverProps, update); WriteLine("ok"); string endpoint = communicator.getProperties().getPropertyWithDefault("Ice.Default.Protocol", "tcp") + " -h 127.0.0.1 -p 12010"; string type = ""; string isSecure = ""; if (!collocated) { Ice.EndpointInfo endpointInfo = metrics.ice_getConnection().getEndpoint().getInfo(); type = endpointInfo.type().ToString(); isSecure = endpointInfo.secure() ? "True": "False"; } Dictionary <string, IceMX.Metrics> map; if (!collocated) { Write("testing connection metrics... "); Flush(); props["IceMX.Metrics.View.Map.Connection.GroupBy"] = "none"; updateProps(clientProps, serverProps, update, props, "Connection"); test(clientMetrics.getMetricsView("View", out timestamp)["Connection"].Length == 0); test(serverMetrics.getMetricsView("View", out timestamp)["Connection"].Length == 0); metrics.ice_ping(); IceMX.ConnectionMetrics cm1, sm1, cm2, sm2; cm1 = (IceMX.ConnectionMetrics)clientMetrics.getMetricsView("View", out timestamp)["Connection"][0]; sm1 = getServerConnectionMetrics(serverMetrics, 25); metrics.ice_ping(); cm2 = (IceMX.ConnectionMetrics)clientMetrics.getMetricsView("View", out timestamp)["Connection"][0]; sm2 = getServerConnectionMetrics(serverMetrics, 50); test(cm2.sentBytes - cm1.sentBytes == 45); // 45 for ice_ping request test(cm2.receivedBytes - cm1.receivedBytes == 25); // 25 bytes for ice_ping response test(sm2.receivedBytes - sm1.receivedBytes == 45); test(sm2.sentBytes - sm1.sentBytes == 25); cm1 = cm2; sm1 = sm2; byte[] bs = new byte[0]; metrics.opByteS(bs); cm2 = (IceMX.ConnectionMetrics)clientMetrics.getMetricsView("View", out timestamp)["Connection"][0]; sm2 = getServerConnectionMetrics(serverMetrics, sm1.sentBytes + cm2.receivedBytes - cm1.receivedBytes); long requestSz = cm2.sentBytes - cm1.sentBytes; long replySz = cm2.receivedBytes - cm1.receivedBytes; cm1 = cm2; sm1 = sm2; bs = new byte[456]; metrics.opByteS(bs); cm2 = (IceMX.ConnectionMetrics)clientMetrics.getMetricsView("View", out timestamp)["Connection"][0]; sm2 = getServerConnectionMetrics(serverMetrics, sm1.sentBytes + replySz); test(cm2.sentBytes - cm1.sentBytes == requestSz + bs.Length + 4); // 4 is for the seq variable size test(cm2.receivedBytes - cm1.receivedBytes == replySz); test(sm2.receivedBytes - sm1.receivedBytes == requestSz + bs.Length + 4); test(sm2.sentBytes - sm1.sentBytes == replySz); cm1 = cm2; sm1 = sm2; bs = new byte[1024 * 1024 * 10]; // Try with large amount of data which should be sent in several chunks metrics.opByteS(bs); cm2 = (IceMX.ConnectionMetrics)clientMetrics.getMetricsView("View", out timestamp)["Connection"][0]; sm2 = getServerConnectionMetrics(serverMetrics, sm1.sentBytes + replySz); test((cm2.sentBytes - cm1.sentBytes) == (requestSz + bs.Length + 4)); // 4 is for the seq variable size test((cm2.receivedBytes - cm1.receivedBytes) == replySz); test((sm2.receivedBytes - sm1.receivedBytes) == (requestSz + bs.Length + 4)); test((sm2.sentBytes - sm1.sentBytes) == replySz); props["IceMX.Metrics.View.Map.Connection.GroupBy"] = "state"; updateProps(clientProps, serverProps, update, props, "Connection"); map = toMap(serverMetrics.getMetricsView("View", out timestamp)["Connection"]); test(map["active"].current == 1); ControllerPrx controller = ControllerPrxHelper.checkedCast( communicator.stringToProxy("controller:default -p 12011")); controller.hold(); map = toMap(clientMetrics.getMetricsView("View", out timestamp)["Connection"]); test(map["active"].current == 1); map = toMap(serverMetrics.getMetricsView("View", out timestamp)["Connection"]); test(map["holding"].current == 1); metrics.ice_getConnection().close(false); map = toMap(clientMetrics.getMetricsView("View", out timestamp)["Connection"]); test(map["closing"].current == 1); map = toMap(serverMetrics.getMetricsView("View", out timestamp)["Connection"]); test(map["holding"].current == 1); controller.resume(); map = toMap(serverMetrics.getMetricsView("View", out timestamp)["Connection"]); test(map["holding"].current == 0); props["IceMX.Metrics.View.Map.Connection.GroupBy"] = "none"; updateProps(clientProps, serverProps, update, props, "Connection"); metrics.ice_getConnection().close(false); metrics.ice_timeout(500).ice_ping(); controller.hold(); try { ((MetricsPrx)metrics.ice_timeout(500)).opByteS(new byte[10000000]); test(false); } catch (Ice.TimeoutException) { } controller.resume(); cm1 = (IceMX.ConnectionMetrics)clientMetrics.getMetricsView("View", out timestamp)["Connection"][0]; while (true) { sm1 = (IceMX.ConnectionMetrics)serverMetrics.getMetricsView("View", out timestamp)["Connection"][0]; if (sm1.failures >= 2) { break; } Thread.Sleep(10); } test(cm1.failures == 2 && sm1.failures >= 2); checkFailure(clientMetrics, "Connection", cm1.id, "::Ice::TimeoutException", 1); checkFailure(clientMetrics, "Connection", cm1.id, "::Ice::ConnectTimeoutException", 1); checkFailure(serverMetrics, "Connection", sm1.id, "::Ice::ConnectionLostException", 0); MetricsPrx m = (MetricsPrx)metrics.ice_timeout(500).ice_connectionId("Con1"); m.ice_ping(); testAttribute(clientMetrics, clientProps, update, "Connection", "parent", "Communicator"); //testAttribute(clientMetrics, clientProps, update, "Connection", "id", ""); testAttribute(clientMetrics, clientProps, update, "Connection", "endpoint", endpoint + " -t 500"); testAttribute(clientMetrics, clientProps, update, "Connection", "endpointType", type); testAttribute(clientMetrics, clientProps, update, "Connection", "endpointIsDatagram", "False"); testAttribute(clientMetrics, clientProps, update, "Connection", "endpointIsSecure", isSecure); testAttribute(clientMetrics, clientProps, update, "Connection", "endpointTimeout", "500"); testAttribute(clientMetrics, clientProps, update, "Connection", "endpointCompress", "False"); testAttribute(clientMetrics, clientProps, update, "Connection", "endpointHost", "127.0.0.1"); testAttribute(clientMetrics, clientProps, update, "Connection", "endpointPort", "12010"); testAttribute(clientMetrics, clientProps, update, "Connection", "incoming", "False"); testAttribute(clientMetrics, clientProps, update, "Connection", "adapterName", ""); testAttribute(clientMetrics, clientProps, update, "Connection", "connectionId", "Con1"); testAttribute(clientMetrics, clientProps, update, "Connection", "localHost", "127.0.0.1"); //testAttribute(clientMetrics, clientProps, update, "Connection", "localPort", ""); testAttribute(clientMetrics, clientProps, update, "Connection", "remoteHost", "127.0.0.1"); testAttribute(clientMetrics, clientProps, update, "Connection", "remotePort", "12010"); testAttribute(clientMetrics, clientProps, update, "Connection", "mcastHost", ""); testAttribute(clientMetrics, clientProps, update, "Connection", "mcastPort", ""); m.ice_getConnection().close(false); waitForCurrent(clientMetrics, "View", "Connection", 0); waitForCurrent(serverMetrics, "View", "Connection", 0); WriteLine("ok"); Write("testing connection establishment metrics... "); Flush(); props["IceMX.Metrics.View.Map.ConnectionEstablishment.GroupBy"] = "id"; updateProps(clientProps, serverProps, update, props, "ConnectionEstablishment"); test(clientMetrics.getMetricsView("View", out timestamp)["ConnectionEstablishment"].Length == 0); metrics.ice_ping(); test(clientMetrics.getMetricsView("View", out timestamp)["ConnectionEstablishment"].Length == 1); IceMX.Metrics m1 = clientMetrics.getMetricsView("View", out timestamp)["ConnectionEstablishment"][0]; test(m1.current == 0 && m1.total == 1 && m1.id.Equals("127.0.0.1:12010")); metrics.ice_getConnection().close(false); controller.hold(); try { communicator.stringToProxy("test:tcp -p 12010 -h 127.0.0.1").ice_timeout(10).ice_ping(); test(false); } catch (Ice.ConnectTimeoutException) { } catch (Ice.LocalException) { test(false); } controller.resume(); test(clientMetrics.getMetricsView("View", out timestamp)["ConnectionEstablishment"].Length == 1); m1 = clientMetrics.getMetricsView("View", out timestamp)["ConnectionEstablishment"][0]; test(m1.id.Equals("127.0.0.1:12010") && m1.total == 3 && m1.failures == 2); checkFailure(clientMetrics, "ConnectionEstablishment", m1.id, "::Ice::ConnectTimeoutException", 2); System.Action c = () => { connect(metrics); }; testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "parent", "Communicator", c); testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "id", "127.0.0.1:12010", c); testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "endpoint", endpoint + " -t 60000", c); testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "endpointType", type, c); testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "endpointIsDatagram", "False", c); testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "endpointIsSecure", isSecure, c); testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "endpointTimeout", "60000", c); testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "endpointCompress", "False", c); testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "endpointHost", "127.0.0.1", c); testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "endpointPort", "12010", c); WriteLine("ok"); Write("testing endpoint lookup metrics... "); Flush(); props["IceMX.Metrics.View.Map.ConnectionEstablishment.GroupBy"] = "id"; updateProps(clientProps, serverProps, update, props, "EndpointLookup"); test(clientMetrics.getMetricsView("View", out timestamp)["EndpointLookup"].Length == 0); Ice.ObjectPrx prx = communicator.stringToProxy("metrics:default -p 12010 -h localhost -t infinite"); prx.ice_ping(); test(clientMetrics.getMetricsView("View", out timestamp)["EndpointLookup"].Length == 1); m1 = clientMetrics.getMetricsView("View", out timestamp)["EndpointLookup"][0]; test(m1.current <= 1 && m1.total == 1 && m1.id.Equals(prx.ice_getConnection().getEndpoint().ToString())); prx.ice_getConnection().close(false); bool dnsException = false; try { communicator.stringToProxy("test:tcp -t 500 -p 12010 -h unknownfoo.zeroc.com").ice_ping(); test(false); } catch (Ice.DNSException) { dnsException = true; } catch (Ice.LocalException) { // Some DNS servers don't fail on unknown DNS names. } test(clientMetrics.getMetricsView("View", out timestamp)["EndpointLookup"].Length == 2); m1 = clientMetrics.getMetricsView("View", out timestamp)["EndpointLookup"][0]; if (!m1.id.Equals("tcp -h unknownfoo.zeroc.com -p 12010 -t 500")) { m1 = clientMetrics.getMetricsView("View", out timestamp)["EndpointLookup"][1]; } test(m1.id.Equals("tcp -h unknownfoo.zeroc.com -p 12010 -t 500") && m1.total == 2 && (!dnsException || m1.failures == 2)); if (dnsException) { checkFailure(clientMetrics, "EndpointLookup", m1.id, "::Ice::DNSException", 2); } c = () => { connect(prx); }; testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "parent", "Communicator", c); testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "id", prx.ice_getConnection().getEndpoint().ToString(), c); testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "endpoint", prx.ice_getConnection().getEndpoint().ToString(), c); testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "endpointType", type, c); testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "endpointIsDatagram", "False", c); testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "endpointIsSecure", isSecure, c); testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "endpointTimeout", "-1", c); testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "endpointCompress", "False", c); testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "endpointHost", "localhost", c); testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "endpointPort", "12010", c); WriteLine("ok"); } Write("testing dispatch metrics... "); Flush(); props["IceMX.Metrics.View.Map.Dispatch.GroupBy"] = "operation"; updateProps(clientProps, serverProps, update, props, "Dispatch"); test(serverMetrics.getMetricsView("View", out timestamp)["Dispatch"].Length == 0); metrics.op(); try { metrics.opWithUserException(); test(false); } catch (UserEx) { } try { metrics.opWithRequestFailedException(); test(false); } catch (Ice.RequestFailedException) { } try { metrics.opWithLocalException(); test(false); } catch (Ice.LocalException) { } try { metrics.opWithUnknownException(); test(false); } catch (Ice.UnknownException) { } if (!collocated) { try { metrics.fail(); test(false); } catch (Ice.ConnectionLostException) { } } map = toMap(serverMetrics.getMetricsView("View", out timestamp)["Dispatch"]); test(!collocated ? map.Count == 6 : map.Count == 5); IceMX.DispatchMetrics dm1; dm1 = (IceMX.DispatchMetrics)map["op"]; test(dm1.current <= 1 && dm1.total == 1 && dm1.failures == 0 && dm1.userException == 0); test(dm1.size == 21 && dm1.replySize == 7); dm1 = (IceMX.DispatchMetrics)map["opWithUserException"]; test(dm1.current <= 1 && dm1.total == 1 && dm1.failures == 0 && dm1.userException == 1); test(dm1.size == 38 && dm1.replySize == 23); dm1 = (IceMX.DispatchMetrics)map["opWithLocalException"]; test(dm1.current <= 1 && dm1.total == 1 && dm1.failures == 1 && dm1.userException == 0); checkFailure(serverMetrics, "Dispatch", dm1.id, "::Ice::SyscallException", 1); test(dm1.size == 39 && dm1.replySize > 7); // Reply contains the exception stack depending on the OS. dm1 = (IceMX.DispatchMetrics)map["opWithRequestFailedException"]; test(dm1.current <= 1 && dm1.total == 1 && dm1.failures == 1 && dm1.userException == 0); checkFailure(serverMetrics, "Dispatch", dm1.id, "::Ice::ObjectNotExistException", 1); test(dm1.size == 47 && dm1.replySize == 40); dm1 = (IceMX.DispatchMetrics)map["opWithUnknownException"]; test(dm1.current <= 1 && dm1.total == 1 && dm1.failures == 1 && dm1.userException == 0); checkFailure(serverMetrics, "Dispatch", dm1.id, "System.ArgumentOutOfRangeException", 1); test(dm1.size == 41 && dm1.replySize > 7); // Reply contains the exception stack depending on the OS. System.Action op = () => { invokeOp(metrics); }; testAttribute(serverMetrics, serverProps, update, "Dispatch", "parent", "TestAdapter", op); testAttribute(serverMetrics, serverProps, update, "Dispatch", "id", "metrics [op]", op); if (!collocated) { testAttribute(serverMetrics, serverProps, update, "Dispatch", "endpoint", endpoint + " -t 60000", op); //testAttribute(serverMetrics, serverProps, update, "Dispatch", "connection", "", op); testAttribute(serverMetrics, serverProps, update, "Dispatch", "endpointType", type, op); testAttribute(serverMetrics, serverProps, update, "Dispatch", "endpointIsDatagram", "False", op); testAttribute(serverMetrics, serverProps, update, "Dispatch", "endpointIsSecure", isSecure, op); testAttribute(serverMetrics, serverProps, update, "Dispatch", "endpointTimeout", "60000", op); testAttribute(serverMetrics, serverProps, update, "Dispatch", "endpointCompress", "False", op); testAttribute(serverMetrics, serverProps, update, "Dispatch", "endpointHost", "127.0.0.1", op); testAttribute(serverMetrics, serverProps, update, "Dispatch", "endpointPort", "12010", op); testAttribute(serverMetrics, serverProps, update, "Dispatch", "incoming", "True", op); testAttribute(serverMetrics, serverProps, update, "Dispatch", "adapterName", "TestAdapter", op); testAttribute(serverMetrics, serverProps, update, "Dispatch", "connectionId", "", op); testAttribute(serverMetrics, serverProps, update, "Dispatch", "localHost", "127.0.0.1", op); testAttribute(serverMetrics, serverProps, update, "Dispatch", "localPort", "12010", op); testAttribute(serverMetrics, serverProps, update, "Dispatch", "remoteHost", "127.0.0.1", op); //testAttribute(serverMetrics, serverProps, update, "Dispatch", "remotePort", "12010", op); testAttribute(serverMetrics, serverProps, update, "Dispatch", "mcastHost", "", op); testAttribute(serverMetrics, serverProps, update, "Dispatch", "mcastPort", "", op); } testAttribute(serverMetrics, serverProps, update, "Dispatch", "operation", "op", op); testAttribute(serverMetrics, serverProps, update, "Dispatch", "identity", "metrics", op); testAttribute(serverMetrics, serverProps, update, "Dispatch", "facet", "", op); testAttribute(serverMetrics, serverProps, update, "Dispatch", "mode", "twoway", op); testAttribute(serverMetrics, serverProps, update, "Dispatch", "context.entry1", "test", op); testAttribute(serverMetrics, serverProps, update, "Dispatch", "context.entry2", "", op); testAttribute(serverMetrics, serverProps, update, "Dispatch", "context.entry3", "", op); WriteLine("ok"); Write("testing invocation metrics... "); Flush(); // // Tests for twoway // props["IceMX.Metrics.View.Map.Invocation.GroupBy"] = "operation"; props["IceMX.Metrics.View.Map.Invocation.Map.Remote.GroupBy"] = "localPort"; props["IceMX.Metrics.View.Map.Invocation.Map.Collocated.GroupBy"] = "id"; updateProps(clientProps, serverProps, update, props, "Invocation"); test(serverMetrics.getMetricsView("View", out timestamp)["Invocation"].Length == 0); Callback cb = new Callback(); metrics.op(); metrics.end_op(metrics.begin_op()); metrics.begin_op().whenCompleted(cb.response, cb.exception); cb.waitForResponse(); try { metrics.opWithUserException(); test(false); } catch (UserEx) { } try { metrics.end_opWithUserException(metrics.begin_opWithUserException()); test(false); } catch (UserEx) { } metrics.begin_opWithUserException().whenCompleted(cb.response, cb.exception); cb.waitForResponse(); try { metrics.opWithRequestFailedException(); test(false); } catch (Ice.RequestFailedException) { } try { metrics.end_opWithRequestFailedException(metrics.begin_opWithRequestFailedException()); test(false); } catch (Ice.RequestFailedException) { } metrics.begin_opWithRequestFailedException().whenCompleted(cb.response, cb.exception); cb.waitForResponse(); try { metrics.opWithLocalException(); test(false); } catch (Ice.LocalException) { } try { metrics.end_opWithLocalException(metrics.begin_opWithLocalException()); test(false); } catch (Ice.LocalException) { } metrics.begin_opWithLocalException().whenCompleted(cb.response, cb.exception); cb.waitForResponse(); try { metrics.opWithUnknownException(); test(false); } catch (Ice.UnknownException) { } try { metrics.end_opWithUnknownException(metrics.begin_opWithUnknownException()); test(false); } catch (Ice.UnknownException) { } metrics.begin_opWithUnknownException().whenCompleted(cb.response, cb.exception); cb.waitForResponse(); if (!collocated) { try { metrics.fail(); test(false); } catch (Ice.ConnectionLostException) { } try { metrics.end_fail(metrics.begin_fail()); test(false); } catch (Ice.ConnectionLostException) { } metrics.begin_fail().whenCompleted(cb.response, cb.exception); cb.waitForResponse(); } map = toMap(clientMetrics.getMetricsView("View", out timestamp)["Invocation"]); test(map.Count == (!collocated ? 6 : 5)); IceMX.InvocationMetrics im1; IceMX.ChildInvocationMetrics rim1; im1 = (IceMX.InvocationMetrics)map["op"]; test(im1.current <= 1 && im1.total == 3 && im1.failures == 0 && im1.retry == 0); test(!collocated ? im1.remotes.Length == 1 : im1.collocated.Length == 1); rim1 = (IceMX.ChildInvocationMetrics)(!collocated ? im1.remotes[0] : im1.collocated[0]); test(rim1.current == 0 && rim1.total == 3 && rim1.failures == 0); test(rim1.size == 63 && rim1.replySize == 21); im1 = (IceMX.InvocationMetrics)map["opWithUserException"]; test(im1.current <= 1 && im1.total == 3 && im1.failures == 0 && im1.retry == 0); test(!collocated ? im1.remotes.Length == 1 : im1.collocated.Length == 1); rim1 = (IceMX.ChildInvocationMetrics)(!collocated ? im1.remotes[0] : im1.collocated[0]); test(rim1.current == 0 && rim1.total == 3 && rim1.failures == 0); test(rim1.size == 114 && rim1.replySize == 69); test(im1.userException == 3); im1 = (IceMX.InvocationMetrics)map["opWithLocalException"]; test(im1.current <= 1 && im1.total == 3 && im1.failures == 3 && im1.retry == 0); test(!collocated ? im1.remotes.Length == 1 : im1.collocated.Length == 1); rim1 = (IceMX.ChildInvocationMetrics)(!collocated ? im1.remotes[0] : im1.collocated[0]); test(rim1.current == 0 && rim1.total == 3 && rim1.failures == 0); test(rim1.size == 117 && rim1.replySize > 7); checkFailure(clientMetrics, "Invocation", im1.id, "::Ice::UnknownLocalException", 3); im1 = (IceMX.InvocationMetrics)map["opWithRequestFailedException"]; test(im1.current <= 1 && im1.total == 3 && im1.failures == 3 && im1.retry == 0); test(!collocated ? im1.remotes.Length == 1 : im1.collocated.Length == 1); rim1 = (IceMX.ChildInvocationMetrics)(!collocated ? im1.remotes[0] : im1.collocated[0]); test(rim1.current == 0 && rim1.total == 3 && rim1.failures == 0); test(rim1.size == 141 && rim1.replySize == 120); checkFailure(clientMetrics, "Invocation", im1.id, "::Ice::ObjectNotExistException", 3); im1 = (IceMX.InvocationMetrics)map["opWithUnknownException"]; test(im1.current <= 1 && im1.total == 3 && im1.failures == 3 && im1.retry == 0); test(!collocated ? im1.remotes.Length == 1 : im1.collocated.Length == 1); rim1 = (IceMX.ChildInvocationMetrics)(!collocated ? im1.remotes[0] : im1.collocated[0]); test(rim1.current == 0 && rim1.total == 3 && rim1.failures == 0); test(rim1.size == 123 && rim1.replySize > 7); checkFailure(clientMetrics, "Invocation", im1.id, "::Ice::UnknownException", 3); if (!collocated) { im1 = (IceMX.InvocationMetrics)map["fail"]; test(im1.current <= 1 && im1.total == 3 && im1.failures == 3 && im1.retry == 3 && im1.remotes.Length == 6); test(im1.remotes[0].current == 0 && im1.remotes[0].total == 1 && im1.remotes[0].failures == 1); test(im1.remotes[1].current == 0 && im1.remotes[1].total == 1 && im1.remotes[1].failures == 1); test(im1.remotes[2].current == 0 && im1.remotes[2].total == 1 && im1.remotes[2].failures == 1); test(im1.remotes[3].current == 0 && im1.remotes[3].total == 1 && im1.remotes[3].failures == 1); test(im1.remotes[4].current == 0 && im1.remotes[4].total == 1 && im1.remotes[4].failures == 1); test(im1.remotes[5].current == 0 && im1.remotes[5].total == 1 && im1.remotes[5].failures == 1); checkFailure(clientMetrics, "Invocation", im1.id, "::Ice::ConnectionLostException", 3); } testAttribute(clientMetrics, clientProps, update, "Invocation", "parent", "Communicator", op); testAttribute(clientMetrics, clientProps, update, "Invocation", "id", "metrics -t -e 1.1 [op]", op); testAttribute(clientMetrics, clientProps, update, "Invocation", "operation", "op", op); testAttribute(clientMetrics, clientProps, update, "Invocation", "identity", "metrics", op); testAttribute(clientMetrics, clientProps, update, "Invocation", "facet", "", op); testAttribute(clientMetrics, clientProps, update, "Invocation", "encoding", "1.1", op); testAttribute(clientMetrics, clientProps, update, "Invocation", "mode", "twoway", op); testAttribute(clientMetrics, clientProps, update, "Invocation", "proxy", "metrics -t -e 1.1:" + endpoint + " -t 60000", op); testAttribute(clientMetrics, clientProps, update, "Invocation", "context.entry1", "test", op); testAttribute(clientMetrics, clientProps, update, "Invocation", "context.entry2", "", op); testAttribute(clientMetrics, clientProps, update, "Invocation", "context.entry3", "", op); // // Oneway tests // clearView(clientProps, serverProps, update); props["IceMX.Metrics.View.Map.Invocation.GroupBy"] = "operation"; props["IceMX.Metrics.View.Map.Invocation.Map.Remote.GroupBy"] = "localPort"; updateProps(clientProps, serverProps, update, props, "Invocation"); MetricsPrx metricsOneway = (MetricsPrx)metrics.ice_oneway(); metricsOneway.op(); metricsOneway.end_op(metricsOneway.begin_op()); metricsOneway.begin_op().whenCompleted(cb.response, cb.exception).waitForSent(); map = toMap(clientMetrics.getMetricsView("View", out timestamp)["Invocation"]); test(map.Count == 1); im1 = (IceMX.InvocationMetrics)map["op"]; test(im1.current <= 1 && im1.total == 3 && im1.failures == 0 && im1.retry == 0); test(!collocated ? (im1.remotes.Length == 1) : (im1.collocated.Length == 1)); rim1 = (IceMX.ChildInvocationMetrics)(!collocated ? im1.remotes[0] : im1.collocated[0]); test(rim1.current <= 1 && rim1.total == 3 && rim1.failures == 0); test(rim1.size == 63 && rim1.replySize == 0); testAttribute(clientMetrics, clientProps, update, "Invocation", "mode", "oneway", () => { invokeOp(metricsOneway); }); // // Batch oneway tests // props["IceMX.Metrics.View.Map.Invocation.GroupBy"] = "operation"; props["IceMX.Metrics.View.Map.Invocation.Map.Remote.GroupBy"] = "localPort"; updateProps(clientProps, serverProps, update, props, "Invocation"); MetricsPrx metricsBatchOneway = (MetricsPrx)metrics.ice_batchOneway(); metricsBatchOneway.op(); metricsBatchOneway.end_op(metricsBatchOneway.begin_op()); //metricsBatchOneway.begin_op().whenCompleted(cb.response, cb.exception).waitForSent(); map = toMap(clientMetrics.getMetricsView("View", out timestamp)["Invocation"]); test(map.Count == 1); im1 = (IceMX.InvocationMetrics)map["op"]; test(im1.current == 0 && im1.total == 2 && im1.failures == 0 && im1.retry == 0); test(im1.remotes.Length == 0); testAttribute(clientMetrics, clientProps, update, "Invocation", "mode", "batch-oneway", () => { invokeOp(metricsBatchOneway); }); WriteLine("ok"); Write("testing metrics view enable/disable..."); Flush(); string[] disabledViews; props["IceMX.Metrics.View.GroupBy"] = "none"; props["IceMX.Metrics.View.Disabled"] = "0"; updateProps(clientProps, serverProps, update, props, "Thread"); test(clientMetrics.getMetricsView("View", out timestamp)["Thread"].Length != 0); test(clientMetrics.getMetricsViewNames(out disabledViews).Length == 1 && disabledViews.Length == 0); props["IceMX.Metrics.View.Disabled"] = "1"; updateProps(clientProps, serverProps, update, props, "Thread"); test(!clientMetrics.getMetricsView("View", out timestamp).ContainsKey("Thread")); test(clientMetrics.getMetricsViewNames(out disabledViews).Length == 0 && disabledViews.Length == 1); clientMetrics.enableMetricsView("View"); test(clientMetrics.getMetricsView("View", out timestamp)["Thread"].Length != 0); test(clientMetrics.getMetricsViewNames(out disabledViews).Length == 1 && disabledViews.Length == 0); clientMetrics.disableMetricsView("View"); test(!clientMetrics.getMetricsView("View", out timestamp).ContainsKey("Thread")); test(clientMetrics.getMetricsViewNames(out disabledViews).Length == 0 && disabledViews.Length == 1); try { clientMetrics.enableMetricsView("UnknownView"); } catch (IceMX.UnknownMetricsView) { } WriteLine("ok"); Write("testing instrumentation observer delegate... "); Flush(); test(obsv.threadObserver.getTotal() > 0); if (!collocated) { test(obsv.connectionObserver.getTotal() > 0); test(obsv.connectionEstablishmentObserver.getTotal() > 0); test(obsv.endpointLookupObserver.getTotal() > 0); test(obsv.invocationObserver.remoteObserver.getTotal() > 0); } else { test(obsv.invocationObserver.collocatedObserver.getTotal() > 0); } test(obsv.dispatchObserver.getTotal() > 0); test(obsv.invocationObserver.getTotal() > 0); test(obsv.threadObserver.getCurrent() > 0); if (!collocated) { test(obsv.connectionObserver.getCurrent() > 0); test(obsv.connectionEstablishmentObserver.getCurrent() == 0); test(obsv.endpointLookupObserver.getCurrent() == 0); test(obsv.invocationObserver.remoteObserver.getCurrent() == 0); } else { for (int i = 0; i < 10; ++i) { if (obsv.invocationObserver.collocatedObserver.getCurrent() > 0) { Thread.Sleep(10); } else { break; } } test(obsv.invocationObserver.collocatedObserver.getCurrent() == 0); } test(obsv.dispatchObserver.getCurrent() == 0); test(obsv.invocationObserver.getCurrent() == 0); test(obsv.threadObserver.getFailedCount() == 0); if (!collocated) { test(obsv.connectionObserver.getFailedCount() > 0); test(obsv.connectionEstablishmentObserver.getFailedCount() > 0); test(obsv.endpointLookupObserver.getFailedCount() > 0); test(obsv.invocationObserver.remoteObserver.getFailedCount() > 0); } //test(obsv.dispatchObserver.getFailedCount() > 0); test(obsv.invocationObserver.getFailedCount() > 0); if (!collocated) { test(obsv.threadObserver.states > 0); test(obsv.connectionObserver.received > 0 && obsv.connectionObserver.sent > 0); test(obsv.invocationObserver.retriedCount > 0); test(obsv.invocationObserver.remoteObserver.replySize > 0); } else { test(obsv.invocationObserver.collocatedObserver.replySize > 0); } //test(obsv.dispatchObserver.userExceptionCount > 0); test(obsv.invocationObserver.userExceptionCount > 0); WriteLine("ok"); return(metrics); }
public static void allTests(Ice.Communicator 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"); string defaultHost = communicator.getProperties().getProperty("Ice.Default.Host"); 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.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(defaultHost)); test(tcpEndpoint.port > 0); test(tcpEndpoint.timeout == 15000); Ice.UDPEndpointInfo udpEndpoint = (Ice.UDPEndpointInfo)endpoints[1].getInfo(); test(udpEndpoint.host.Equals(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(endpoints.Length >= 1); publishedEndpoints = adapter.getPublishedEndpoints(); test(publishedEndpoints.Length == 1); foreach (Ice.Endpoint endpoint in endpoints) { tcpEndpoint = getTCPEndpointInfo(endpoint.getInfo()); test(tcpEndpoint.port == 12020); } tcpEndpoint = getTCPEndpointInfo(publishedEndpoints[0].getInfo()); test(tcpEndpoint.host.Equals("127.0.0.1")); test(tcpEndpoint.port == 12020); adapter.destroy(); } WriteLine("ok"); Ice.ObjectPrx @base = communicator.stringToProxy("test:default -p 12010:udp -p 12010"); TestIntfPrx testIntf = TestIntfPrxHelper.checkedCast(@base); Write("test connection endpoint information... "); Flush(); { Ice.EndpointInfo info = @base.ice_getConnection().getEndpoint().getInfo(); Ice.TCPEndpointInfo tcpinfo = getTCPEndpointInfo(info); test(tcpinfo.port == 12010); 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 == 12010); 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 == 12010); 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 == 12010); 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(TestCommon.Application app) { Ice.Communicator communicator = app.communicator(); string sref = "test:" + app.getTestEndpoint(0); Ice.ObjectPrx obj = communicator.stringToProxy(sref); test(obj != null); Test.TestIntfPrx p = Test.TestIntfPrxHelper.uncheckedCast(obj); sref = "testController:" + app.getTestEndpoint(1); obj = communicator.stringToProxy(sref); test(obj != null); Test.TestIntfControllerPrx testController = Test.TestIntfControllerPrxHelper.uncheckedCast(obj); Write("testing dispatcher... "); Flush(); { p.op(); Callback cb = new Callback(); p.begin_op().whenCompleted(cb.response, cb.exception); cb.check(); TestIntfPrx i = (TestIntfPrx)p.ice_adapterId("dummy"); i.begin_op().whenCompleted(cb.exception); cb.check(); // // Expect InvocationTimeoutException. // { Test.TestIntfPrx to = Test.TestIntfPrxHelper.uncheckedCast(p.ice_invocationTimeout(250)); to.begin_sleep(500).whenCompleted( () => { test(false); }, (Ice.Exception ex) => { test(ex is Ice.InvocationTimeoutException); test(Dispatcher.isDispatcherThread()); cb.called(); }); cb.check(); } testController.holdAdapter(); Test.Callback_TestIntf_opWithPayload resp = cb.payload; Ice.ExceptionCallback excb = cb.ignoreEx; Ice.SentCallback scb = cb.sent; byte[] seq = new byte[10 * 1024]; (new System.Random()).NextBytes(seq); Ice.AsyncResult r; while ((r = p.begin_opWithPayload(seq).whenCompleted(resp, excb).whenSent(scb)).sentSynchronously()) { ; } testController.resumeAdapter(); r.waitForCompleted(); } WriteLine("ok"); Write("testing dispatcher with continuations... "); Flush(); { p.op(); Callback cb = new Callback(); System.Action <Task> continuation = (Task previous) => { try { previous.Wait(); cb.response(); } catch (System.AggregateException ex) { cb.exception((Ice.Exception)ex.InnerException); } }; // We use sleepAsync instead of opAsync to ensure the response isn't received before // we setup the continuation var t = p.sleepAsync(100).ContinueWith(continuation, TaskContinuationOptions.ExecuteSynchronously); t.Wait(); cb.check(); var i = (TestIntfPrx)p.ice_adapterId("dummy"); i.sleepAsync(100).ContinueWith(continuation, TaskContinuationOptions.ExecuteSynchronously).Wait(); cb.check(); // // Expect InvocationTimeoutException. // { Test.TestIntfPrx to = Test.TestIntfPrxHelper.uncheckedCast(p.ice_invocationTimeout(250)); to.sleepAsync(500).ContinueWith( previous => { try { previous.Wait(); test(false); } catch (System.AggregateException ex) { test(ex.InnerException is Ice.InvocationTimeoutException); test(Dispatcher.isDispatcherThread()); } }, TaskContinuationOptions.ExecuteSynchronously).Wait(); } // // Repeat using the proxy scheduler in this case we don't need to call sleepAsync, continuations // are waranted to run with the dispatcher even if not executed synchronously. // t = p.opAsync().ContinueWith(continuation, p.ice_scheduler()); t.Wait(); cb.check(); i.opAsync().ContinueWith(continuation, i.ice_scheduler()).Wait(); cb.check(); // // Expect InvocationTimeoutException. // { Test.TestIntfPrx to = Test.TestIntfPrxHelper.uncheckedCast(p.ice_invocationTimeout(250)); to.sleepAsync(500).ContinueWith( previous => { try { previous.Wait(); test(false); } catch (System.AggregateException ex) { test(ex.InnerException is Ice.InvocationTimeoutException); test(Dispatcher.isDispatcherThread()); } }, p.ice_scheduler()).Wait(); } testController.holdAdapter(); System.Action <Task> continuation2 = (Task previous) => { test(Dispatcher.isDispatcherThread()); try { previous.Wait(); } catch (System.AggregateException ex) { test(ex.InnerException is Ice.CommunicatorDestroyedException); } }; byte[] seq = new byte[10 * 1024]; (new System.Random()).NextBytes(seq); Progress sentSynchronously; do { sentSynchronously = new Progress(); t = p.opWithPayloadAsync(seq, progress: sentSynchronously).ContinueWith(continuation2, TaskContinuationOptions.ExecuteSynchronously); }while(sentSynchronously.getResult()); testController.resumeAdapter(); t.Wait(); } WriteLine("ok"); Write("testing dispatcher with async/await... "); Flush(); p.opAsync().ContinueWith(async previous => // Execute the code below from the Ice client thread pool { await p.opAsync(); test(Dispatcher.isDispatcherThread()); try { TestIntfPrx i = (TestIntfPrx)p.ice_adapterId("dummy"); await i.opAsync(); test(false); } catch (Exception) { test(Dispatcher.isDispatcherThread()); } Test.TestIntfPrx to = Test.TestIntfPrxHelper.uncheckedCast(p.ice_invocationTimeout(250)); try { await to.sleepAsync(500); test(false); } catch (Ice.InvocationTimeoutException) { test(Dispatcher.isDispatcherThread()); } }, TaskContinuationOptions.ExecuteSynchronously).Wait(); WriteLine("ok"); p.shutdown(); }
public static Test.MyClassPrx allTests(global::Test.TestHelper helper) { Ice.Communicator communicator = helper.communicator(); Ice.ObjectPrx baseProxy = communicator.stringToProxy("test:" + helper.getTestEndpoint(0)); var cl = Test.MyClassPrxHelper.checkedCast(baseProxy); var oneway = Test.MyClassPrxHelper.uncheckedCast(cl.ice_oneway()); var batchOneway = Test.MyClassPrxHelper.uncheckedCast(cl.ice_batchOneway()); var output = helper.getWriter(); output.Write("testing ice_invoke... "); output.Flush(); { byte[] inEncaps, outEncaps; if (!oneway.ice_invoke("opOneway", Ice.OperationMode.Normal, null, out outEncaps)) { test(false); } test(batchOneway.ice_invoke("opOneway", Ice.OperationMode.Normal, null, out outEncaps)); test(batchOneway.ice_invoke("opOneway", Ice.OperationMode.Normal, null, out outEncaps)); test(batchOneway.ice_invoke("opOneway", Ice.OperationMode.Normal, null, out outEncaps)); test(batchOneway.ice_invoke("opOneway", Ice.OperationMode.Normal, null, out outEncaps)); batchOneway.ice_flushBatchRequests(); Ice.OutputStream outS = new Ice.OutputStream(communicator); outS.startEncapsulation(); outS.writeString(testString); outS.endEncapsulation(); inEncaps = outS.finished(); if (cl.ice_invoke("opString", Ice.OperationMode.Normal, inEncaps, out outEncaps)) { Ice.InputStream inS = new Ice.InputStream(communicator, outEncaps); inS.startEncapsulation(); string s = inS.readString(); test(s.Equals(testString)); s = inS.readString(); inS.endEncapsulation(); test(s.Equals(testString)); } else { test(false); } } for (int i = 0; i < 2; ++i) { byte[] outEncaps; Dictionary <string, string> ctx = null; if (i == 1) { ctx = new Dictionary <string, string>(); ctx["raise"] = ""; } if (cl.ice_invoke("opException", Ice.OperationMode.Normal, null, out outEncaps, ctx)) { test(false); } else { Ice.InputStream inS = new Ice.InputStream(communicator, outEncaps); inS.startEncapsulation(); try { inS.throwException(); } catch (Test.MyException) { inS.endEncapsulation(); } catch (Exception) { test(false); } } } output.WriteLine("ok"); output.Write("testing asynchronous ice_invoke with Async Task API... "); output.Flush(); { try { oneway.ice_invokeAsync("opOneway", Ice.OperationMode.Normal, null).Wait(); } catch (Exception) { test(false); } Ice.OutputStream outS = new Ice.OutputStream(communicator); outS.startEncapsulation(); outS.writeString(testString); outS.endEncapsulation(); byte[] inEncaps = outS.finished(); // begin_ice_invoke with no callback var result = cl.ice_invokeAsync("opString", Ice.OperationMode.Normal, inEncaps).Result; if (result.returnValue) { Ice.InputStream inS = new Ice.InputStream(communicator, result.outEncaps); inS.startEncapsulation(); string s = inS.readString(); test(s.Equals(testString)); s = inS.readString(); inS.endEncapsulation(); test(s.Equals(testString)); } else { test(false); } } { var result = cl.ice_invokeAsync("opException", Ice.OperationMode.Normal, null).Result; if (result.returnValue) { test(false); } else { Ice.InputStream inS = new Ice.InputStream(communicator, result.outEncaps); inS.startEncapsulation(); try { inS.throwException(); } catch (Test.MyException) { inS.endEncapsulation(); } catch (Exception) { test(false); } } } output.WriteLine("ok"); output.Write("testing asynchronous ice_invoke with AsyncResult API... "); output.Flush(); { byte[] inEncaps, outEncaps; Ice.AsyncResult result = oneway.begin_ice_invoke("opOneway", Ice.OperationMode.Normal, null); if (!oneway.end_ice_invoke(out outEncaps, result)) { test(false); } Ice.OutputStream outS = new Ice.OutputStream(communicator); outS.startEncapsulation(); outS.writeString(testString); outS.endEncapsulation(); inEncaps = outS.finished(); // begin_ice_invoke with no callback result = cl.begin_ice_invoke("opString", Ice.OperationMode.Normal, inEncaps); if (cl.end_ice_invoke(out outEncaps, result)) { Ice.InputStream inS = new Ice.InputStream(communicator, outEncaps); inS.startEncapsulation(); string s = inS.readString(); test(s.Equals(testString)); s = inS.readString(); inS.endEncapsulation(); test(s.Equals(testString)); } else { test(false); } // begin_ice_invoke with Callback Callback cb = new Callback(communicator, false); cl.begin_ice_invoke("opString", Ice.OperationMode.Normal, inEncaps, cb.opString, null); cb.check(); // begin_ice_invoke with Callback with cookie cb = new Callback(communicator, true); cl.begin_ice_invoke("opString", Ice.OperationMode.Normal, inEncaps, cb.opString, new Cookie()); cb.check(); // begin_ice_invoke with Callback_Object_ice_invoke cb = new Callback(communicator, true); cl.begin_ice_invoke("opString", Ice.OperationMode.Normal, inEncaps).whenCompleted(cb.opStringNC, null); cb.check(); } { // begin_ice_invoke with no callback Ice.AsyncResult result = cl.begin_ice_invoke("opException", Ice.OperationMode.Normal, null); byte[] outEncaps; if (cl.end_ice_invoke(out outEncaps, result)) { test(false); } else { Ice.InputStream inS = new Ice.InputStream(communicator, outEncaps); inS.startEncapsulation(); try { inS.throwException(); } catch (Test.MyException) { inS.endEncapsulation(); } catch (Exception) { test(false); } } // begin_ice_invoke with Callback Callback cb = new Callback(communicator, false); cl.begin_ice_invoke("opException", Ice.OperationMode.Normal, null, cb.opException, null); cb.check(); // begin_ice_invoke with Callback with cookie cb = new Callback(communicator, true); cl.begin_ice_invoke("opException", Ice.OperationMode.Normal, null, cb.opException, new Cookie()); cb.check(); // begin_ice_invoke with Callback_Object_ice_invoke cb = new Callback(communicator, true); cl.begin_ice_invoke("opException", Ice.OperationMode.Normal, null).whenCompleted(cb.opExceptionNC, null); cb.check(); } output.WriteLine("ok"); return(cl); }
public static Test.BackgroundPrx allTests(Ice.Communicator communicator) { string sref = "background:default -p 12010"; Ice.ObjectPrx obj = communicator.stringToProxy(sref); test(obj != null); BackgroundPrx background = BackgroundPrxHelper.uncheckedCast(obj); sref = "backgroundController:tcp -p 12011"; obj = communicator.stringToProxy(sref); test(obj != null); BackgroundControllerPrx backgroundController = BackgroundControllerPrxHelper.uncheckedCast(obj); Configuration configuration = Configuration.getInstance(); Console.Write("testing connect... "); Console.Out.Flush(); { connectTests(configuration, background); } Console.Out.WriteLine("ok"); Console.Write("testing initialization... "); Console.Out.Flush(); { initializeTests(configuration, background, backgroundController); } Console.Out.WriteLine("ok"); Console.Write("testing connection validation... "); Console.Out.Flush(); { validationTests(configuration, background, backgroundController); } Console.Out.WriteLine("ok"); Console.Write("testing read/write... "); Console.Out.Flush(); { readWriteTests(configuration, background, backgroundController); } Console.Out.WriteLine("ok"); Console.Write("testing locator... "); Console.Out.Flush(); { Ice.LocatorPrx locator; obj = communicator.stringToProxy("locator:default -p 12010").ice_invocationTimeout(250); locator = Ice.LocatorPrxHelper.uncheckedCast(obj); obj = communicator.stringToProxy("background@Test").ice_locator(locator).ice_oneway(); backgroundController.pauseCall("findAdapterById"); try { obj.ice_ping(); test(false); } catch (Ice.TimeoutException) { } backgroundController.resumeCall("findAdapterById"); obj = communicator.stringToProxy("locator:default -p 12010"); locator = Ice.LocatorPrxHelper.uncheckedCast(obj); obj = obj.ice_locator(locator); obj.ice_ping(); obj = communicator.stringToProxy("background@Test").ice_locator(locator); BackgroundPrx bg = BackgroundPrxHelper.uncheckedCast(obj); backgroundController.pauseCall("findAdapterById"); Ice.AsyncResult r1 = bg.begin_op(); Ice.AsyncResult r2 = bg.begin_op(); test(!r1.IsCompleted); test(!r2.IsCompleted); backgroundController.resumeCall("findAdapterById"); bg.end_op(r1); bg.end_op(r2); test(r1.IsCompleted); test(r2.IsCompleted); } Console.Out.WriteLine("ok"); Console.Write("testing router... "); Console.Out.Flush(); { Ice.RouterPrx router; obj = communicator.stringToProxy("router:default -p 12010").ice_invocationTimeout(250); router = Ice.RouterPrxHelper.uncheckedCast(obj); obj = communicator.stringToProxy("background@Test").ice_router(router).ice_oneway(); backgroundController.pauseCall("getClientProxy"); try { obj.ice_ping(); test(false); } catch (Ice.TimeoutException) { } backgroundController.resumeCall("getClientProxy"); obj = communicator.stringToProxy("router:default -p 12010"); router = Ice.RouterPrxHelper.uncheckedCast(obj); obj = communicator.stringToProxy("background@Test").ice_router(router); BackgroundPrx bg = BackgroundPrxHelper.uncheckedCast(obj); test(bg.ice_getRouter() != null); backgroundController.pauseCall("getClientProxy"); Ice.AsyncResult r1 = bg.begin_op(); Ice.AsyncResult r2 = bg.begin_op(); test(!r1.IsCompleted); test(!r2.IsCompleted); backgroundController.resumeCall("getClientProxy"); bg.end_op(r1); bg.end_op(r2); test(r1.IsCompleted); test(r2.IsCompleted); } Console.Out.WriteLine("ok"); bool ws = communicator.getProperties().getProperty("Ice.Default.Protocol").Equals("test-ws"); bool wss = communicator.getProperties().getProperty("Ice.Default.Protocol").Equals("test-wss"); if (!ws && !wss) { Console.Write("testing buffered transport... "); Console.Out.Flush(); configuration.buffered(true); backgroundController.buffered(true); background.begin_op(); background.ice_getCachedConnection().close(true); background.begin_op(); OpAMICallback cb = new OpAMICallback(); List <Ice.AsyncResult> results = new List <Ice.AsyncResult>(); for (int i = 0; i < 10000; ++i) { Ice.AsyncResult r = background.begin_op().whenCompleted(cb.responseNoOp, cb.noException); results.Add(r); if (i % 50 == 0) { backgroundController.holdAdapter(); backgroundController.resumeAdapter(); } if (i % 100 == 0) { r.waitForCompleted(); } } foreach (Ice.AsyncResult r in results) { r.waitForCompleted(); } Console.Out.WriteLine("ok"); } return(background); }
internal AddProxiesCallback(RouterInfo info, Ice.ObjectPrx prx, AddProxyCallback callback) { _info = info; _prx = prx; _callback = callback; }
allTests(TestCommon.Application app, Ice.Communicator communicator2, string rf) { Ice.Communicator communicator = app.communicator(); Write("testing stringToProxy... "); Flush(); Ice.ObjectPrx base1 = communicator.stringToProxy(rf); test(base1 != null); Ice.ObjectPrx base2 = communicator.stringToProxy(rf); test(base2 != null); WriteLine("ok"); Write("testing checked cast... "); Flush(); Test.RetryPrx retry1 = Test.RetryPrxHelper.checkedCast(base1); test(retry1 != null); test(retry1.Equals(base1)); Test.RetryPrx retry2 = Test.RetryPrxHelper.checkedCast(base2); test(retry2 != null); test(retry2.Equals(base2)); WriteLine("ok"); Write("calling regular operation with first proxy... "); Flush(); retry1.op(false); WriteLine("ok"); Instrumentation.testInvocationCount(3); Write("calling operation to kill connection with second proxy... "); Flush(); try { retry2.op(true); test(false); } catch (Ice.UnknownLocalException) { // Expected with collocation } catch (Ice.ConnectionLostException) { } Instrumentation.testInvocationCount(1); Instrumentation.testFailureCount(1); Instrumentation.testRetryCount(0); WriteLine("ok"); Write("calling regular operation with first proxy again... "); Flush(); retry1.op(false); Instrumentation.testInvocationCount(1); Instrumentation.testFailureCount(0); Instrumentation.testRetryCount(0); WriteLine("ok"); Callback cb = new Callback(); Write("calling regular AMI operation with first proxy... "); retry1.begin_op(false).whenCompleted( () => { cb.called(); }, (Ice.Exception ex) => { test(false); }); cb.check(); Instrumentation.testInvocationCount(1); Instrumentation.testFailureCount(0); Instrumentation.testRetryCount(0); WriteLine("ok"); Write("calling AMI operation to kill connection with second proxy... "); retry2.begin_op(true).whenCompleted( () => { test(false); }, (Ice.Exception ex) => { test(ex is Ice.ConnectionLostException || ex is Ice.UnknownLocalException); cb.called(); }); cb.check(); Instrumentation.testInvocationCount(1); Instrumentation.testFailureCount(1); Instrumentation.testRetryCount(0); WriteLine("ok"); Write("calling regular AMI operation with first proxy again... "); retry1.begin_op(false).whenCompleted( () => { cb.called(); }, (Ice.Exception ex) => { test(false); }); cb.check(); Instrumentation.testInvocationCount(1); Instrumentation.testFailureCount(0); Instrumentation.testRetryCount(0); WriteLine("ok"); Write("testing idempotent operation... "); test(retry1.opIdempotent(4) == 4); Instrumentation.testInvocationCount(1); Instrumentation.testFailureCount(0); Instrumentation.testRetryCount(4); test(retry1.end_opIdempotent(retry1.begin_opIdempotent(4)) == 4); Instrumentation.testInvocationCount(1); Instrumentation.testFailureCount(0); Instrumentation.testRetryCount(4); WriteLine("ok"); Write("testing non-idempotent operation... "); try { retry1.opNotIdempotent(); test(false); } catch (Ice.LocalException) { } Instrumentation.testInvocationCount(1); Instrumentation.testFailureCount(1); Instrumentation.testRetryCount(0); try { retry1.end_opNotIdempotent(retry1.begin_opNotIdempotent()); test(false); } catch (Ice.LocalException) { } Instrumentation.testInvocationCount(1); Instrumentation.testFailureCount(1); Instrumentation.testRetryCount(0); WriteLine("ok"); if (retry1.ice_getConnection() == null) { Instrumentation.testInvocationCount(1); Write("testing system exception... "); try { retry1.opSystemException(); test(false); } catch (SystemFailure) { } Instrumentation.testInvocationCount(1); Instrumentation.testFailureCount(1); Instrumentation.testRetryCount(0); try { retry1.end_opSystemException(retry1.begin_opSystemException()); test(false); } catch (SystemFailure) { } Instrumentation.testInvocationCount(1); Instrumentation.testFailureCount(1); Instrumentation.testRetryCount(0); WriteLine("ok"); } Write("testing invocation timeout and retries... "); Flush(); retry2 = Test.RetryPrxHelper.checkedCast(communicator2.stringToProxy(retry1.ToString())); try { // No more than 2 retries before timeout kicks-in ((Test.RetryPrx)retry2.ice_invocationTimeout(500)).opIdempotent(4); test(false); } catch (Ice.InvocationTimeoutException) { Instrumentation.testRetryCount(2); retry2.opIdempotent(-1); // Reset the counter Instrumentation.testRetryCount(-1); } try { // No more than 2 retries before timeout kicks-in Test.RetryPrx prx = (Test.RetryPrx)retry2.ice_invocationTimeout(500); prx.end_opIdempotent(prx.begin_opIdempotent(4)); test(false); } catch (Ice.InvocationTimeoutException) { Instrumentation.testRetryCount(2); retry2.opIdempotent(-1); // Reset the counter Instrumentation.testRetryCount(-1); } WriteLine("ok"); return(retry1); }
protected void register(Ice.Object servant, bool icegrid = true) { Servant = servant; //logger.Info("registering: " + Servant.ice_id()); Proxy = IceApp.register(Name, Servant, icegrid); }
internal static void batchOneways(Test.MyClassPrx p) { byte[] bs1 = new byte[10 * 1024]; Test.MyClassPrx batch = Test.MyClassPrxHelper.uncheckedCast(p.ice_batchOneway()); batch.ice_flushBatchRequests(); // Empty flush p.opByteSOnewayCallCount(); // Reset the call count for (int i = 0; i < 30; ++i) { try { batch.opByteSOneway(bs1); test(true); } catch (Ice.MemoryLimitException) { test(false); } } int count = 0; while (count < 27) // 3 * 9 requests auto-flushed. { count += p.opByteSOnewayCallCount(); System.Threading.Thread.Sleep(10); } if (batch.ice_getConnection() != null) { Test.MyClassPrx batch1 = Test.MyClassPrxHelper.uncheckedCast(p.ice_batchOneway()); Test.MyClassPrx batch2 = Test.MyClassPrxHelper.uncheckedCast(p.ice_batchOneway()); batch1.ice_ping(); batch2.ice_ping(); batch1.ice_flushBatchRequests(); batch1.ice_getConnection().close(Ice.ConnectionClose.GracefullyWithWait); batch1.ice_ping(); batch2.ice_ping(); batch1.ice_getConnection(); batch2.ice_getConnection(); batch1.ice_ping(); batch1.ice_getConnection().close(Ice.ConnectionClose.GracefullyWithWait); batch1.ice_ping(); batch2.ice_ping(); } Ice.Identity identity = new Ice.Identity(); identity.name = "invalid"; Ice.ObjectPrx batch3 = batch.ice_identity(identity); batch3.ice_ping(); batch3.ice_flushBatchRequests(); // Make sure that a bogus batch request doesn't cause troubles to other ones. batch3.ice_ping(); batch.ice_ping(); batch.ice_flushBatchRequests(); batch.ice_ping(); if (batch.ice_getConnection() != null) { Ice.InitializationData initData = new Ice.InitializationData(); initData.properties = p.ice_getCommunicator().getProperties().ice_clone_(); BatchRequestInterceptorI interceptor = new BatchRequestInterceptorI(); initData.batchRequestInterceptor = interceptor.enqueue; Ice.Communicator ic = Ice.Util.initialize(initData); batch = Test.MyClassPrxHelper.uncheckedCast(ic.stringToProxy(p.ToString()).ice_batchOneway()); test(interceptor.count() == 0); batch.ice_ping(); batch.ice_ping(); batch.ice_ping(); test(interceptor.count() == 0); interceptor.setEnqueue(true); batch.ice_ping(); batch.ice_ping(); batch.ice_ping(); test(interceptor.count() == 3); batch.ice_flushBatchRequests(); batch.ice_ping(); test(interceptor.count() == 1); batch.opByteSOneway(bs1); test(interceptor.count() == 2); batch.opByteSOneway(bs1); test(interceptor.count() == 3); batch.opByteSOneway(bs1); // This should trigger the flush batch.ice_ping(); test(interceptor.count() == 2); ic.destroy(); } p.ice_ping(); if (p.ice_getConnection() != null && p.ice_getCommunicator().getProperties().getProperty("Ice.Override.Compress").Equals("")) { Ice.ObjectPrx prx = p.ice_getConnection().createProxy(p.ice_getIdentity()).ice_batchOneway(); Test.MyClassPrx batchC1 = Test.MyClassPrxHelper.uncheckedCast(prx.ice_compress(false)); Test.MyClassPrx batchC2 = Test.MyClassPrxHelper.uncheckedCast(prx.ice_compress(true)); Test.MyClassPrx batchC3 = Test.MyClassPrxHelper.uncheckedCast(prx.ice_identity(identity)); batchC1.opByteSOneway(bs1); batchC1.opByteSOneway(bs1); batchC1.opByteSOneway(bs1); batchC1.ice_getConnection().flushBatchRequests(Ice.CompressBatch.Yes); batchC2.opByteSOneway(bs1); batchC2.opByteSOneway(bs1); batchC2.opByteSOneway(bs1); batchC1.ice_getConnection().flushBatchRequests(Ice.CompressBatch.No); batchC1.opByteSOneway(bs1); batchC1.opByteSOneway(bs1); batchC1.opByteSOneway(bs1); batchC1.ice_getConnection().flushBatchRequests(Ice.CompressBatch.BasedOnProxy); batchC1.opByteSOneway(bs1); batchC2.opByteSOneway(bs1); batchC1.opByteSOneway(bs1); batchC1.ice_getConnection().flushBatchRequests(Ice.CompressBatch.BasedOnProxy); batchC1.opByteSOneway(bs1); batchC3.opByteSOneway(bs1); batchC1.opByteSOneway(bs1); batchC1.ice_getConnection().flushBatchRequests(Ice.CompressBatch.BasedOnProxy); } }
public static void allTests(Ice.Communicator communicator) #endif { ServerManagerPrx manager = ServerManagerPrxHelper.checkedCast( communicator.stringToProxy("ServerManager :default -p 12010")); test(manager != null); TestLocatorPrx locator = TestLocatorPrxHelper.uncheckedCast(communicator.getDefaultLocator()); test(locator != null); TestLocatorRegistryPrx registry = TestLocatorRegistryPrxHelper.checkedCast(locator.getRegistry()); test(registry != null); Write("testing stringToProxy... "); Flush(); Ice.ObjectPrx @base = communicator.stringToProxy("test @ TestAdapter"); Ice.ObjectPrx base2 = communicator.stringToProxy("test @ TestAdapter"); Ice.ObjectPrx base3 = communicator.stringToProxy("test"); Ice.ObjectPrx base4 = communicator.stringToProxy("ServerManager"); Ice.ObjectPrx base5 = communicator.stringToProxy("test2"); Ice.ObjectPrx base6 = communicator.stringToProxy("test @ ReplicatedAdapter"); WriteLine("ok"); Write("testing ice_locator and ice_getLocator... "); test(Ice.Util.proxyIdentityCompare(@base.ice_getLocator(), communicator.getDefaultLocator()) == 0); Ice.LocatorPrx anotherLocator = Ice.LocatorPrxHelper.uncheckedCast(communicator.stringToProxy("anotherLocator")); @base = @base.ice_locator(anotherLocator); test(Ice.Util.proxyIdentityCompare(@base.ice_getLocator(), anotherLocator) == 0); communicator.setDefaultLocator(null); @base = communicator.stringToProxy("test @ TestAdapter"); test(@base.ice_getLocator() == null); @base = @base.ice_locator(anotherLocator); test(Ice.Util.proxyIdentityCompare(@base.ice_getLocator(), anotherLocator) == 0); communicator.setDefaultLocator(locator); @base = communicator.stringToProxy("test @ TestAdapter"); test(Ice.Util.proxyIdentityCompare(@base.ice_getLocator(), communicator.getDefaultLocator()) == 0); // // We also test ice_router/ice_getRouter (perhaps we should add a // test/Ice/router test?) // test(@base.ice_getRouter() == null); Ice.RouterPrx anotherRouter = Ice.RouterPrxHelper.uncheckedCast(communicator.stringToProxy("anotherRouter")); @base = @base.ice_router(anotherRouter); test(Ice.Util.proxyIdentityCompare(@base.ice_getRouter(), anotherRouter) == 0); Ice.RouterPrx router = Ice.RouterPrxHelper.uncheckedCast(communicator.stringToProxy("dummyrouter")); communicator.setDefaultRouter(router); @base = communicator.stringToProxy("test @ TestAdapter"); test(Ice.Util.proxyIdentityCompare(@base.ice_getRouter(), communicator.getDefaultRouter()) == 0); communicator.setDefaultRouter(null); @base = communicator.stringToProxy("test @ TestAdapter"); test(@base.ice_getRouter() == null); WriteLine("ok"); Write("starting server... "); Flush(); manager.startServer(); WriteLine("ok"); Write("testing checked cast... "); Flush(); TestIntfPrx obj = TestIntfPrxHelper.checkedCast(@base); test(obj != null); TestIntfPrx obj2 = TestIntfPrxHelper.checkedCast(base2); test(obj2 != null); TestIntfPrx obj3 = TestIntfPrxHelper.checkedCast(base3); test(obj3 != null); ServerManagerPrx obj4 = ServerManagerPrxHelper.checkedCast(base4); test(obj4 != null); TestIntfPrx obj5 = TestIntfPrxHelper.checkedCast(base5); test(obj5 != null); TestIntfPrx obj6 = TestIntfPrxHelper.checkedCast(base6); test(obj6 != null); WriteLine("ok"); Write("testing id@AdapterId indirect proxy... "); Flush(); obj.shutdown(); manager.startServer(); try { obj2.ice_ping(); } catch (Ice.LocalException) { test(false); } WriteLine("ok"); Write("testing id@ReplicaGroupId indirect proxy... "); Flush(); obj.shutdown(); manager.startServer(); try { obj6.ice_ping(); } catch (Ice.LocalException) { test(false); } WriteLine("ok"); Write("testing identity indirect proxy... "); Flush(); obj.shutdown(); manager.startServer(); try { obj3.ice_ping(); } catch (Ice.LocalException) { test(false); } try { obj2.ice_ping(); } catch (Ice.LocalException) { test(false); } obj.shutdown(); manager.startServer(); try { obj2.ice_ping(); } catch (Ice.LocalException) { test(false); } try { obj3.ice_ping(); } catch (Ice.LocalException) { test(false); } obj.shutdown(); manager.startServer(); try { obj2.ice_ping(); } catch (Ice.LocalException) { test(false); } obj.shutdown(); manager.startServer(); try { obj3.ice_ping(); } catch (Ice.LocalException) { test(false); } obj.shutdown(); manager.startServer(); try { obj5 = TestIntfPrxHelper.checkedCast(base5); obj5.ice_ping(); } catch (Ice.LocalException) { test(false); } WriteLine("ok"); Write("testing proxy with unknown identity... "); Flush(); try { @base = communicator.stringToProxy("unknown/unknown"); @base.ice_ping(); test(false); } catch (Ice.NotRegisteredException ex) { test(ex.kindOfObject.Equals("object")); test(ex.id.Equals("unknown/unknown")); } WriteLine("ok"); Write("testing proxy with unknown adapter... "); Flush(); try { @base = communicator.stringToProxy("test @ TestAdapterUnknown"); @base.ice_ping(); test(false); } catch (Ice.NotRegisteredException ex) { test(ex.kindOfObject.Equals("object adapter")); test(ex.id.Equals("TestAdapterUnknown")); } WriteLine("ok"); Write("testing locator cache timeout... "); Flush(); int count = locator.getRequestCount(); communicator.stringToProxy("test@TestAdapter").ice_locatorCacheTimeout(0).ice_ping(); // No locator cache. test(++count == locator.getRequestCount()); communicator.stringToProxy("test@TestAdapter").ice_locatorCacheTimeout(0).ice_ping(); // No locator cache. test(++count == locator.getRequestCount()); communicator.stringToProxy("test@TestAdapter").ice_locatorCacheTimeout(1).ice_ping(); // 1s timeout. test(count == locator.getRequestCount()); System.Threading.Thread.Sleep(1200); // 1200ms communicator.stringToProxy("test@TestAdapter").ice_locatorCacheTimeout(1).ice_ping(); // 1s timeout. test(++count == locator.getRequestCount()); communicator.stringToProxy("test").ice_locatorCacheTimeout(0).ice_ping(); // No locator cache. count += 2; test(count == locator.getRequestCount()); communicator.stringToProxy("test").ice_locatorCacheTimeout(1).ice_ping(); // 1s timeout test(count == locator.getRequestCount()); System.Threading.Thread.Sleep(1200); // 1200ms communicator.stringToProxy("test").ice_locatorCacheTimeout(1).ice_ping(); // 1s timeout count += 2; test(count == locator.getRequestCount()); communicator.stringToProxy("test@TestAdapter").ice_locatorCacheTimeout(-1).ice_ping(); test(count == locator.getRequestCount()); communicator.stringToProxy("test").ice_locatorCacheTimeout(-1).ice_ping(); test(count == locator.getRequestCount()); communicator.stringToProxy("test@TestAdapter").ice_ping(); test(count == locator.getRequestCount()); communicator.stringToProxy("test").ice_ping(); test(count == locator.getRequestCount()); test(communicator.stringToProxy("test").ice_locatorCacheTimeout(99).ice_getLocatorCacheTimeout() == 99); WriteLine("ok"); Write("testing proxy from server... "); Flush(); obj = TestIntfPrxHelper.checkedCast(communicator.stringToProxy("test@TestAdapter")); HelloPrx hello = obj.getHello(); test(hello.ice_getAdapterId().Equals("TestAdapter")); hello.sayHello(); hello = obj.getReplicatedHello(); test(hello.ice_getAdapterId().Equals("ReplicatedAdapter")); hello.sayHello(); WriteLine("ok"); Write("testing locator request queuing... "); Flush(); hello = (HelloPrx)obj.getReplicatedHello().ice_locatorCacheTimeout(0).ice_connectionCached(false); count = locator.getRequestCount(); hello.ice_ping(); test(++count == locator.getRequestCount()); List <Ice.AsyncResult <Test.Callback_Hello_sayHello> > results = new List <Ice.AsyncResult <Test.Callback_Hello_sayHello> >(); for (int i = 0; i < 1000; i++) { Ice.AsyncResult <Test.Callback_Hello_sayHello> result = hello.begin_sayHello(). whenCompleted(delegate() { }, delegate(Ice.Exception ex) { test(false); }); results.Add(result); } foreach (Ice.AsyncResult <Test.Callback_Hello_sayHello> result in results) { result.waitForCompleted(); } results.Clear(); test(locator.getRequestCount() > count && locator.getRequestCount() < count + 999); if (locator.getRequestCount() > count + 800) { Write("queuing = " + (locator.getRequestCount() - count)); } count = locator.getRequestCount(); hello = (HelloPrx)hello.ice_adapterId("unknown"); for (int i = 0; i < 1000; i++) { Ice.AsyncResult <Test.Callback_Hello_sayHello> result = hello.begin_sayHello(). whenCompleted(delegate() { test(false); }, delegate(Ice.Exception ex) { test(ex is Ice.NotRegisteredException); }); results.Add(result); } foreach (Ice.AsyncResult <Test.Callback_Hello_sayHello> result in results) { result.waitForCompleted(); } results.Clear(); // XXX: // Take into account the retries. test(locator.getRequestCount() > count && locator.getRequestCount() < count + 1999); if (locator.getRequestCount() > count + 800) { Write("queuing = " + (locator.getRequestCount() - count)); } WriteLine("ok"); Write("testing adapter locator cache... "); Flush(); try { communicator.stringToProxy("test@TestAdapter3").ice_ping(); test(false); } catch (Ice.NotRegisteredException ex) { test(ex.kindOfObject == "object adapter"); test(ex.id.Equals("TestAdapter3")); } registry.setAdapterDirectProxy("TestAdapter3", locator.findAdapterById("TestAdapter")); try { communicator.stringToProxy("test@TestAdapter3").ice_ping(); registry.setAdapterDirectProxy("TestAdapter3", communicator.stringToProxy("dummy:tcp")); communicator.stringToProxy("test@TestAdapter3").ice_ping(); } catch (Ice.LocalException) { test(false); } try { communicator.stringToProxy("test@TestAdapter3").ice_locatorCacheTimeout(0).ice_ping(); test(false); } catch (Ice.LocalException) { } try { communicator.stringToProxy("test@TestAdapter3").ice_ping(); test(false); } catch (Ice.LocalException) { } registry.setAdapterDirectProxy("TestAdapter3", locator.findAdapterById("TestAdapter")); try { communicator.stringToProxy("test@TestAdapter3").ice_ping(); } catch (Ice.LocalException) { test(false); } WriteLine("ok"); Write("testing well-known object locator cache... "); Flush(); registry.addObject(communicator.stringToProxy("test3@TestUnknown")); try { communicator.stringToProxy("test3").ice_ping(); test(false); } catch (Ice.NotRegisteredException ex) { test(ex.kindOfObject == "object adapter"); test(ex.id.Equals("TestUnknown")); } registry.addObject(communicator.stringToProxy("test3@TestAdapter4")); // Update registry.setAdapterDirectProxy("TestAdapter4", communicator.stringToProxy("dummy:tcp")); try { communicator.stringToProxy("test3").ice_ping(); test(false); } catch (Ice.LocalException) { } registry.setAdapterDirectProxy("TestAdapter4", locator.findAdapterById("TestAdapter")); try { communicator.stringToProxy("test3").ice_ping(); } catch (Ice.LocalException) { test(false); } registry.setAdapterDirectProxy("TestAdapter4", communicator.stringToProxy("dummy:tcp")); try { communicator.stringToProxy("test3").ice_ping(); } catch (Ice.LocalException) { test(false); } try { communicator.stringToProxy("test@TestAdapter4").ice_locatorCacheTimeout(0).ice_ping(); test(false); } catch (Ice.LocalException) { } try { communicator.stringToProxy("test@TestAdapter4").ice_ping(); test(false); } catch (Ice.LocalException) { } try { communicator.stringToProxy("test3").ice_ping(); test(false); } catch (Ice.LocalException) { } registry.addObject(communicator.stringToProxy("test3@TestAdapter")); try { communicator.stringToProxy("test3").ice_ping(); } catch (Ice.LocalException) { test(false); } registry.addObject(communicator.stringToProxy("test4")); try { communicator.stringToProxy("test4").ice_ping(); test(false); } catch (Ice.NoEndpointException) { } WriteLine("ok"); Write("testing locator cache background updates... "); Flush(); { Ice.InitializationData initData = new Ice.InitializationData(); initData.properties = communicator.getProperties().ice_clone_(); initData.properties.setProperty("Ice.BackgroundLocatorCacheUpdates", "1"); Ice.Communicator ic = Ice.Util.initialize(initData); registry.setAdapterDirectProxy("TestAdapter5", locator.findAdapterById("TestAdapter")); registry.addObject(communicator.stringToProxy("test3@TestAdapter")); count = locator.getRequestCount(); ic.stringToProxy("test@TestAdapter5").ice_locatorCacheTimeout(0).ice_ping(); // No locator cache. ic.stringToProxy("test3").ice_locatorCacheTimeout(0).ice_ping(); // No locator cache. count += 3; test(count == locator.getRequestCount()); registry.setAdapterDirectProxy("TestAdapter5", null); registry.addObject(communicator.stringToProxy("test3:tcp")); ic.stringToProxy("test@TestAdapter5").ice_locatorCacheTimeout(10).ice_ping(); // 10s timeout. ic.stringToProxy("test3").ice_locatorCacheTimeout(10).ice_ping(); // 10s timeout. test(count == locator.getRequestCount()); System.Threading.Thread.Sleep(1200); // The following request should trigger the background // updates but still use the cached endpoints and // therefore succeed. ic.stringToProxy("test@TestAdapter5").ice_locatorCacheTimeout(1).ice_ping(); // 1s timeout. ic.stringToProxy("test3").ice_locatorCacheTimeout(1).ice_ping(); // 1s timeout. try { while (true) { ic.stringToProxy("test@TestAdapter5").ice_locatorCacheTimeout(1).ice_ping(); // 1s timeout. System.Threading.Thread.Sleep(10); } } catch (Ice.LocalException) { // Expected to fail once they endpoints have been updated in the background. } try { while (true) { ic.stringToProxy("test3").ice_locatorCacheTimeout(1).ice_ping(); // 1s timeout. System.Threading.Thread.Sleep(10); } } catch (Ice.LocalException) { // Expected to fail once they endpoints have been updated in the background. } ic.destroy(); } WriteLine("ok"); Write("testing proxy from server after shutdown... "); Flush(); hello = obj.getReplicatedHello(); obj.shutdown(); manager.startServer(); hello.sayHello(); WriteLine("ok"); Write("testing object migration... "); Flush(); hello = HelloPrxHelper.checkedCast(communicator.stringToProxy("hello")); obj.migrateHello(); hello.sayHello(); obj.migrateHello(); hello.sayHello(); obj.migrateHello(); hello.sayHello(); WriteLine("ok"); Write("testing locator encoding resolution... "); Flush(); hello = HelloPrxHelper.checkedCast(communicator.stringToProxy("hello")); count = locator.getRequestCount(); communicator.stringToProxy("test@TestAdapter").ice_encodingVersion(Ice.Util.Encoding_1_1).ice_ping(); test(count == locator.getRequestCount()); communicator.stringToProxy("test@TestAdapter10").ice_encodingVersion(Ice.Util.Encoding_1_0).ice_ping(); test(++count == locator.getRequestCount()); communicator.stringToProxy("test -e 1.0@TestAdapter10-2").ice_ping(); test(++count == locator.getRequestCount()); WriteLine("ok"); Write("shutdown server... "); Flush(); obj.shutdown(); WriteLine("ok"); Write("testing whether server is gone... "); Flush(); try { obj2.ice_ping(); test(false); } catch (Ice.LocalException) { } try { obj3.ice_ping(); test(false); } catch (Ice.LocalException) { } try { obj5.ice_ping(); test(false); } catch (Ice.LocalException) { } WriteLine("ok"); #if !SILVERLIGHT Write("testing indirect proxies to collocated objects... "); Flush(); // // Set up test for calling a collocated object through an // indirect, adapterless reference. // Ice.Properties properties = communicator.getProperties(); properties.setProperty("Ice.PrintAdapterReady", "0"); Ice.ObjectAdapter adapter = communicator.createObjectAdapterWithEndpoints("Hello", "default"); adapter.setLocator(locator); Ice.Identity id = new Ice.Identity(); id.name = Guid.NewGuid().ToString(); registry.addObject(adapter.add(new HelloI(), id)); adapter.activate(); try { HelloPrx helloPrx = HelloPrxHelper.checkedCast( communicator.stringToProxy("\"" + communicator.identityToString(id) + "\"")); helloPrx.ice_getConnection(); test(false); } catch (Ice.CollocationOptimizationException) { } adapter.deactivate(); WriteLine("ok"); Write("shutdown server manager... "); Flush(); manager.shutdown(); WriteLine("ok"); #else manager.shutdown(); #endif }
public static Test.TimeoutPrx allTests(TestCommon.Application app) { Ice.Communicator communicator = app.communicator(); string sref = "timeout:" + app.getTestEndpoint(0); Ice.ObjectPrx obj = communicator.stringToProxy(sref); test(obj != null); Test.TimeoutPrx timeout = Test.TimeoutPrxHelper.checkedCast(obj); test(timeout != null); Write("testing connect timeout... "); Flush(); { // // Expect ConnectTimeoutException. // Test.TimeoutPrx to = Test.TimeoutPrxHelper.uncheckedCast(obj.ice_timeout(100)); timeout.holdAdapter(500); try { to.op(); test(false); } catch (Ice.ConnectTimeoutException) { // Expected. } } { // // Expect success. // timeout.op(); // Ensure adapter is active. Test.TimeoutPrx to = Test.TimeoutPrxHelper.uncheckedCast(obj.ice_timeout(1000)); timeout.holdAdapter(500); try { to.op(); } catch (Ice.ConnectTimeoutException) { test(false); } } WriteLine("ok"); // The sequence needs to be large enough to fill the write/recv buffers byte[] seq = new byte[2000000]; Write("testing connection timeout... "); Flush(); { // // Expect TimeoutException. // Test.TimeoutPrx to = Test.TimeoutPrxHelper.uncheckedCast(obj.ice_timeout(250)); connect(to); timeout.holdAdapter(750); try { to.sendData(seq); test(false); } catch (Ice.TimeoutException) { // Expected. } } { // // Expect success. // timeout.op(); // Ensure adapter is active. Test.TimeoutPrx to = Test.TimeoutPrxHelper.uncheckedCast(obj.ice_timeout(1000)); timeout.holdAdapter(500); try { to.sendData(new byte[1000000]); } catch (Ice.TimeoutException) { test(false); } } WriteLine("ok"); Write("testing invocation timeout... "); Flush(); { Ice.Connection connection = obj.ice_getConnection(); Test.TimeoutPrx to = Test.TimeoutPrxHelper.uncheckedCast(obj.ice_invocationTimeout(100)); test(connection == to.ice_getConnection()); try { to.sleep(750); test(false); } catch (Ice.InvocationTimeoutException) { } obj.ice_ping(); to = Test.TimeoutPrxHelper.checkedCast(obj.ice_invocationTimeout(500)); test(connection == to.ice_getConnection()); try { to.sleep(100); } catch (Ice.InvocationTimeoutException) { test(false); } test(connection == to.ice_getConnection()); } { // // Expect InvocationTimeoutException. // Test.TimeoutPrx to = Test.TimeoutPrxHelper.uncheckedCast(obj.ice_invocationTimeout(100)); Callback cb = new Callback(); to.begin_sleep(750).whenCompleted( () => { test(false); }, (Ice.Exception ex) => { test(ex is Ice.InvocationTimeoutException); cb.called(); }); cb.check(); obj.ice_ping(); } { // // Expect success. // Test.TimeoutPrx to = Test.TimeoutPrxHelper.uncheckedCast(obj.ice_invocationTimeout(500)); Callback cb = new Callback(); to.begin_sleep(100).whenCompleted( () => { cb.called(); }, (Ice.Exception ex) => { test(false); }); cb.check(); } { // // Backward compatible connection timeouts // Test.TimeoutPrx to = Test.TimeoutPrxHelper.uncheckedCast(obj.ice_invocationTimeout(-2).ice_timeout(250)); Ice.Connection con = connect(to); try { to.sleep(750); test(false); } catch (Ice.TimeoutException) { try { con.getInfo(); test(false); } catch (Ice.TimeoutException) { // Connection got closed as well. } } obj.ice_ping(); try { con = connect(to); to.end_sleep(to.begin_sleep(750)); test(false); } catch (Ice.TimeoutException) { try { con.getInfo(); test(false); } catch (Ice.TimeoutException) { // Connection got closed as well. } } obj.ice_ping(); } WriteLine("ok"); Write("testing close timeout... "); Flush(); { Test.TimeoutPrx to = Test.TimeoutPrxHelper.uncheckedCast(obj.ice_timeout(250)); Ice.Connection connection = connect(to); timeout.holdAdapter(600); connection.close(Ice.ConnectionClose.GracefullyWithWait); try { connection.getInfo(); // getInfo() doesn't throw in the closing state. } catch (Ice.LocalException) { test(false); } Thread.Sleep(650); try { connection.getInfo(); test(false); } catch (Ice.ConnectionManuallyClosedException ex) { // Expected. test(ex.graceful); } timeout.op(); // Ensure adapter is active. } WriteLine("ok"); Write("testing timeout overrides... "); Flush(); { // // Test Ice.Override.Timeout. This property overrides all // endpoint timeouts. // string[] args = new string[0]; Ice.InitializationData initData = new Ice.InitializationData(); initData.properties = communicator.getProperties().ice_clone_(); initData.properties.setProperty("Ice.Override.ConnectTimeout", "250"); initData.properties.setProperty("Ice.Override.Timeout", "100"); Ice.Communicator comm = Ice.Util.initialize(ref args, initData); Test.TimeoutPrx to = Test.TimeoutPrxHelper.uncheckedCast(comm.stringToProxy(sref)); connect(to); timeout.holdAdapter(500); try { to.sendData(seq); test(false); } catch (Ice.TimeoutException) { // Expected. } // // Calling ice_timeout() should have no effect. // timeout.op(); // Ensure adapter is active. to = Test.TimeoutPrxHelper.uncheckedCast(to.ice_timeout(1000)); connect(to); timeout.holdAdapter(500); try { to.sendData(seq); test(false); } catch (Ice.TimeoutException) { // Expected. } comm.destroy(); } { // // Test Ice.Override.ConnectTimeout. // string[] args = new string[0]; Ice.InitializationData initData = new Ice.InitializationData(); initData.properties = communicator.getProperties().ice_clone_(); initData.properties.setProperty("Ice.Override.ConnectTimeout", "250"); Ice.Communicator comm = Ice.Util.initialize(ref args, initData); timeout.holdAdapter(750); Test.TimeoutPrx to = Test.TimeoutPrxHelper.uncheckedCast(comm.stringToProxy(sref)); try { to.op(); test(false); } catch (Ice.ConnectTimeoutException) { // Expected. } // // Calling ice_timeout() should have no effect on the connect timeout. // timeout.op(); // Ensure adapter is active. timeout.holdAdapter(750); to = Test.TimeoutPrxHelper.uncheckedCast(to.ice_timeout(1000)); try { to.op(); test(false); } catch (Ice.ConnectTimeoutException) { // Expected. } // // Verify that timeout set via ice_timeout() is still used for requests. // timeout.op(); // Ensure adapter is active. to = Test.TimeoutPrxHelper.uncheckedCast(to.ice_timeout(250)); connect(to); timeout.holdAdapter(750); try { to.sendData(seq); test(false); } catch (Ice.TimeoutException) { // Expected. } comm.destroy(); } { // // Test Ice.Override.CloseTimeout. // Ice.InitializationData initData = new Ice.InitializationData(); initData.properties = communicator.getProperties().ice_clone_(); initData.properties.setProperty("Ice.Override.CloseTimeout", "100"); Ice.Communicator comm = Ice.Util.initialize(initData); comm.stringToProxy(sref).ice_getConnection(); timeout.holdAdapter(800); long begin = System.DateTime.Now.Ticks; comm.destroy(); test(((long)new System.TimeSpan(System.DateTime.Now.Ticks - begin).TotalMilliseconds - begin) < 700); } WriteLine("ok"); Write("testing invocation timeouts with collocated calls... "); Flush(); { communicator.getProperties().setProperty("TimeoutCollocated.AdapterId", "timeoutAdapter"); Ice.ObjectAdapter adapter = communicator.createObjectAdapter("TimeoutCollocated"); adapter.activate(); Test.TimeoutPrx proxy = Test.TimeoutPrxHelper.uncheckedCast(adapter.addWithUUID(new TimeoutI())); proxy = (Test.TimeoutPrx)proxy.ice_invocationTimeout(100); try { proxy.sleep(500); test(false); } catch (Ice.InvocationTimeoutException) { } try { proxy.end_sleep(proxy.begin_sleep(500)); test(false); } catch (Ice.InvocationTimeoutException) { } try { ((Test.TimeoutPrx)proxy.ice_invocationTimeout(-2)).ice_ping(); ((Test.TimeoutPrx)proxy.ice_invocationTimeout(-2)).begin_ice_ping().waitForCompleted(); } catch (Ice.Exception) { test(false); } Test.TimeoutPrx batchTimeout = (Test.TimeoutPrx)proxy.ice_batchOneway(); batchTimeout.ice_ping(); batchTimeout.ice_ping(); batchTimeout.ice_ping(); ((Test.TimeoutPrx)proxy.ice_invocationTimeout(-1)).begin_sleep(300); // Keep the server thread pool busy. try { batchTimeout.ice_flushBatchRequests(); test(false); } catch (Ice.InvocationTimeoutException) { } batchTimeout.ice_ping(); batchTimeout.ice_ping(); batchTimeout.ice_ping(); ((Test.TimeoutPrx)proxy.ice_invocationTimeout(-1)).begin_sleep(300); // Keep the server thread pool busy. try { batchTimeout.end_ice_flushBatchRequests(batchTimeout.begin_ice_flushBatchRequests()); test(false); } catch (Ice.InvocationTimeoutException) { } adapter.destroy(); } WriteLine("ok"); return(timeout); }
public void response(Ice.ObjectPrx proxy) { _m.Lock(); try { _locatorInfo.finishRequest(_ref, _wellKnownRefs, proxy, false); _response = true; _proxy = proxy; foreach(RequestCallback callback in _callbacks) { callback.response(_locatorInfo, proxy); } _m.NotifyAll(); } finally { _m.Unlock(); } }
public static void allTests(Ice.Communicator communicator) #endif { string sref = "test:default -p 12010"; Ice.ObjectPrx obj = communicator.stringToProxy(sref); test(obj != null); Test.TestIntfPrx p = Test.TestIntfPrxHelper.uncheckedCast(obj); sref = "testController:tcp -p 12011"; obj = communicator.stringToProxy(sref); test(obj != null); Test.TestIntfControllerPrx testController = Test.TestIntfControllerPrxHelper.uncheckedCast(obj); Write("testing dispatcher... "); Flush(); { p.op(); Callback cb = new Callback(); p.begin_op().whenCompleted(cb.response, cb.exception); cb.check(); TestIntfPrx i = (TestIntfPrx)p.ice_adapterId("dummy"); i.begin_op().whenCompleted(cb.exception); cb.check(); // // Expect InvocationTimeoutException. // { Test.TestIntfPrx to = Test.TestIntfPrxHelper.uncheckedCast(p.ice_invocationTimeout(250)); to.begin_sleep(500).whenCompleted( () => { test(false); }, (Ice.Exception ex) => { test(ex is Ice.InvocationTimeoutException); test(Dispatcher.isDispatcherThread()); cb.called(); }); cb.check(); } testController.holdAdapter(); Test.Callback_TestIntf_opWithPayload resp = cb.payload; Ice.ExceptionCallback excb = cb.ignoreEx; Ice.SentCallback scb = cb.sent; byte[] seq = new byte[10 * 1024]; (new System.Random()).NextBytes(seq); Ice.AsyncResult r; while ((r = p.begin_opWithPayload(seq).whenCompleted(resp, excb).whenSent(scb)).sentSynchronously()) { ; } testController.resumeAdapter(); r.waitForCompleted(); } WriteLine("ok"); p.shutdown(); }
public DiscoverI(Ice.ObjectPrx obj) { _obj = obj; }
public override int run(string[] args) { string option = "None"; string topicName = "time"; int i; for (i = 0; i < args.Length; ++i) { String oldoption = option; if (args[i].Equals("--datagram")) { option = "Datagram"; } else if (args[i].Equals("--twoway")) { option = "Twoway"; } else if (args[i].Equals("--oneway")) { option = "Oneway"; } else if (args[i].StartsWith("--")) { usage(); return(1); } else { topicName = args[i++]; break; } if (!oldoption.Equals(option) && !oldoption.Equals("None")) { usage(); return(1); } } if (i != args.Length) { usage(); return(1); } IceStorm.TopicManagerPrx manager = IceStorm.TopicManagerPrxHelper.checkedCast( communicator().propertyToProxy("TopicManager.Proxy")); if (manager == null) { Console.WriteLine("invalid proxy"); return(1); } // // Retrieve the topic. // IceStorm.TopicPrx topic; try { topic = manager.retrieve(topicName); } catch (IceStorm.NoSuchTopic) { try { topic = manager.create(topicName); } catch (IceStorm.TopicExists) { Console.WriteLine("temporary error. try again."); return(1); } } // // Get the topic's publisher object, and create a Clock proxy with // the mode specified as an argument of this application. // Ice.ObjectPrx publisher = topic.getPublisher(); if (option.Equals("Datagram")) { publisher = publisher.ice_datagram(); } else if (option.Equals("Twoway")) { // Do nothing. } else // if(oneway) { publisher = publisher.ice_oneway(); } ClockPrx clock = ClockPrxHelper.uncheckedCast(publisher); Console.WriteLine("publishing tick events. Press ^C to terminate the application."); try { while (true) { clock.tick(System.DateTime.Now.ToString("G", DateTimeFormatInfo.InvariantInfo)); System.Threading.Thread.Sleep(1000); } } catch (Ice.CommunicatorDestroyedException) { // Ignore } return(0); }
internal static void twoways(Ice.Communicator communicator, Test.MyClassPrx p) { { byte[] i = new byte[_length]; for (int c = 0; c < _length; ++c) { i[c] = (byte)c; } byte[] o; byte[] r; r = p.opAByteS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { List <byte> i = new List <byte>(_length); for (int c = 0; c < _length; ++c) { i.Add((byte)c); } List <byte> o; List <byte> r; r = p.opLByteS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { LinkedList <byte> i = new LinkedList <byte>(); for (int c = 0; c < _length; ++c) { i.AddLast((byte)c); } LinkedList <byte> o; LinkedList <byte> r; r = p.opKByteS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Queue <byte> i = new Queue <byte>(); for (int c = 0; c < _length; ++c) { i.Enqueue((byte)c); } Queue <byte> o; Queue <byte> r; r = p.opQByteS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Stack <byte> i = new Stack <byte>(); for (int c = 0; c < _length; ++c) { i.Push((byte)c); } Stack <byte> o; Stack <byte> r; r = p.opSByteS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { bool[] i = new bool[_length]; for (int c = 0; c < _length; ++c) { i[c] = c % 1 == 1; } bool[] o; bool[] r; r = p.opABoolS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { List <bool> i = new List <bool>(_length); for (int c = 0; c < _length; ++c) { i.Add(c % 1 == 1); } List <bool> o; List <bool> r; r = p.opLBoolS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { LinkedList <bool> i = new LinkedList <bool>(); for (int c = 0; c < _length; ++c) { i.AddLast(c % 1 == 1); } LinkedList <bool> o; LinkedList <bool> r; r = p.opKBoolS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Queue <bool> i = new Queue <bool>(); for (int c = 0; c < _length; ++c) { i.Enqueue(c % 1 == 1); } Queue <bool> o; Queue <bool> r; r = p.opQBoolS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Stack <bool> i = new Stack <bool>(); for (int c = 0; c < _length; ++c) { i.Push(c % 1 == 1); } Stack <bool> o; Stack <bool> r; r = p.opSBoolS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { short[] i = new short[_length]; for (int c = 0; c < _length; ++c) { i[c] = (short)c; } short[] o; short[] r; { r = p.opAShortS(i, out o); } test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { List <short> i = new List <short>(_length); for (int c = 0; c < _length; ++c) { i.Add((short)c); } List <short> o; List <short> r; r = p.opLShortS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { LinkedList <short> i = new LinkedList <short>(); for (int c = 0; c < _length; ++c) { i.AddLast((short)c); } LinkedList <short> o; LinkedList <short> r; r = p.opKShortS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Queue <short> i = new Queue <short>(); for (int c = 0; c < _length; ++c) { i.Enqueue((short)c); } Queue <short> o; Queue <short> r; r = p.opQShortS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Stack <short> i = new Stack <short>(); for (int c = 0; c < _length; ++c) { i.Push((short)c); } Stack <short> o; Stack <short> r; r = p.opSShortS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { int[] i = new int[_length]; for (int c = 0; c < _length; ++c) { i[c] = (int)c; } int[] o; int[] r; r = p.opAIntS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { List <int> i = new List <int>(_length); for (int c = 0; c < _length; ++c) { i.Add((int)c); } List <int> o; List <int> r; r = p.opLIntS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { LinkedList <int> i = new LinkedList <int>(); for (int c = 0; c < _length; ++c) { i.AddLast((int)c); } LinkedList <int> o; LinkedList <int> r; r = p.opKIntS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Queue <int> i = new Queue <int>(); for (int c = 0; c < _length; ++c) { i.Enqueue((int)c); } Queue <int> o; Queue <int> r; r = p.opQIntS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Stack <int> i = new Stack <int>(); for (int c = 0; c < _length; ++c) { i.Push((int)c); } Stack <int> o; Stack <int> r; r = p.opSIntS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { long[] i = new long[_length]; for (int c = 0; c < _length; ++c) { i[c] = (long)c; } long[] o; long[] r; r = p.opALongS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { List <long> i = new List <long>(_length); for (int c = 0; c < _length; ++c) { i.Add((long)c); } List <long> o; List <long> r; r = p.opLLongS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { LinkedList <long> i = new LinkedList <long>(); for (int c = 0; c < _length; ++c) { i.AddLast((long)c); } LinkedList <long> o; LinkedList <long> r; r = p.opKLongS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Queue <long> i = new Queue <long>(); for (int c = 0; c < _length; ++c) { i.Enqueue((long)c); } Queue <long> o; Queue <long> r; r = p.opQLongS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Stack <long> i = new Stack <long>(); for (int c = 0; c < _length; ++c) { i.Push((long)c); } Stack <long> o; Stack <long> r; r = p.opSLongS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { float[] i = new float[_length]; for (int c = 0; c < _length; ++c) { i[c] = (float)c; } float[] o; float[] r; r = p.opAFloatS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { List <float> i = new List <float>(_length); for (int c = 0; c < _length; ++c) { i.Add((float)c); } List <float> o; List <float> r; r = p.opLFloatS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { LinkedList <float> i = new LinkedList <float>(); for (int c = 0; c < _length; ++c) { i.AddLast((float)c); } LinkedList <float> o; LinkedList <float> r; r = p.opKFloatS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Queue <float> i = new Queue <float>(); for (int c = 0; c < _length; ++c) { i.Enqueue((float)c); } Queue <float> o; Queue <float> r; r = p.opQFloatS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Stack <float> i = new Stack <float>(); for (int c = 0; c < _length; ++c) { i.Push((float)c); } Stack <float> o; Stack <float> r; r = p.opSFloatS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { double[] i = new double[_length]; for (int c = 0; c < _length; ++c) { i[c] = (double)c; } double[] o; double[] r; r = p.opADoubleS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { List <double> i = new List <double>(_length); for (int c = 0; c < _length; ++c) { i.Add((double)c); } List <double> o; List <double> r; r = p.opLDoubleS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { LinkedList <double> i = new LinkedList <double>(); for (int c = 0; c < _length; ++c) { i.AddLast((double)c); } LinkedList <double> o; LinkedList <double> r; r = p.opKDoubleS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Queue <double> i = new Queue <double>(); for (int c = 0; c < _length; ++c) { i.Enqueue((double)c); } Queue <double> o; Queue <double> r; r = p.opQDoubleS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Stack <double> i = new Stack <double>(); for (int c = 0; c < _length; ++c) { i.Push((double)c); } Stack <double> o; Stack <double> r; r = p.opSDoubleS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { string[] i = new string[_length]; for (int c = 0; c < _length; ++c) { i[c] = c.ToString(); } string[] o; string[] r; r = p.opAStringS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { List <string> i = new List <string>(_length); for (int c = 0; c < _length; ++c) { i.Add(c.ToString()); } List <string> o; List <string> r; r = p.opLStringS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { LinkedList <string> i = new LinkedList <string>(); for (int c = 0; c < _length; ++c) { i.AddLast(c.ToString()); } LinkedList <string> o; LinkedList <string> r; r = p.opKStringS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Queue <string> i = new Queue <string>(); for (int c = 0; c < _length; ++c) { i.Enqueue(c.ToString()); } Queue <string> o; Queue <string> r; r = p.opQStringS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Stack <string> i = new Stack <string>(); for (int c = 0; c < _length; ++c) { i.Push(c.ToString()); } Stack <string> o; Stack <string> r; r = p.opSStringS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Ice.Value[] i = new Test.CV[_length]; for (int c = 0; c < _length; ++c) { i[c] = new Test.CV(c); } Ice.Value[] o; Ice.Value[] r; r = p.opAObjectS(i, out o); System.Collections.IEnumerator eo = o.GetEnumerator(); System.Collections.IEnumerator er = r.GetEnumerator(); foreach (Test.CV obj in i) { eo.MoveNext(); er.MoveNext(); test(obj.i == ((Test.CV)eo.Current).i); test(obj.i == ((Test.CV)er.Current).i); } } { var i = new List <Ice.Value>(_length); for (int c = 0; c < _length; ++c) { i.Add(new Test.CV(c)); } List <Ice.Value> o; List <Ice.Value> r; r = p.opLObjectS(i, out o); var eo = o.GetEnumerator(); var er = r.GetEnumerator(); foreach (Test.CV obj in i) { eo.MoveNext(); er.MoveNext(); test(obj.i == ((Test.CV)eo.Current).i); test(obj.i == ((Test.CV)er.Current).i); } } { Ice.ObjectPrx[] i = new Ice.ObjectPrx[_length]; for (int c = 0; c < _length; ++c) { i[c] = communicator.stringToProxy(c.ToString()); } Ice.ObjectPrx[] o; Ice.ObjectPrx[] r; r = p.opAObjectPrxS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { List <Ice.ObjectPrx> i = new List <Ice.ObjectPrx>(_length); for (int c = 0; c < _length; ++c) { i.Add(communicator.stringToProxy(c.ToString())); } List <Ice.ObjectPrx> o; List <Ice.ObjectPrx> r; r = p.opLObjectPrxS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { LinkedList <Ice.ObjectPrx> i = new LinkedList <Ice.ObjectPrx>(); for (int c = 0; c < _length; ++c) { i.AddLast(communicator.stringToProxy(c.ToString())); } LinkedList <Ice.ObjectPrx> o; LinkedList <Ice.ObjectPrx> r; r = p.opKObjectPrxS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Queue <Ice.ObjectPrx> i = new Queue <Ice.ObjectPrx>(); for (int c = 0; c < _length; ++c) { i.Enqueue(communicator.stringToProxy(c.ToString())); } Queue <Ice.ObjectPrx> o; Queue <Ice.ObjectPrx> r; r = p.opQObjectPrxS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Stack <Ice.ObjectPrx> i = new Stack <Ice.ObjectPrx>(); for (int c = 0; c < _length; ++c) { i.Push(communicator.stringToProxy(c.ToString())); } Stack <Ice.ObjectPrx> o; Stack <Ice.ObjectPrx> r; r = p.opSObjectPrxS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { var i = new Test.S[_length]; for (int c = 0; c < _length; ++c) { i[c].i = c; } Test.S[] o; Test.S[] r; r = p.opAStructS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { var i = new List <Test.S>(_length); for (int c = 0; c < _length; ++c) { i.Add(new Test.S(c)); } List <Test.S> o; List <Test.S> r; r = p.opLStructS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { var i = new LinkedList <Test.S>(); for (int c = 0; c < _length; ++c) { i.AddLast(new Test.S(c)); } LinkedList <Test.S> o; LinkedList <Test.S> r; r = p.opKStructS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { var i = new Queue <Test.S>(); for (int c = 0; c < _length; ++c) { i.Enqueue(new Test.S(c)); } Queue <Test.S> o; Queue <Test.S> r; r = p.opQStructS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { var i = new Stack <Test.S>(); for (int c = 0; c < _length; ++c) { i.Push(new Test.S(c)); } Stack <Test.S> o; Stack <Test.S> r; r = p.opSStructS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { var i = new Test.SD[_length]; for (int c = 0; c < _length; ++c) { i[c] = new Test.SD(c); } Test.SD[] o; Test.SD[] r; r = p.opAStructSD(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { var i = new List <Test.SD>(_length); for (int c = 0; c < _length; ++c) { i.Add(new Test.SD(c)); } List <Test.SD> o; List <Test.SD> r; r = p.opLStructSD(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { var i = new LinkedList <Test.SD>(); for (int c = 0; c < _length; ++c) { i.AddLast(new Test.SD(c)); } LinkedList <Test.SD> o; LinkedList <Test.SD> r; r = p.opKStructSD(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { var i = new Queue <Test.SD>(); for (int c = 0; c < _length; ++c) { i.Enqueue(new Test.SD(c)); } Queue <Test.SD> o; Queue <Test.SD> r; r = p.opQStructSD(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { var i = new Stack <Test.SD>(); for (int c = 0; c < _length; ++c) { i.Push(new Test.SD(c)); } Stack <Test.SD> o; Stack <Test.SD> r; r = p.opSStructSD(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { var i = new Test.CV[_length]; for (int c = 0; c < _length; ++c) { i[c] = new Test.CV(c); } Test.CV[] o; Test.CV[] r; r = p.opACVS(i, out o); System.Collections.IEnumerator eo = o.GetEnumerator(); System.Collections.IEnumerator er = r.GetEnumerator(); foreach (Test.CV obj in i) { eo.MoveNext(); er.MoveNext(); test(obj.i == ((Test.CV)eo.Current).i); test(obj.i == ((Test.CV)er.Current).i); } } { var i = new List <Test.CV>(_length); for (int c = 0; c < _length; ++c) { i.Add(new Test.CV(c)); } List <Test.CV> o; List <Test.CV> r; r = p.opLCVS(i, out o); IEnumerator <Test.CV> eo = o.GetEnumerator(); IEnumerator <Test.CV> er = r.GetEnumerator(); foreach (Test.CV obj in i) { eo.MoveNext(); er.MoveNext(); test(obj.i == eo.Current.i); test(obj.i == er.Current.i); } } { var i = new Test.CR[_length]; for (int c = 0; c < _length; ++c) { i[c] = new Test.CR(new Test.CV(c)); } Test.CR[] o; Test.CR[] r; r = p.opACRS(i, out o); System.Collections.IEnumerator eo = o.GetEnumerator(); System.Collections.IEnumerator er = r.GetEnumerator(); foreach (Test.CR obj in i) { eo.MoveNext(); er.MoveNext(); test(obj.v.i == ((Test.CR)eo.Current).v.i); test(obj.v.i == ((Test.CR)er.Current).v.i); } } { var i = new List <Test.CR>(_length); for (int c = 0; c < _length; ++c) { i.Add(new Test.CR(new Test.CV(c))); } List <Test.CR> o; List <Test.CR> r; r = p.opLCRS(i, out o); IEnumerator <Test.CR> eo = o.GetEnumerator(); IEnumerator <Test.CR> er = r.GetEnumerator(); foreach (Test.CR obj in i) { eo.MoveNext(); er.MoveNext(); test(obj.v.i == eo.Current.v.i); test(obj.v.i == er.Current.v.i); } } { var i = new Test.En[_length]; for (int c = 0; c < _length; ++c) { i[c] = (Test.En)(c % 3); } Test.En[] o; Test.En[] r; r = p.opAEnS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { var i = new List <Test.En>(_length); for (int c = 0; c < _length; ++c) { i.Add((Test.En)(c % 3)); } List <Test.En> o; List <Test.En> r; r = p.opLEnS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { var i = new LinkedList <Test.En>(); for (int c = 0; c < _length; ++c) { i.AddLast((Test.En)(c % 3)); } LinkedList <Test.En> o; LinkedList <Test.En> r; r = p.opKEnS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { var i = new Queue <Test.En>(); for (int c = 0; c < _length; ++c) { i.Enqueue((Test.En)(c % 3)); } Queue <Test.En> o; Queue <Test.En> r; r = p.opQEnS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { var i = new Stack <Test.En>(); for (int c = 0; c < _length; ++c) { i.Push((Test.En)(c % 3)); } Stack <Test.En> o; Stack <Test.En> r; r = p.opSEnS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Test.IPrx[] i = new Test.IPrx[_length]; for (int c = 0; c < _length; ++c) { i[c] = Test.IPrxHelper.uncheckedCast(communicator.stringToProxy(c.ToString())); } Test.IPrx[] o; Test.IPrx[] r; r = p.opAIPrxS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { List <Test.IPrx> i = new List <Test.IPrx>(_length); for (int c = 0; c < _length; ++c) { i.Add(Test.IPrxHelper.uncheckedCast(communicator.stringToProxy(c.ToString()))); } List <Test.IPrx> o; List <Test.IPrx> r; r = p.opLIPrxS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { LinkedList <Test.IPrx> i = new LinkedList <Test.IPrx>(); for (int c = 0; c < _length; ++c) { i.AddLast(Test.IPrxHelper.uncheckedCast(communicator.stringToProxy(c.ToString()))); } LinkedList <Test.IPrx> o; LinkedList <Test.IPrx> r; r = p.opKIPrxS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Queue <Test.IPrx> i = new Queue <Test.IPrx>(); for (int c = 0; c < _length; ++c) { i.Enqueue(Test.IPrxHelper.uncheckedCast(communicator.stringToProxy(c.ToString()))); } Queue <Test.IPrx> o; Queue <Test.IPrx> r; r = p.opQIPrxS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Stack <Test.IPrx> i = new Stack <Test.IPrx>(); for (int c = 0; c < _length; ++c) { i.Push(Test.IPrxHelper.uncheckedCast(communicator.stringToProxy(c.ToString()))); } Stack <Test.IPrx> o; Stack <Test.IPrx> r; r = p.opSIPrxS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Custom <int> i = new Custom <int>(); for (int c = 0; c < _length; ++c) { i.Add(c); } Custom <int> o; Custom <int> r; r = p.opCustomIntS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { var i = new Custom <Test.CV>(); for (int c = 0; c < _length; ++c) { i.Add(new Test.CV(c)); } i.Add(null); Custom <Test.CV> o; Custom <Test.CV> r; r = p.opCustomCVS(i, out o); var eo = o.GetEnumerator(); var er = r.GetEnumerator(); foreach (Test.CV obj in i) { eo.MoveNext(); er.MoveNext(); if (obj == null) { test(eo.Current == null); test(er.Current == null); } else { test(obj.i == eo.Current.i); test(obj.i == er.Current.i); } } } { Custom <Custom <int> > i = new Custom <Custom <int> >(); for (int c = 0; c < _length; ++c) { Custom <int> inner = new Custom <int>(); for (int j = 0; j < c; ++j) { inner.Add(j); } i.Add(inner); } Custom <Custom <int> > o; Custom <Custom <int> > r; r = p.opCustomIntSS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { var i = new Custom <Custom <Test.CV> >(); for (int c = 0; c < _length; ++c) { var inner = new Custom <Test.CV>(); for (int j = 0; j < c; ++j) { inner.Add(new Test.CV(j)); } i.Add(inner); } Custom <Custom <Test.CV> > o; Custom <Custom <Test.CV> > r; r = p.opCustomCVSS(i, out o); var eo = o.GetEnumerator(); var er = r.GetEnumerator(); foreach (Custom <Test.CV> s in i) { eo.MoveNext(); er.MoveNext(); IEnumerator <Test.CV> io = eo.Current.GetEnumerator(); IEnumerator <Test.CV> ir = er.Current.GetEnumerator(); foreach (Test.CV obj in s) { io.MoveNext(); ir.MoveNext(); if (obj == null) { test(io.Current == null); test(ir.Current == null); } else { test(obj.i == io.Current.i); test(obj.i == ir.Current.i); } } } } { Serialize.Small i = null; Serialize.Small o; Serialize.Small r; r = p.opSerialSmallCSharp(i, out o); test(o == null); test(r == null); } { Serialize.Small i = new Serialize.Small(); i.i = 99; Serialize.Small o; Serialize.Small r; try { r = p.opSerialSmallCSharp(i, out o); test(o.i == 99); test(r.i == 99); } catch (Ice.OperationNotExistException) { // OK, talking to non-C# server. } } { Serialize.Large i = new Serialize.Large(); i.d1 = 1.0; i.d2 = 2.0; i.d3 = 3.0; i.d4 = 4.0; i.d5 = 5.0; i.d6 = 6.0; i.d7 = 7.0; i.d8 = 8.0; i.d9 = 9.0; i.d10 = 10.0; Serialize.Large o; Serialize.Large r; try { r = p.opSerialLargeCSharp(i, out o); test(o.d1 == 1.0); test(o.d2 == 2.0); test(o.d3 == 3.0); test(o.d4 == 4.0); test(o.d5 == 5.0); test(o.d6 == 6.0); test(o.d7 == 7.0); test(o.d8 == 8.0); test(o.d9 == 9.0); test(o.d10 == 10.0); test(r.d1 == 1.0); test(r.d2 == 2.0); test(r.d3 == 3.0); test(r.d4 == 4.0); test(r.d5 == 5.0); test(r.d6 == 6.0); test(r.d7 == 7.0); test(r.d8 == 8.0); test(r.d9 == 9.0); test(r.d10 == 10.0); } catch (Ice.OperationNotExistException) { // OK, talking to non-C# server. } } { Serialize.Struct i = new Serialize.Struct(); i.o = null; i.o2 = i; i.s = null; i.s2 = "Hello"; Serialize.Struct o; Serialize.Struct r; try { r = p.opSerialStructCSharp(i, out o); test(o.o == null); test(o.o2 != null); test(((Serialize.Struct)(o.o2)).o == null); test(((Serialize.Struct)(o.o2)).o2 == o.o2); test(o.s == null); test(o.s2.Equals("Hello")); test(r.o == null); test(r.o2 != null); test(((Serialize.Struct)(r.o2)).o == null); test(((Serialize.Struct)(r.o2)).o2 == r.o2); test(r.s == null); test(r.s2.Equals("Hello")); } catch (Ice.OperationNotExistException) { // OK, talking to non-C# server. } } }
public static void allTests(TestCommon.Application app) { Ice.Communicator communicator = app.communicator(); communicator.getProperties().setProperty("ReplyAdapter.Endpoints", "udp"); Ice.ObjectAdapter adapter = communicator.createObjectAdapter("ReplyAdapter"); PingReplyI replyI = new PingReplyI(); Test.PingReplyPrx reply = (Test.PingReplyPrx)Test.PingReplyPrxHelper.uncheckedCast(adapter.addWithUUID(replyI)).ice_datagram(); adapter.activate(); Console.Out.Write("testing udp... "); Console.Out.Flush(); Ice.ObjectPrx @base = communicator.stringToProxy("test:" + app.getTestEndpoint(0, "udp")).ice_datagram(); Test.TestIntfPrx obj = Test.TestIntfPrxHelper.uncheckedCast(@base); int nRetry = 5; bool ret = false; while (nRetry-- > 0) { replyI.reset(); obj.ping(reply); obj.ping(reply); obj.ping(reply); ret = replyI.waitReply(3, 2000); if (ret) { break; // Success } // If the 3 datagrams were not received within the 2 seconds, we try again to // receive 3 new datagrams using a new object. We give up after 5 retries. replyI = new PingReplyI(); reply = (Test.PingReplyPrx)Test.PingReplyPrxHelper.uncheckedCast(adapter.addWithUUID(replyI)).ice_datagram(); } test(ret == true); if (communicator.getProperties().getPropertyAsInt("Ice.Override.Compress") == 0) { // // Only run this test if compression is disabled, the test expect fixed message size // to be sent over the wire. // byte[] seq = null; try { seq = new byte[1024]; while (true) { seq = new byte[seq.Length * 2 + 10]; replyI.reset(); obj.sendByteSeq(seq, reply); replyI.waitReply(1, 10000); } } catch (Ice.DatagramLimitException) { // // The server's Ice.UDP.RcvSize property is set to 16384, which means that DatagramLimitException // will be throw when try to send a packet bigger than that. // test(seq.Length > 16384); } obj.ice_getConnection().close(Ice.ConnectionClose.GracefullyWithWait); communicator.getProperties().setProperty("Ice.UDP.SndSize", "64000"); seq = new byte[50000]; try { replyI.reset(); obj.sendByteSeq(seq, reply); bool b = replyI.waitReply(1, 500); // // The server's Ice.UDP.RcvSize property is set to 16384, which means this packet // should not be delivered. // test(!b); } catch (Ice.DatagramLimitException) { } catch (Ice.LocalException ex) { Console.Out.WriteLine(ex); test(false); } } Console.Out.WriteLine("ok"); Console.Out.Write("testing udp multicast... "); Console.Out.Flush(); StringBuilder endpoint = new StringBuilder(); if (communicator.getProperties().getProperty("Ice.IPv6").Equals("1")) { endpoint.Append("udp -h \"ff15::1:1\" --interface \"::1\" -p "); // Use loopback to prevent other machines to answer. } else { endpoint.Append("udp -h 239.255.1.1 --interface 127.0.0.1 -p "); // Use loopback to prevent other machines to answer. } endpoint.Append(app.getTestPort(10)); @base = communicator.stringToProxy("test -d:" + endpoint.ToString()); TestIntfPrx objMcast = Test.TestIntfPrxHelper.uncheckedCast(@base); nRetry = 5; while (nRetry-- > 0) { replyI.reset(); objMcast.ping(reply); ret = replyI.waitReply(5, 5000); if (ret) { break; } replyI = new PingReplyI(); reply = (Test.PingReplyPrx)Test.PingReplyPrxHelper.uncheckedCast(adapter.addWithUUID(replyI)).ice_datagram(); } if (!ret) { Console.Out.WriteLine("failed (is a firewall enabled?)"); } else { Console.Out.WriteLine("ok"); } Console.Out.Write("testing udp bi-dir connection... "); Console.Out.Flush(); obj.ice_getConnection().setAdapter(adapter); objMcast.ice_getConnection().setAdapter(adapter); nRetry = 5; while (nRetry-- > 0) { replyI.reset(); obj.pingBiDir(reply.ice_getIdentity()); obj.pingBiDir(reply.ice_getIdentity()); obj.pingBiDir(reply.ice_getIdentity()); ret = replyI.waitReply(3, 2000); if (ret) { break; // Success } replyI = new PingReplyI(); reply = (PingReplyPrx)PingReplyPrxHelper.uncheckedCast(adapter.addWithUUID(replyI)).ice_datagram(); } test(ret); Console.Out.WriteLine("ok"); // // Sending the replies back on the multicast UDP connection doesn't work for most // platform (it works for macOS Leopard but not Snow Leopard, doesn't work on SLES, // Windows...). For Windows, see UdpTransceiver constructor for the details. So // we don't run this test. // // Console.Out.Write("testing udp bi-dir connection... "); // nRetry = 5; // while(nRetry-- > 0) // { // replyI.reset(); // objMcast.pingBiDir(reply.ice_getIdentity()); // ret = replyI.waitReply(5, 2000); // if(ret) // { // break; // Success // } // replyI = new PingReplyI(); // reply = (PingReplyPrx)PingReplyPrxHelper.uncheckedCast(adapter.addWithUUID(replyI)).ice_datagram(); // } // if(!ret) // { // Console.Out.WriteLine("failed (is a firewall enabled?)"); // } // else // { // Console.Out.WriteLine("ok"); // } }
public override int run(string[] args) { if (args.Length > 0) { Console.Error.WriteLine(appName() + ": too many arguments"); return(1); } string name; do { Console.Out.Write("Please enter your name ==> "); Console.Out.Flush(); name = Console.In.ReadLine(); if (name == null) { return(1); } name = name.Trim(); }while(name.Length == 0); Ice.ObjectPrx basePrx = communicator().propertyToProxy("SessionFactory.Proxy"); SessionFactoryPrx factory = SessionFactoryPrxHelper.checkedCast(basePrx); if (factory == null) { Console.Error.WriteLine("invalid proxy"); return(1); } SessionPrx session = factory.create(name); SessionRefreshThread refresh = new SessionRefreshThread(communicator().getLogger(), 5000, session); Thread refreshThread = new Thread(new ThreadStart(refresh.run)); refreshThread.Start(); List <HelloPrx> hellos = new List <HelloPrx>(); menu(); try { bool destroy = true; bool shutdown = false; while (true) { Console.Out.Write("==> "); Console.Out.Flush(); string line = Console.In.ReadLine(); if (line == null) { break; } if (line.Length > 0 && Char.IsDigit(line[0])) { int index = Int32.Parse(line); if (index < hellos.Count) { HelloPrx hello = hellos[index]; hello.sayHello(); } else { Console.Out.WriteLine("Index is too high. " + hellos.Count + " hello objects exist so far.\n" + "Use `c' to create a new hello object."); } } else if (line.Equals("c")) { hellos.Add(session.createHello()); Console.Out.WriteLine("Created hello object " + (hellos.Count - 1)); } else if (line.Equals("s")) { destroy = false; shutdown = true; break; } else if (line.Equals("x")) { break; } else if (line.Equals("t")) { destroy = false; break; } else if (line.Equals("?")) { menu(); } else { Console.Out.WriteLine("Unknown command `" + line + "'."); menu(); } } // // The refresher thread must be terminated before destroy is // called, otherwise it might get ObjectNotExistException. refresh // is set to 0 so that if session.destroy() raises an exception // the thread will not be re-terminated and re-joined. // refresh.terminate(); refreshThread.Join(); refresh = null; if (destroy) { session.destroy(); } if (shutdown) { factory.shutdown(); } } catch (System.Exception) { // // The refresher thread must be terminated in the event of a // failure. // if (refresh != null) { refresh.terminate(); refreshThread.Join(); refresh = null; } throw; } return(0); }
public static ThrowerPrx allTests(Ice.Communicator communicator) #endif { #if SILVERLIGHT WriteLine("Ice.FactoryAssemblies: " + communicator.getProperties().getProperty("Ice.FactoryAssemblies")); #endif #if !SILVERLIGHT { Write("testing object adapter registration exceptions... "); Ice.ObjectAdapter first; try { first = communicator.createObjectAdapter("TestAdapter0"); } catch (Ice.InitializationException) { // Expected } communicator.getProperties().setProperty("TestAdapter0.Endpoints", "default"); first = communicator.createObjectAdapter("TestAdapter0"); try { communicator.createObjectAdapter("TestAdapter0"); test(false); } catch (Ice.AlreadyRegisteredException) { // Expected. } try { Ice.ObjectAdapter second = communicator.createObjectAdapterWithEndpoints("TestAdapter0", "ssl -h foo -p 12011"); test(false); // // Quell mono error that variable second isn't used. // second.deactivate(); } catch (Ice.AlreadyRegisteredException) { // Expected } first.deactivate(); WriteLine("ok"); } { Write("testing servant registration exceptions... "); communicator.getProperties().setProperty("TestAdapter1.Endpoints", "default"); Ice.ObjectAdapter adapter = communicator.createObjectAdapter("TestAdapter1"); Ice.Object obj = new EmptyI(); adapter.add(obj, communicator.stringToIdentity("x")); try { adapter.add(obj, communicator.stringToIdentity("x")); test(false); } catch (Ice.AlreadyRegisteredException) { } try { adapter.add(obj, communicator.stringToIdentity("")); test(false); } catch (Ice.IllegalIdentityException e) { test(e.id.name.Equals("")); } try { adapter.add(null, communicator.stringToIdentity("x")); test(false); } catch (Ice.IllegalServantException) { } adapter.remove(communicator.stringToIdentity("x")); try { adapter.remove(communicator.stringToIdentity("x")); test(false); } catch (Ice.NotRegisteredException) { } adapter.deactivate(); WriteLine("ok"); } { Write("testing servant locator registration exceptions... "); communicator.getProperties().setProperty("TestAdapter2.Endpoints", "default"); Ice.ObjectAdapter adapter = communicator.createObjectAdapter("TestAdapter2"); Ice.ServantLocator loc = new ServantLocatorI(); adapter.addServantLocator(loc, "x"); try { adapter.addServantLocator(loc, "x"); test(false); } catch (Ice.AlreadyRegisteredException) { } adapter.deactivate(); WriteLine("ok"); } #endif { Write("testing object factory registration exception... "); communicator.getValueFactoryManager().add(_ => { return(null); }, "::x"); try { communicator.getValueFactoryManager().add(_ => { return(null); }, "::x"); test(false); } catch (Ice.AlreadyRegisteredException) { } WriteLine("ok"); } Write("testing stringToProxy... "); Flush(); String @ref = "thrower:default -p 12010"; Ice.ObjectPrx @base = communicator.stringToProxy(@ref); test(@base != null); WriteLine("ok"); Write("testing checked cast... "); Flush(); ThrowerPrx thrower = ThrowerPrxHelper.checkedCast(@base); test(thrower != null); test(thrower.Equals(@base)); WriteLine("ok"); Write("catching exact types... "); Flush(); try { thrower.throwAasA(1); test(false); } catch (A ex) { test(ex.aMem == 1); } catch (Exception) { test(false); } try { thrower.throwAorDasAorD(1); test(false); } catch (A ex) { test(ex.aMem == 1); } catch (Exception) { test(false); } try { thrower.throwAorDasAorD(-1); test(false); } catch (D ex) { test(ex.dMem == -1); } catch (Exception) { test(false); } try { thrower.throwBasB(1, 2); test(false); } catch (B ex) { test(ex.aMem == 1); test(ex.bMem == 2); } catch (Exception) { test(false); } try { thrower.throwCasC(1, 2, 3); test(false); } catch (C ex) { test(ex.aMem == 1); test(ex.bMem == 2); test(ex.cMem == 3); } catch (Exception) { test(false); } WriteLine("ok"); Write("catching base types... "); Flush(); try { thrower.throwBasB(1, 2); test(false); } catch (A ex) { test(ex.aMem == 1); } catch (Exception) { test(false); } try { thrower.throwCasC(1, 2, 3); test(false); } catch (B ex) { test(ex.aMem == 1); test(ex.bMem == 2); } catch (Exception) { test(false); } WriteLine("ok"); Write("catching derived types... "); Flush(); try { thrower.throwBasA(1, 2); test(false); } catch (B ex) { test(ex.aMem == 1); test(ex.bMem == 2); } catch (Exception) { test(false); } try { thrower.throwCasA(1, 2, 3); test(false); } catch (C ex) { test(ex.aMem == 1); test(ex.bMem == 2); test(ex.cMem == 3); } catch (Exception) { test(false); } try { thrower.throwCasB(1, 2, 3); test(false); } catch (C ex) { test(ex.aMem == 1); test(ex.bMem == 2); test(ex.cMem == 3); } catch (Exception) { test(false); } WriteLine("ok"); if (thrower.supportsUndeclaredExceptions()) { Write("catching unknown user exception... "); Flush(); try { thrower.throwUndeclaredA(1); test(false); } catch (Ice.UnknownUserException) { } catch (Exception) { test(false); } try { thrower.throwUndeclaredB(1, 2); test(false); } catch (Ice.UnknownUserException) { } catch (Exception) { test(false); } try { thrower.throwUndeclaredC(1, 2, 3); test(false); } catch (Ice.UnknownUserException) { } catch (Exception) { test(false); } WriteLine("ok"); } if (thrower.ice_getConnection() != null) { Write("testing memory limit marshal exception..."); Flush(); try { thrower.throwMemoryLimitException(null); test(false); } catch (Ice.MemoryLimitException) { } catch (Exception) { test(false); } try { thrower.throwMemoryLimitException(new byte[20 * 1024]); // 20KB test(false); } catch (Ice.ConnectionLostException) { } catch (Exception) { test(false); } ThrowerPrx thrower2 = ThrowerPrxHelper.uncheckedCast( communicator.stringToProxy("thrower:default -p 12011")); try { thrower2.throwMemoryLimitException(new byte[2 * 1024 * 1024]); // 2MB (no limits) } catch (Ice.MemoryLimitException) { } ThrowerPrx thrower3 = ThrowerPrxHelper.uncheckedCast( communicator.stringToProxy("thrower:default -p 12012")); try { thrower3.throwMemoryLimitException(new byte[1024]); // 1KB limit test(false); } catch (Ice.ConnectionLostException) { } WriteLine("ok"); } Write("catching object not exist exception... "); Flush(); { Ice.Identity id = communicator.stringToIdentity("does not exist"); try { ThrowerPrx thrower2 = ThrowerPrxHelper.uncheckedCast(thrower.ice_identity(id)); thrower2.ice_ping(); test(false); } catch (Ice.ObjectNotExistException ex) { test(ex.id.Equals(id)); } catch (Exception) { test(false); } } WriteLine("ok"); Write("catching facet not exist exception... "); Flush(); try { ThrowerPrx thrower2 = ThrowerPrxHelper.uncheckedCast(thrower, "no such facet"); try { thrower2.ice_ping(); test(false); } catch (Ice.FacetNotExistException ex) { test(ex.facet.Equals("no such facet")); } } catch (Exception) { test(false); } WriteLine("ok"); Write("catching operation not exist exception... "); Flush(); try { WrongOperationPrx thrower2 = WrongOperationPrxHelper.uncheckedCast(thrower); thrower2.noSuchOperation(); test(false); } catch (Ice.OperationNotExistException ex) { test(ex.operation.Equals("noSuchOperation")); } catch (Exception) { test(false); } WriteLine("ok"); Write("catching unknown local exception... "); Flush(); try { thrower.throwLocalException(); test(false); } catch (Ice.UnknownLocalException) { } catch (Exception) { test(false); } try { thrower.throwLocalExceptionIdempotent(); test(false); } catch (Ice.UnknownLocalException) { } catch (Ice.OperationNotExistException) { } catch (Exception) { test(false); } WriteLine("ok"); Write("catching unknown non-Ice exception... "); Flush(); try { thrower.throwNonIceException(); test(false); } catch (Ice.UnknownException) { } catch (System.Exception) { test(false); } WriteLine("ok"); Write("testing asynchronous exceptions... "); Flush(); try { thrower.throwAfterResponse(); } catch (Exception) { test(false); } try { thrower.throwAfterException(); test(false); } catch (A) { } catch (Exception) { test(false); } WriteLine("ok"); Write("catching exact types with AMI mapping... "); Flush(); { Callback cb = new Callback(); thrower.begin_throwAasA(1).whenCompleted( () => { test(false); }, (Ice.Exception exc) => { test(exc is A); A ex = exc as A; test(ex.aMem == 1); cb.called(); }); cb.check(); } { Callback cb = new Callback(); thrower.begin_throwAorDasAorD(1).whenCompleted( () => { test(false); }, (Ice.Exception exc) => { try { throw exc; } catch (A ex) { test(ex.aMem == 1); } catch (D ex) { test(ex.dMem == -1); } catch (Exception) { test(false); } cb.called(); }); cb.check(); } { Callback cb = new Callback(); thrower.begin_throwAorDasAorD(-1).whenCompleted( () => { test(false); }, (Ice.Exception exc) => { try { throw exc; } catch (A ex) { test(ex.aMem == 1); } catch (D ex) { test(ex.dMem == -1); } catch (Exception) { test(false); } cb.called(); }); cb.check(); } { Callback cb = new Callback(); thrower.begin_throwBasB(1, 2).whenCompleted( () => { test(false); }, (Ice.Exception exc) => { try { throw exc; } catch (B ex) { test(ex.aMem == 1); test(ex.bMem == 2); } catch (Exception) { test(false); } cb.called(); }); cb.check(); } { Callback cb = new Callback(); thrower.begin_throwCasC(1, 2, 3).whenCompleted( () => { test(false); }, (Ice.Exception exc) => { try { throw exc; } catch (C ex) { test(ex.aMem == 1); test(ex.bMem == 2); test(ex.cMem == 3); } catch (Exception) { test(false); } cb.called(); }); cb.check(); } WriteLine("ok"); Write("catching derived types with new AMI mapping... "); Flush(); { Callback cb = new Callback(); thrower.begin_throwBasA(1, 2).whenCompleted( () => { test(false); }, (Ice.Exception exc) => { try { throw exc; } catch (B ex) { test(ex.aMem == 1); test(ex.bMem == 2); } catch (Exception) { test(false); } cb.called(); }); cb.check(); } { Callback cb = new Callback(); thrower.begin_throwCasA(1, 2, 3).whenCompleted( () => { test(false); }, (Ice.Exception exc) => { try { throw exc; } catch (C ex) { test(ex.aMem == 1); test(ex.bMem == 2); test(ex.cMem == 3); } catch (Exception) { test(false); } cb.called(); }); cb.check(); } { Callback cb = new Callback(); thrower.begin_throwCasB(1, 2, 3).whenCompleted( () => { test(false); }, (Ice.Exception exc) => { try { throw exc; } catch (C ex) { test(ex.aMem == 1); test(ex.bMem == 2); test(ex.cMem == 3); } catch (Exception) { test(false); } cb.called(); }); cb.check(); } WriteLine("ok"); if (thrower.supportsUndeclaredExceptions()) { Write("catching unknown user exception with new AMI mapping... "); Flush(); { Callback cb = new Callback(); thrower.begin_throwUndeclaredA(1).whenCompleted( () => { test(false); }, (Ice.Exception exc) => { try { throw exc; } catch (Ice.UnknownUserException) { } catch (Exception) { test(false); } cb.called(); }); cb.check(); } { Callback cb = new Callback(); thrower.begin_throwUndeclaredB(1, 2).whenCompleted( () => { test(false); }, (Ice.Exception exc) => { try { throw exc; } catch (Ice.UnknownUserException) { } catch (Exception) { test(false); } cb.called(); }); cb.check(); } { Callback cb = new Callback(); thrower.begin_throwUndeclaredC(1, 2, 3).whenCompleted( () => { test(false); }, (Ice.Exception exc) => { try { throw exc; } catch (Ice.UnknownUserException) { } catch (Exception) { test(false); } cb.called(); }); cb.check(); } WriteLine("ok"); } Write("catching object not exist exception with new AMI mapping... "); Flush(); { Ice.Identity id = communicator.stringToIdentity("does not exist"); ThrowerPrx thrower2 = ThrowerPrxHelper.uncheckedCast(thrower.ice_identity(id)); Callback cb = new Callback(); thrower2.begin_throwAasA(1).whenCompleted( () => { test(false); }, (Ice.Exception exc) => { try { throw exc; } catch (Ice.ObjectNotExistException ex) { test(ex.id.Equals(id)); } catch (Exception) { test(false); } cb.called(); }); cb.check(); } WriteLine("ok"); Write("catching facet not exist exception with new AMI mapping... "); Flush(); { ThrowerPrx thrower2 = ThrowerPrxHelper.uncheckedCast(thrower, "no such facet"); Callback cb = new Callback(); thrower2.begin_throwAasA(1).whenCompleted( () => { test(false); }, (Ice.Exception exc) => { try { throw exc; } catch (Ice.FacetNotExistException ex) { test(ex.facet.Equals("no such facet")); } catch (Exception) { test(false); } cb.called(); }); cb.check(); } WriteLine("ok"); Write("catching operation not exist exception with new AMI mapping... "); Flush(); { Callback cb = new Callback(); WrongOperationPrx thrower4 = WrongOperationPrxHelper.uncheckedCast(thrower); thrower4.begin_noSuchOperation().whenCompleted( () => { test(false); }, (Ice.Exception exc) => { try { throw exc; } catch (Ice.OperationNotExistException ex) { test(ex.operation.Equals("noSuchOperation")); } catch (Exception) { test(false); } cb.called(); }); cb.check(); } WriteLine("ok"); Write("catching unknown local exception with new AMI mapping... "); Flush(); { Callback cb = new Callback(); thrower.begin_throwLocalException().whenCompleted( () => { test(false); }, (Ice.Exception exc) => { try { throw exc; } catch (Ice.UnknownLocalException) { } catch (Ice.OperationNotExistException) { } catch (Exception) { test(false); } cb.called(); }); cb.check(); } { Callback cb = new Callback(); thrower.begin_throwLocalExceptionIdempotent().whenCompleted( () => { test(false); }, (Ice.Exception exc) => { try { throw exc; } catch (Ice.UnknownLocalException) { } catch (Ice.OperationNotExistException) { } catch (Exception) { test(false); } cb.called(); }); cb.check(); } WriteLine("ok"); Write("catching unknown non-Ice exception with new AMI mapping... "); Flush(); { Callback cb = new Callback(); thrower.begin_throwNonIceException().whenCompleted( () => { test(false); }, (Ice.Exception exc) => { try { throw exc; } catch (Ice.UnknownException) { } catch (Exception) { test(false); } cb.called(); }); cb.check(); } WriteLine("ok"); // ---------------------------------------- if (thrower.supportsUndeclaredExceptions()) { Write("catching unknown user exception with new AMI mapping... "); Flush(); { Callback cb = new Callback(); thrower.begin_throwUndeclaredA(1).whenCompleted( () => { test(false); }, (Ice.Exception exc) => { try { throw exc; } catch (Ice.UnknownUserException) { } catch (Exception) { test(false); } cb.called(); }); cb.check(); } { Callback cb = new Callback(); thrower.begin_throwUndeclaredB(1, 2).whenCompleted( () => { test(false); }, (Ice.Exception exc) => { try { throw exc; } catch (Ice.UnknownUserException) { } catch (Exception) { test(false); } cb.called(); }); cb.check(); } { Callback cb = new Callback(); thrower.begin_throwUndeclaredC(1, 2, 3).whenCompleted( () => { test(false); }, (Ice.Exception exc) => { try { throw exc; } catch (Ice.UnknownUserException) { } catch (Exception) { test(false); } cb.called(); }); cb.check(); } WriteLine("ok"); } Write("catching object not exist exception with new AMI mapping... "); Flush(); { Ice.Identity id = communicator.stringToIdentity("does not exist"); ThrowerPrx thrower2 = ThrowerPrxHelper.uncheckedCast(thrower.ice_identity(id)); Callback cb = new Callback(); thrower2.begin_throwAasA(1).whenCompleted( () => { test(false); }, (Ice.Exception exc) => { try { throw exc; } catch (Ice.ObjectNotExistException ex) { test(ex.id.Equals(id)); } catch (Exception) { test(false); } cb.called(); }); cb.check(); } WriteLine("ok"); Write("catching facet not exist exception with new AMI mapping... "); Flush(); { ThrowerPrx thrower2 = ThrowerPrxHelper.uncheckedCast(thrower, "no such facet"); Callback cb = new Callback(); thrower2.begin_throwAasA(1).whenCompleted( () => { test(false); }, (Ice.Exception exc) => { try { throw exc; } catch (Ice.FacetNotExistException ex) { test(ex.facet.Equals("no such facet")); } catch (Exception) { test(false); } cb.called(); }); cb.check(); } WriteLine("ok"); Write("catching operation not exist exception with new AMI mapping... "); Flush(); { Callback cb = new Callback(); WrongOperationPrx thrower4 = WrongOperationPrxHelper.uncheckedCast(thrower); thrower4.begin_noSuchOperation().whenCompleted( () => { test(false); }, (Ice.Exception exc) => { try { throw exc; } catch (Ice.OperationNotExistException ex) { test(ex.operation.Equals("noSuchOperation")); } catch (Exception) { test(false); } cb.called(); }); cb.check(); } WriteLine("ok"); Write("catching unknown local exception with new AMI mapping... "); Flush(); { Callback cb = new Callback(); thrower.begin_throwLocalException().whenCompleted( () => { test(false); }, (Ice.Exception exc) => { try { throw exc; } catch (Ice.UnknownLocalException) { } catch (Ice.OperationNotExistException) { } catch (Exception) { test(false); } cb.called(); }); cb.check(); } { Callback cb = new Callback(); thrower.begin_throwLocalExceptionIdempotent().whenCompleted( () => { test(false); }, (Ice.Exception exc) => { try { throw exc; } catch (Ice.UnknownLocalException) { } catch (Ice.OperationNotExistException) { } catch (Exception) { test(false); } cb.called(); }); cb.check(); } WriteLine("ok"); Write("catching unknown non-Ice exception with new AMI mapping... "); Flush(); { Callback cb = new Callback(); thrower.begin_throwNonIceException().whenCompleted( () => { test(false); }, (Ice.Exception exc) => { try { throw exc; } catch (Ice.UnknownException) { } catch (Exception) { test(false); } cb.called(); }); cb.check(); } WriteLine("ok"); #if SILVERLIGHT thrower.shutdown(); #else return(thrower); #endif }
public static void allTests(global::Test.TestHelper helper) { Ice.Communicator communicator = helper.communicator(); var output = helper.getWriter(); output.Write("testing stringToProxy... "); output.Flush(); String @ref = "hold:" + helper.getTestEndpoint(0); Ice.ObjectPrx @base = communicator.stringToProxy(@ref); test(@base != null); String refSerialized = "hold:" + helper.getTestEndpoint(1); Ice.ObjectPrx baseSerialized = communicator.stringToProxy(refSerialized); test(baseSerialized != null); output.WriteLine("ok"); output.Write("testing checked cast... "); output.Flush(); var hold = Test.HoldPrxHelper.checkedCast(@base); var holdOneway = Test.HoldPrxHelper.uncheckedCast(@base.ice_oneway()); test(hold != null); test(hold.Equals(@base)); var holdSerialized = Test.HoldPrxHelper.checkedCast(baseSerialized); var holdSerializedOneway = Test.HoldPrxHelper.uncheckedCast(baseSerialized.ice_oneway()); test(holdSerialized != null); test(holdSerialized.Equals(baseSerialized)); output.WriteLine("ok"); output.Write("changing state between active and hold rapidly... "); output.Flush(); for (int i = 0; i < 100; ++i) { hold.putOnHold(0); } for (int i = 0; i < 100; ++i) { holdOneway.putOnHold(0); } for (int i = 0; i < 100; ++i) { holdSerialized.putOnHold(0); } for (int i = 0; i < 100; ++i) { holdSerializedOneway.putOnHold(0); } output.WriteLine("ok"); output.Write("testing without serialize mode... "); output.Flush(); Random rand = new Random(); { Condition cond = new Condition(true); int value = 0; Ice.AsyncResult result = null; while (cond.value()) { SetCB cb = new SetCB(cond, value); result = hold.begin_set(++value, value < 500 ? rand.Next(5) : 0).whenCompleted(cb.response, cb.exception); if (value % 100 == 0) { result.waitForSent(); } if (value > 100000) { // Don't continue, it's possible that out-of-order dispatch doesn't occur // after 100000 iterations and we don't want the test to last for too long // when this occurs. break; } } test(value > 100000 || !cond.value()); result.waitForSent(); } output.WriteLine("ok"); output.Write("testing with serialize mode... "); output.Flush(); { Condition cond = new Condition(true); int value = 0; Ice.AsyncResult result = null; while (value < 3000 && cond.value()) { SetCB cb = new SetCB(cond, value); result = holdSerialized.begin_set(++value, 0).whenCompleted(cb.response, cb.exception); if (value % 100 == 0) { result.waitForSent(); } } result.waitForCompleted(); test(cond.value()); for (int i = 0; i < 10000; ++i) { holdSerializedOneway.setOneway(value + 1, value); ++value; if ((i % 100) == 0) { holdSerializedOneway.putOnHold(1); } } } output.WriteLine("ok"); output.Write("testing serialization... "); output.Flush(); { int value = 0; holdSerialized.set(value, 0); Ice.AsyncResult result = null; for (int i = 0; i < 10000; ++i) { // Create a new proxy for each request result = ((Test.HoldPrx)holdSerialized.ice_oneway()).begin_setOneway(value + 1, value); ++value; if ((i % 100) == 0) { result.waitForSent(); holdSerialized.ice_ping(); // Ensure everything's dispatched. holdSerialized.ice_getConnection().close(Ice.ConnectionClose.GracefullyWithWait); } } result.waitForCompleted(); } output.WriteLine("ok"); output.Write("testing waitForHold... "); output.Flush(); { hold.waitForHold(); hold.waitForHold(); for (int i = 0; i < 1000; ++i) { holdOneway.ice_ping(); if ((i % 20) == 0) { hold.putOnHold(0); } } hold.putOnHold(-1); hold.ice_ping(); hold.putOnHold(-1); hold.ice_ping(); } output.WriteLine("ok"); output.Write("changing state to hold and shutting down server... "); output.Flush(); hold.shutdown(); output.WriteLine("ok"); }
public static InitialPrx allTests(Ice.Communicator communicator) #endif { communicator.getValueFactoryManager().add(MyValueFactory, "::Test::B"); communicator.getValueFactoryManager().add(MyValueFactory, "::Test::C"); communicator.getValueFactoryManager().add(MyValueFactory, "::Test::D"); communicator.getValueFactoryManager().add(MyValueFactory, "::Test::E"); communicator.getValueFactoryManager().add(MyValueFactory, "::Test::F"); communicator.getValueFactoryManager().add(MyValueFactory, "::Test::I"); communicator.getValueFactoryManager().add(MyValueFactory, "::Test::J"); communicator.getValueFactoryManager().add(MyValueFactory, "::Test::H"); // Disable Obsolete warning/error #pragma warning disable 612, 618 communicator.addObjectFactory(new MyObjectFactory(), "TestOF"); #pragma warning restore 612, 618 Write("testing stringToProxy... "); Flush(); String @ref = "initial:default -p 12010"; Ice.ObjectPrx @base = communicator.stringToProxy(@ref); test(@base != null); WriteLine("ok"); Write("testing checked cast... "); Flush(); InitialPrx initial = InitialPrxHelper.checkedCast(@base); test(initial != null); test(initial.Equals(@base)); WriteLine("ok"); Write("getting B1... "); Flush(); B b1 = initial.getB1(); test(b1 != null); WriteLine("ok"); Write("getting B2... "); Flush(); B b2 = initial.getB2(); test(b2 != null); WriteLine("ok"); Write("getting C... "); Flush(); C c = initial.getC(); test(c != null); WriteLine("ok"); Write("getting D... "); Flush(); D d = initial.getD(); test(d != null); WriteLine("ok"); Write("checking consistency... "); Flush(); test(b1 != b2); //test(b1 != c); //test(b1 != d); //test(b2 != c); //test(b2 != d); //test(c != d); test(b1.theB == b1); test(b1.theC == null); test(b1.theA is B); test(((B)b1.theA).theA == b1.theA); test(((B)b1.theA).theB == b1); //test(((B)b1.theA).theC is C); // Redundant -- theC is always of type C test(((C)(((B)b1.theA).theC)).theB == b1.theA); test(b1.preMarshalInvoked); test(b1.postUnmarshalInvoked()); test(b1.theA.preMarshalInvoked); test(b1.theA.postUnmarshalInvoked()); test(((B)b1.theA).theC.preMarshalInvoked); test(((B)b1.theA).theC.postUnmarshalInvoked()); // More tests possible for b2 and d, but I think this is already // sufficient. test(b2.theA == b2); test(d.theC == null); WriteLine("ok"); Write("getting B1, B2, C, and D all at once... "); Flush(); B b1out; B b2out; C cout; D dout; initial.getAll(out b1out, out b2out, out cout, out dout); test(b1out != null); test(b2out != null); test(cout != null); test(dout != null); WriteLine("ok"); Write("checking consistency... "); Flush(); test(b1out != b2out); test(b1out.theA == b2out); test(b1out.theB == b1out); test(b1out.theC == null); test(b2out.theA == b2out); test(b2out.theB == b1out); test(b2out.theC == cout); test(cout.theB == b2out); test(dout.theA == b1out); test(dout.theB == b2out); test(dout.theC == null); test(dout.preMarshalInvoked); test(dout.postUnmarshalInvoked()); test(dout.theA.preMarshalInvoked); test(dout.theA.postUnmarshalInvoked()); test(dout.theB.preMarshalInvoked); test(dout.theB.postUnmarshalInvoked()); test(dout.theB.theC.preMarshalInvoked); test(dout.theB.theC.postUnmarshalInvoked()); WriteLine("ok"); Write("testing protected members... "); Flush(); E e = initial.getE(); test(e.checkValues()); System.Reflection.BindingFlags flags = System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance; test(!typeof(E).GetField("i", flags).IsPublic&& !typeof(E).GetField("i", flags).IsPrivate); test(!typeof(E).GetField("s", flags).IsPublic&& !typeof(E).GetField("s", flags).IsPrivate); F f = initial.getF(); test(f.checkValues()); test(f.e2.checkValues()); test(!typeof(F).GetField("e1", flags).IsPublic&& !typeof(F).GetField("e1", flags).IsPrivate); test(typeof(F).GetField("e2", flags).IsPublic&& !typeof(F).GetField("e2", flags).IsPrivate); WriteLine("ok"); Write("getting I, J and H... "); Flush(); I i = initial.getI(); test(i != null); I j = initial.getJ(); test(j != null && ((J)j) != null); I h = initial.getH(); test(h != null && ((H)h) != null); WriteLine("ok"); Write("getting D1... "); Flush(); D1 d1 = new D1(new A1("a1"), new A1("a2"), new A1("a3"), new A1("a4")); d1 = initial.getD1(d1); test(d1.a1.name.Equals("a1")); test(d1.a2.name.Equals("a2")); test(d1.a3.name.Equals("a3")); test(d1.a4.name.Equals("a4")); WriteLine("ok"); Write("throw EDerived... "); Flush(); try { initial.throwEDerived(); test(false); } catch (EDerived ederived) { test(ederived.a1.name.Equals("a1")); test(ederived.a2.name.Equals("a2")); test(ederived.a3.name.Equals("a3")); test(ederived.a4.name.Equals("a4")); } WriteLine("ok"); Write("setting I... "); Flush(); initial.setI(i); initial.setI(j); initial.setI(h); WriteLine("ok"); Write("testing sequences..."); Flush(); try { Base[] inS = new Base[0]; Base[] outS; Base[] retS; retS = initial.opBaseSeq(inS, out outS); inS = new Base[1]; inS[0] = new Base(new S(), ""); retS = initial.opBaseSeq(inS, out outS); test(retS.Length == 1 && outS.Length == 1); } catch (Ice.OperationNotExistException) { } WriteLine("ok"); Write("testing compact ID..."); Flush(); try { test(initial.getCompact() != null); } catch (Ice.OperationNotExistException) { } WriteLine("ok"); Write("testing UnexpectedObjectException..."); Flush(); @ref = "uoet:default -p 12010"; @base = communicator.stringToProxy(@ref); test(@base != null); UnexpectedObjectExceptionTestPrx uoet = UnexpectedObjectExceptionTestPrxHelper.uncheckedCast(@base); test(uoet != null); try { uoet.op(); test(false); } catch (Ice.UnexpectedObjectException ex) { test(ex.type.Equals("::Test::AlsoEmpty")); test(ex.expectedType.Equals("::Test::Empty")); } catch (System.Exception ex) { WriteLine(ex.ToString()); test(false); } WriteLine("ok"); // Disable Obsolete warning/error #pragma warning disable 612, 618 Write("testing getting ObjectFactory..."); Flush(); test(communicator.findObjectFactory("TestOF") != null); WriteLine("ok"); Write("testing getting ObjectFactory as ValueFactory..."); Flush(); test(communicator.getValueFactoryManager().find("TestOF") != null); WriteLine("ok"); #pragma warning restore 612, 618 #if SILVERLIGHT initial.shutdown(); #else return(initial); #endif }
public static int Main(string[] args) { int status = 0; Ice.Communicator communicator = null; try { System.Console.Error.Write("testing proxy & endpoint hash algorithm collisions... "); System.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); { System.Random rand = new System.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); } } { System.Random rand = new System.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)); System.Console.Error.WriteLine("ok"); System.Console.Error.Write("testing exceptions hash algorithm collisions... "); { Dictionary <int, Test.OtherException> seenException = new Dictionary <int, Test.OtherException>(); System.Random rand = new System.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>(); System.Random rand = new System.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>(); System.Random rand = new System.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); } System.Console.Error.WriteLine("ok"); System.Console.Error.Write("testing struct hash algorithm collisions... "); { Dictionary <int, Test.PointF> seenPointF = new Dictionary <int, Test.PointF>(); System.Random rand = new System.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); } System.Console.Error.WriteLine("ok"); if (communicator != null) { try { communicator.destroy(); } catch (Ice.LocalException ex) { System.Console.Error.WriteLine(ex); status = 1; } } } catch (Exception ex) { Console.WriteLine(ex.ToString()); status = 1; } return(status); }
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
public static TestIntfPrx allTests(Ice.Communicator communicator, bool collocated) #endif { Write("testing stringToProxy... "); Flush(); String @ref = "Test:default -p 12010 -t 2000"; Ice.ObjectPrx @base = communicator.stringToProxy(@ref); test(@base != null); WriteLine("ok"); Write("testing checked cast... "); Flush(); TestIntfPrx testPrx = TestIntfPrxHelper.checkedCast(@base); test(testPrx != null); test(testPrx.Equals(@base)); WriteLine("ok"); Write("base... "); Flush(); { try { testPrx.baseAsBase(); test(false); } catch (Base b) { test(b.b.Equals("Base.b")); test(b.GetType().FullName.Equals("Test.Base")); } catch (Exception) { test(false); } } WriteLine("ok"); Write("base (AMI)... "); Flush(); { Callback cb = new Callback(); testPrx.begin_baseAsBase().whenCompleted( () => { test(false); }, (Ice.Exception ex) => { try { throw ex; } catch (Base b) { test(b.b.Equals("Base.b")); test(b.GetType().Name.Equals("Base")); } catch (Exception) { test(false); } cb.called(); }); cb.check(); } WriteLine("ok"); Write("slicing of unknown derived... "); Flush(); { try { testPrx.unknownDerivedAsBase(); test(false); } catch (Base b) { test(b.b.Equals("UnknownDerived.b")); test(b.GetType().FullName.Equals("Test.Base")); } catch (Exception) { test(false); } } WriteLine("ok"); Write("slicing of unknown derived (AMI)... "); Flush(); { Callback cb = new Callback(); testPrx.begin_unknownDerivedAsBase().whenCompleted( () => { test(false); }, (Ice.Exception ex) => { try { throw ex; } catch (Base b) { test(b.b.Equals("UnknownDerived.b")); test(b.GetType().Name.Equals("Base")); } catch (Exception) { test(false); } cb.called(); }); cb.check(); } WriteLine("ok"); Write("non-slicing of known derived as base... "); Flush(); { try { testPrx.knownDerivedAsBase(); test(false); } catch (KnownDerived k) { test(k.b.Equals("KnownDerived.b")); test(k.kd.Equals("KnownDerived.kd")); test(k.GetType().FullName.Equals("Test.KnownDerived")); } catch (Exception) { test(false); } } WriteLine("ok"); Write("non-slicing of known derived as base (AMI)... "); Flush(); { Callback cb = new Callback(); testPrx.begin_knownDerivedAsBase().whenCompleted( () => { test(false); }, (Ice.Exception ex) => { try { throw ex; } catch (KnownDerived k) { test(k.b.Equals("KnownDerived.b")); test(k.kd.Equals("KnownDerived.kd")); test(k.GetType().Name.Equals("KnownDerived")); } catch (Exception) { test(false); } cb.called(); }); cb.check(); } WriteLine("ok"); Write("non-slicing of known derived as derived... "); Flush(); { try { testPrx.knownDerivedAsKnownDerived(); test(false); } catch (KnownDerived k) { test(k.b.Equals("KnownDerived.b")); test(k.kd.Equals("KnownDerived.kd")); test(k.GetType().FullName.Equals("Test.KnownDerived")); } catch (Exception) { test(false); } } WriteLine("ok"); Write("non-slicing of known derived as derived (AMI)... "); Flush(); { Callback cb = new Callback(); testPrx.begin_knownDerivedAsKnownDerived().whenCompleted( () => { test(false); }, (Ice.Exception ex) => { try { throw ex; } catch (KnownDerived k) { test(k.b.Equals("KnownDerived.b")); test(k.kd.Equals("KnownDerived.kd")); test(k.GetType().Name.Equals("KnownDerived")); } catch (Exception) { test(false); } cb.called(); }); cb.check(); } WriteLine("ok"); Write("slicing of unknown intermediate as base... "); Flush(); { try { testPrx.unknownIntermediateAsBase(); test(false); } catch (Base b) { test(b.b.Equals("UnknownIntermediate.b")); test(b.GetType().FullName.Equals("Test.Base")); } catch (Exception) { test(false); } } WriteLine("ok"); Write("slicing of unknown intermediate as base (AMI)... "); Flush(); { Callback cb = new Callback(); testPrx.begin_unknownIntermediateAsBase().whenCompleted( () => { test(false); }, (Ice.Exception ex) => { try { throw ex; } catch (Base b) { test(b.b.Equals("UnknownIntermediate.b")); test(b.GetType().Name.Equals("Base")); } catch (Exception) { test(false); } cb.called(); }); cb.check(); } WriteLine("ok"); Write("slicing of known intermediate as base... "); Flush(); { try { testPrx.knownIntermediateAsBase(); test(false); } catch (KnownIntermediate ki) { test(ki.b.Equals("KnownIntermediate.b")); test(ki.ki.Equals("KnownIntermediate.ki")); test(ki.GetType().FullName.Equals("Test.KnownIntermediate")); } catch (Exception) { test(false); } } WriteLine("ok"); Write("slicing of known intermediate as base (AMI)... "); Flush(); { Callback cb = new Callback(); testPrx.begin_knownIntermediateAsBase().whenCompleted( () => { test(false); }, (Ice.Exception ex) => { try { throw ex; } catch (KnownIntermediate ki) { test(ki.b.Equals("KnownIntermediate.b")); test(ki.ki.Equals("KnownIntermediate.ki")); test(ki.GetType().Name.Equals("KnownIntermediate")); } catch (Exception) { test(false); } cb.called(); }); cb.check(); } WriteLine("ok"); Write("slicing of known most derived as base... "); Flush(); { try { testPrx.knownMostDerivedAsBase(); test(false); } catch (KnownMostDerived kmd) { test(kmd.b.Equals("KnownMostDerived.b")); test(kmd.ki.Equals("KnownMostDerived.ki")); test(kmd.kmd.Equals("KnownMostDerived.kmd")); test(kmd.GetType().FullName.Equals("Test.KnownMostDerived")); } catch (Exception) { test(false); } } WriteLine("ok"); Write("slicing of known most derived as base (AMI)... "); Flush(); { Callback cb = new Callback(); testPrx.begin_knownMostDerivedAsBase().whenCompleted( () => { test(false); }, (Ice.Exception ex) => { try { throw ex; } catch (KnownMostDerived kmd) { test(kmd.b.Equals("KnownMostDerived.b")); test(kmd.ki.Equals("KnownMostDerived.ki")); test(kmd.kmd.Equals("KnownMostDerived.kmd")); test(kmd.GetType().Name.Equals("KnownMostDerived")); } catch (Exception) { test(false); } cb.called(); }); cb.check(); } WriteLine("ok"); Write("non-slicing of known intermediate as intermediate... "); Flush(); { try { testPrx.knownIntermediateAsKnownIntermediate(); test(false); } catch (KnownIntermediate ki) { test(ki.b.Equals("KnownIntermediate.b")); test(ki.ki.Equals("KnownIntermediate.ki")); test(ki.GetType().FullName.Equals("Test.KnownIntermediate")); } catch (Exception) { test(false); } } WriteLine("ok"); Write("non-slicing of known intermediate as intermediate (AMI)... "); Flush(); { Callback cb = new Callback(); testPrx.begin_knownIntermediateAsKnownIntermediate().whenCompleted( () => { test(false); }, (Ice.Exception ex) => { try { throw ex; } catch (KnownIntermediate ki) { test(ki.b.Equals("KnownIntermediate.b")); test(ki.ki.Equals("KnownIntermediate.ki")); test(ki.GetType().Name.Equals("KnownIntermediate")); } catch (Exception) { test(false); } cb.called(); }); cb.check(); } WriteLine("ok"); Write("non-slicing of known most derived as intermediate... "); Flush(); { try { testPrx.knownMostDerivedAsKnownIntermediate(); test(false); } catch (KnownMostDerived kmd) { test(kmd.b.Equals("KnownMostDerived.b")); test(kmd.ki.Equals("KnownMostDerived.ki")); test(kmd.kmd.Equals("KnownMostDerived.kmd")); test(kmd.GetType().FullName.Equals("Test.KnownMostDerived")); } catch (Exception) { test(false); } } WriteLine("ok"); Write("non-slicing of known most derived as intermediate (AMI)... "); Flush(); { Callback cb = new Callback(); testPrx.begin_knownMostDerivedAsKnownIntermediate().whenCompleted( () => { test(false); }, (Ice.Exception ex) => { try { throw ex; } catch (KnownMostDerived kmd) { test(kmd.b.Equals("KnownMostDerived.b")); test(kmd.ki.Equals("KnownMostDerived.ki")); test(kmd.kmd.Equals("KnownMostDerived.kmd")); test(kmd.GetType().Name.Equals("KnownMostDerived")); } catch (Exception) { test(false); } cb.called(); }); cb.check(); } WriteLine("ok"); Write("non-slicing of known most derived as most derived... "); Flush(); { try { testPrx.knownMostDerivedAsKnownMostDerived(); test(false); } catch (KnownMostDerived kmd) { test(kmd.b.Equals("KnownMostDerived.b")); test(kmd.ki.Equals("KnownMostDerived.ki")); test(kmd.kmd.Equals("KnownMostDerived.kmd")); test(kmd.GetType().FullName.Equals("Test.KnownMostDerived")); } catch (Exception) { test(false); } } WriteLine("ok"); Write("non-slicing of known most derived as most derived (AMI)... "); Flush(); { Callback cb = new Callback(); testPrx.begin_knownMostDerivedAsKnownMostDerived().whenCompleted( () => { test(false); }, (Ice.Exception ex) => { try { throw ex; } catch (KnownMostDerived kmd) { test(kmd.b.Equals("KnownMostDerived.b")); test(kmd.ki.Equals("KnownMostDerived.ki")); test(kmd.kmd.Equals("KnownMostDerived.kmd")); test(kmd.GetType().Name.Equals("KnownMostDerived")); } catch (Exception) { test(false); } cb.called(); }); cb.check(); } WriteLine("ok"); Write("slicing of unknown most derived, known intermediate as base... "); Flush(); { try { testPrx.unknownMostDerived1AsBase(); test(false); } catch (KnownIntermediate ki) { test(ki.b.Equals("UnknownMostDerived1.b")); test(ki.ki.Equals("UnknownMostDerived1.ki")); test(ki.GetType().FullName.Equals("Test.KnownIntermediate")); } catch (Exception) { test(false); } } WriteLine("ok"); Write("slicing of unknown most derived, known intermediate as base (AMI)... "); Flush(); { Callback cb = new Callback(); testPrx.begin_unknownMostDerived1AsBase().whenCompleted( () => { test(false); }, (Ice.Exception ex) => { try { throw ex; } catch (KnownIntermediate ki) { test(ki.b.Equals("UnknownMostDerived1.b")); test(ki.ki.Equals("UnknownMostDerived1.ki")); test(ki.GetType().Name.Equals("KnownIntermediate")); } catch (Exception) { test(false); } cb.called(); }); cb.check(); } WriteLine("ok"); Write("slicing of unknown most derived, known intermediate as intermediate... "); Flush(); { try { testPrx.unknownMostDerived1AsKnownIntermediate(); test(false); } catch (KnownIntermediate ki) { test(ki.b.Equals("UnknownMostDerived1.b")); test(ki.ki.Equals("UnknownMostDerived1.ki")); test(ki.GetType().FullName.Equals("Test.KnownIntermediate")); } catch (Exception) { test(false); } } WriteLine("ok"); Write("slicing of unknown most derived, known intermediate as intermediate (AMI)... "); Flush(); { Callback cb = new Callback(); testPrx.begin_unknownMostDerived1AsKnownIntermediate().whenCompleted( () => { test(false); }, (Ice.Exception ex) => { try { throw ex; } catch (KnownIntermediate ki) { test(ki.b.Equals("UnknownMostDerived1.b")); test(ki.ki.Equals("UnknownMostDerived1.ki")); test(ki.GetType().Name.Equals("KnownIntermediate")); } catch (Exception) { test(false); } cb.called(); }); cb.check(); } WriteLine("ok"); Write("slicing of unknown most derived, unknown intermediate thrown as base... "); Flush(); { try { testPrx.unknownMostDerived2AsBase(); test(false); } catch (Base b) { test(b.b.Equals("UnknownMostDerived2.b")); test(b.GetType().FullName.Equals("Test.Base")); } catch (Exception) { test(false); } } WriteLine("ok"); Write("slicing of unknown most derived, unknown intermediate thrown as base (AMI)... "); Flush(); { Callback cb = new Callback(); testPrx.begin_unknownMostDerived2AsBase().whenCompleted( () => { test(false); }, (Ice.Exception ex) => { try { throw ex; } catch (Base b) { test(b.b.Equals("UnknownMostDerived2.b")); test(b.GetType().Name.Equals("Base")); } catch (Exception) { test(false); } cb.called(); }); cb.check(); } WriteLine("ok"); Write("unknown most derived in compact format... "); Flush(); { try { testPrx.unknownMostDerived2AsBaseCompact(); test(false); } catch (Base) { // // For the 1.0 encoding, the unknown exception is sliced to Base. // test(testPrx.ice_getEncodingVersion().Equals(Ice.Util.Encoding_1_0)); } catch (Ice.UnknownUserException) { // // A MarshalException is raised for the compact format because the // most-derived type is unknown and the exception cannot be sliced. // test(!testPrx.ice_getEncodingVersion().Equals(Ice.Util.Encoding_1_0)); } catch (Ice.OperationNotExistException) { } catch (Exception) { test(false); } } WriteLine("ok"); // // No server side in Silverlight // #if !SILVERLIGHT Write("preserved exceptions... "); Flush(); { Ice.ObjectAdapter adapter = communicator.createObjectAdapterWithEndpoints("Relay", "default"); RelayPrx relay = RelayPrxHelper.uncheckedCast(adapter.addWithUUID(new RelayI())); adapter.activate(); try { testPrx.relayKnownPreservedAsBase(relay); test(false); } catch (KnownPreservedDerived ex) { test(ex.b.Equals("base")); test(ex.kp.Equals("preserved")); test(ex.kpd.Equals("derived")); } catch (Ice.OperationNotExistException) { } catch (Exception) { test(false); } try { testPrx.relayKnownPreservedAsKnownPreserved(relay); test(false); } catch (KnownPreservedDerived ex) { test(ex.b.Equals("base")); test(ex.kp.Equals("preserved")); test(ex.kpd.Equals("derived")); } /* * catch(Exception) * { * test(false); * } */ catch (Ice.OperationNotExistException) { } catch (Exception) { test(false); } try { testPrx.relayUnknownPreservedAsBase(relay); test(false); } catch (Preserved2 ex) { test(ex.b.Equals("base")); test(ex.kp.Equals("preserved")); test(ex.kpd.Equals("derived")); test(ex.p1.ice_id().Equals(PreservedClass.ice_staticId())); PreservedClass pc = ex.p1 as PreservedClass; test(pc.bc.Equals("bc")); test(pc.pc.Equals("pc")); test(ex.p2 == ex.p1); } catch (KnownPreservedDerived ex) { // // For the 1.0 encoding, the unknown exception is sliced to KnownPreserved. // test(testPrx.ice_getEncodingVersion().Equals(Ice.Util.Encoding_1_0)); test(ex.b.Equals("base")); test(ex.kp.Equals("preserved")); test(ex.kpd.Equals("derived")); } catch (Ice.OperationNotExistException) { } catch (Exception) { test(false); } try { testPrx.relayUnknownPreservedAsKnownPreserved(relay); test(false); } catch (Preserved2 ex) { test(ex.b.Equals("base")); test(ex.kp.Equals("preserved")); test(ex.kpd.Equals("derived")); test(ex.p1.ice_id().Equals(PreservedClass.ice_staticId())); PreservedClass pc = ex.p1 as PreservedClass; test(pc.bc.Equals("bc")); test(pc.pc.Equals("pc")); test(ex.p2 == ex.p1); } catch (KnownPreservedDerived ex) { // // For the 1.0 encoding, the unknown exception is sliced to KnownPreserved. // test(testPrx.ice_getEncodingVersion().Equals(Ice.Util.Encoding_1_0)); test(ex.b.Equals("base")); test(ex.kp.Equals("preserved")); test(ex.kpd.Equals("derived")); } catch (Ice.OperationNotExistException) { } catch (Exception) { test(false); } adapter.destroy(); } WriteLine("ok"); #endif #if SILVERLIGHT testPrx.shutdown(); #else return(testPrx); #endif }
public void initialize() { Ice.Properties properties = _communicator.getProperties(); bool ipv4 = properties.getPropertyAsIntWithDefault("Ice.IPv4", 1) > 0; bool preferIPv6 = properties.getPropertyAsInt("Ice.PreferIPv6Address") > 0; string address; if (ipv4 && !preferIPv6) { address = properties.getPropertyWithDefault("IceDiscovery.Address", "239.255.0.1"); } else { address = properties.getPropertyWithDefault("IceDiscovery.Address", "ff15::1"); } int port = properties.getPropertyAsIntWithDefault("IceDiscovery.Port", 4061); string intf = properties.getProperty("IceDiscovery.Interface"); if (properties.getProperty("IceDiscovery.Multicast.Endpoints").Length == 0) { StringBuilder s = new StringBuilder(); s.Append("udp -h \"").Append(address).Append("\" -p ").Append(port); if (intf.Length != 0) { s.Append(" --interface \"").Append(intf).Append("\""); } properties.setProperty("IceDiscovery.Multicast.Endpoints", s.ToString()); } string lookupEndpoints = properties.getProperty("IceDiscovery.Lookup"); if (lookupEndpoints.Length == 0) { int protocol = ipv4 && !preferIPv6 ? IceInternal.Network.EnableIPv4 : IceInternal.Network.EnableIPv6; var interfaces = IceInternal.Network.getInterfacesForMulticast(intf, protocol); foreach (string p in interfaces) { if (p != interfaces[0]) { lookupEndpoints += ":"; } lookupEndpoints += "udp -h \"" + address + "\" -p " + port + " --interface \"" + p + "\""; } } if (properties.getProperty("IceDiscovery.Reply.Endpoints").Length == 0) { properties.setProperty("IceDiscovery.Reply.Endpoints", "udp -h " + (intf.Length == 0 ? "*" : "\"" + intf + "\"")); } if (properties.getProperty("IceDiscovery.Locator.Endpoints").Length == 0) { properties.setProperty("IceDiscovery.Locator.AdapterId", Guid.NewGuid().ToString()); } _multicastAdapter = _communicator.createObjectAdapter("IceDiscovery.Multicast"); _replyAdapter = _communicator.createObjectAdapter("IceDiscovery.Reply"); _locatorAdapter = _communicator.createObjectAdapter("IceDiscovery.Locator"); // // Setup locatory registry. // LocatorRegistryI locatorRegistry = new LocatorRegistryI(_communicator); Ice.LocatorRegistryPrx locatorRegistryPrx = Ice.LocatorRegistryPrxHelper.uncheckedCast( _locatorAdapter.addWithUUID(locatorRegistry)); Ice.ObjectPrx lookupPrx = _communicator.stringToProxy("IceDiscovery/Lookup -d:" + lookupEndpoints); // No colloc optimization or router for the multicast proxy! lookupPrx = lookupPrx.ice_collocationOptimized(false).ice_router(null); // // Add lookup and lookup reply Ice objects // LookupI lookup = new LookupI(locatorRegistry, LookupPrxHelper.uncheckedCast(lookupPrx), properties); _multicastAdapter.add(lookup, Ice.Util.stringToIdentity("IceDiscovery/Lookup")); _replyAdapter.addDefaultServant(new LookupReplyI(lookup), ""); Ice.Identity id = new Ice.Identity("dummy", ""); lookup.setLookupReply(LookupReplyPrxHelper.uncheckedCast(_replyAdapter.createProxy(id).ice_datagram())); // // Setup locator on the communicator. // Ice.ObjectPrx loc; loc = _locatorAdapter.addWithUUID( new LocatorI(lookup, Ice.LocatorRegistryPrxHelper.uncheckedCast(locatorRegistryPrx))); _defaultLocator = _communicator.getDefaultLocator(); _locator = Ice.LocatorPrxHelper.uncheckedCast(loc); _communicator.setDefaultLocator(_locator); _multicastAdapter.activate(); _replyAdapter.activate(); _locatorAdapter.activate(); }
public string proxyToString(Ice.ObjectPrx proxy) { return(instance_.proxyFactory().proxyToString(proxy)); }
public Dictionary <string, string> proxyToProperty(Ice.ObjectPrx proxy, string prefix) { return(instance_.proxyFactory().proxyToProperty(proxy, prefix)); }
public LocatorRegistryI(Ice.Communicator com) { _wellKnownProxy = com.stringToProxy("p").ice_locator(null).ice_router(null).ice_collocationOptimized(true); }
public override void addObject(Ice.ObjectPrx obj, Ice.Current current) { addObject(obj); }
/// <summary> /// Initializes a new instance of the /// <see cref="T:Ferda.Modules.BoxModuleI"/> class. /// </summary> /// <param name="boxInfo">The box info.</param> /// <param name="myIdentity">My identity.</param> /// <param name="myFactoryProxy">My factory proxy.</param> /// <param name="manager">The manager.</param> /// <param name="adapter">The adapter.</param> /// <param name="localePrefs">The localization preferences.</param> public BoxModuleI(IBoxInfo boxInfo, Ice.Identity myIdentity, BoxModuleFactoryPrx myFactoryProxy, Ferda.ModulesManager.ManagersEnginePrx manager, Ice.ObjectAdapter adapter, string[] localePrefs) { System.Diagnostics.Debug.WriteLine("BoxModuleI Constructor (entering): " + boxInfo.Identifier); // initializes inner fields by specified parameters this.boxInfo = boxInfo; this.iceIdentity = myIdentity; this.stringIceIdentity = Ice.Util.identityToString(IceIdentity); this.myFactoryProxy = myFactoryProxy; this.manager = manager; this.adapter = adapter; this.localePrefs = localePrefs; // add the new box module to the specified adapter adapter.add(this, this.iceIdentity); // get my proxy this.myProxy = BoxModulePrxHelper.uncheckedCast(adapter.createProxy(myIdentity)); // initializes box module`s functions object this.boxInfo.CreateFunctions(this, out this.functionsIceObj, out this.functionsIObj); this.functionsIObj.setBoxModuleInfo(this, this.boxInfo); this.functionsObjPrx = Ice.ObjectPrxHelper.uncheckedCast(adapter.addWithUUID(this.functionsIceObj)); // initializes properties this.properties = new Dictionary<string, PropertyValue>(); foreach (string propertyName in boxInfo.GetPropertiesNames()) { if (!boxInfo.IsPropertyReadOnly(propertyName)) { this.setProperty(propertyName, boxInfo.GetPropertyDefaultValue(propertyName)); } } // initializes sockets (connections and functions) this.connections = new Dictionary<string, Dictionary<string, BoxModulePrx>>(); foreach (string socketName in boxInfo.GetSocketNames()) { connections[socketName] = new Dictionary<string, BoxModulePrx>(); } System.Diagnostics.Debug.WriteLine("BoxModuleI Constructor (leaving): " + this.boxInfo.Identifier); }
public void addObject(Ice.ObjectPrx obj) { _objects[obj.ice_getIdentity()] = obj; }
public void flushBatch() { Debug.Assert(_batchProxy != null); _batchProxy.ice_flushBatchRequests(); _batchProxy = null; }
public static void allTests(TestCommon.Application app) { Ice.Communicator communicator = app.communicator(); Console.Out.Write("testing stringToProxy... "); Console.Out.Flush(); String rf = "test @ TestAdapter"; Ice.ObjectPrx @base = communicator.stringToProxy(rf); test(@base != null); Console.Out.WriteLine("ok"); Console.Out.Write("testing IceGrid.Locator is present... "); IceGrid.LocatorPrx locator = IceGrid.LocatorPrxHelper.uncheckedCast(@base); test(locator != null); Console.Out.WriteLine("ok"); Console.Out.Write("testing checked cast... "); Console.Out.Flush(); TestIntfPrx obj = TestIntfPrxHelper.checkedCast(@base); test(obj != null); test(obj.Equals(@base)); Console.Out.WriteLine("ok"); Console.Out.Write("pinging server... "); Console.Out.Flush(); obj.ice_ping(); Console.Out.WriteLine("ok"); Console.Out.Write("testing locator finder... "); Ice.Identity finderId = new Ice.Identity(); finderId.category = "Ice"; finderId.name = "LocatorFinder"; Ice.LocatorFinderPrx finder = Ice.LocatorFinderPrxHelper.checkedCast( communicator.getDefaultLocator().ice_identity(finderId)); test(finder.getLocator() != null); Console.Out.WriteLine("ok"); Console.Out.Write("testing discovery... "); { // Add test well-known object IceGrid.RegistryPrx registry = IceGrid.RegistryPrxHelper.checkedCast( communicator.stringToProxy(communicator.getDefaultLocator().ice_getIdentity().category + "/Registry")); test(registry != null); try { IceGrid.AdminSessionPrx session = registry.createAdminSession("foo", "bar"); session.getAdmin().addObjectWithType(@base, "::Test"); session.destroy(); } catch (Ice.UserException) { test(false); } // // Ensure the IceGrid discovery locator can discover the // registries and make sure locator requests are forwarded. // Ice.InitializationData initData = new Ice.InitializationData(); initData.properties = communicator.getProperties().ice_clone_(); initData.properties.setProperty("Ice.Default.Locator", ""); initData.properties.setProperty("Ice.Plugin.IceLocatorDiscovery", "IceLocatorDiscovery:IceLocatorDiscovery.PluginFactory"); initData.properties.setProperty("IceLocatorDiscovery.Port", app.getTestPort(99).ToString()); initData.properties.setProperty("AdapterForDiscoveryTest.AdapterId", "discoveryAdapter"); initData.properties.setProperty("AdapterForDiscoveryTest.Endpoints", "default"); Ice.Communicator com = Ice.Util.initialize(initData); test(com.getDefaultLocator() != null); com.stringToProxy("test @ TestAdapter").ice_ping(); com.stringToProxy("test").ice_ping(); test(com.getDefaultLocator().getRegistry() != null); test(IceGrid.LocatorPrxHelper.uncheckedCast(com.getDefaultLocator()).getLocalRegistry() != null); test(IceGrid.LocatorPrxHelper.uncheckedCast(com.getDefaultLocator()).getLocalQuery() != null); Ice.ObjectAdapter adapter = com.createObjectAdapter("AdapterForDiscoveryTest"); adapter.activate(); adapter.deactivate(); com.destroy(); // // Now, ensure that the IceGrid discovery locator correctly // handles failure to find a locator. // initData.properties.setProperty("IceLocatorDiscovery.InstanceName", "unknown"); initData.properties.setProperty("IceLocatorDiscovery.RetryCount", "1"); initData.properties.setProperty("IceLocatorDiscovery.Timeout", "100"); com = Ice.Util.initialize(initData); test(com.getDefaultLocator() != null); try { com.stringToProxy("test @ TestAdapter").ice_ping(); } catch (Ice.NoEndpointException) { } try { com.stringToProxy("test").ice_ping(); } catch (Ice.NoEndpointException) { } test(com.getDefaultLocator().getRegistry() == null); test(IceGrid.LocatorPrxHelper.checkedCast(com.getDefaultLocator()) == null); try { IceGrid.LocatorPrxHelper.uncheckedCast(com.getDefaultLocator()).getLocalRegistry(); } catch (Ice.OperationNotExistException) { } adapter = com.createObjectAdapter("AdapterForDiscoveryTest"); adapter.activate(); adapter.deactivate(); com.destroy(); string multicast; if (communicator.getProperties().getProperty("Ice.IPv6").Equals("1")) { multicast = "\"ff15::1\""; } else { multicast = "239.255.0.1"; } // // Test invalid lookup endpoints // initData.properties = communicator.getProperties().ice_clone_(); initData.properties.setProperty("Ice.Default.Locator", ""); initData.properties.setProperty("Ice.Plugin.IceLocatorDiscovery", "IceLocatorDiscovery:IceLocatorDiscovery.PluginFactory"); initData.properties.setProperty("IceLocatorDiscovery.Lookup", "udp -h " + multicast + " --interface unknown"); com = Ice.Util.initialize(initData); test(com.getDefaultLocator() != null); try { com.stringToProxy("test @ TestAdapter").ice_ping(); test(false); } catch (Ice.NoEndpointException) { } com.destroy(); initData.properties = communicator.getProperties().ice_clone_(); initData.properties.setProperty("Ice.Default.Locator", ""); initData.properties.setProperty("Ice.Plugin.IceLocatorDiscovery", "IceLocatorDiscovery:IceLocatorDiscovery.PluginFactory"); { string intf = initData.properties.getProperty("IceLocatorDiscovery.Interface"); if (!intf.Equals("")) { intf = " --interface \"" + intf + "\""; } string port = app.getTestPort(99).ToString(); initData.properties.setProperty("IceLocatorDiscovery.Lookup", "udp -h " + multicast + " --interface unknown:" + "udp -h " + multicast + " -p " + port + intf); } com = Ice.Util.initialize(initData); test(com.getDefaultLocator() != null); try { com.stringToProxy("test @ TestAdapter").ice_ping(); } catch (Ice.NoEndpointException) { test(false); } com.destroy(); } Console.Out.WriteLine("ok"); Console.Out.Write("shutting down server... "); Console.Out.Flush(); obj.shutdown(); Console.Out.WriteLine("ok"); }
public void response(Ice.ObjectPrx proxy) { lock(this) { _locatorInfo.finishRequest(_ref, _wellKnownRefs, proxy, false); _response = true; _proxy = proxy; System.Threading.Monitor.PulseAll(this); } foreach(RequestCallback callback in _callbacks) { callback.response(_locatorInfo, proxy); } }
allTestsWithDeploy(TestCommon.Application app) { Ice.Communicator communicator = app.communicator(); Console.Out.Write("testing stringToProxy... "); Console.Out.Flush(); Ice.ObjectPrx @base = communicator.stringToProxy("test @ TestAdapter"); test(@base != null); Ice.ObjectPrx @base2 = communicator.stringToProxy("test"); test(@base2 != null); Console.Out.WriteLine("ok"); Console.Out.Write("testing checked cast... "); Console.Out.Flush(); TestIntfPrx obj = TestIntfPrxHelper.checkedCast(@base); test(obj != null); test(obj.Equals(@base)); TestIntfPrx obj2 = TestIntfPrxHelper.checkedCast(@base2); test(obj2 != null); test(obj2.Equals(@base2)); Console.Out.WriteLine("ok"); Console.Out.Write("pinging server... "); Console.Out.Flush(); obj.ice_ping(); obj2.ice_ping(); Console.Out.WriteLine("ok"); Console.Out.Write("testing encoding versioning... "); Console.Out.Flush(); Ice.ObjectPrx base10 = communicator.stringToProxy("test10 @ TestAdapter10"); test(base10 != null); Ice.ObjectPrx base102 = communicator.stringToProxy("test10"); test(base102 != null); try { base10.ice_ping(); test(false); } catch (Ice.NoEndpointException) { } try { base102.ice_ping(); test(false); } catch (Ice.NoEndpointException) { } base10 = base10.ice_encodingVersion(Ice.Util.Encoding_1_0); base102 = base102.ice_encodingVersion(Ice.Util.Encoding_1_0); base10.ice_ping(); base102.ice_ping(); Console.Out.WriteLine("ok"); Console.Out.Write("testing reference with unknown identity... "); Console.Out.Flush(); try { communicator.stringToProxy("unknown/unknown").ice_ping(); test(false); } catch (Ice.NotRegisteredException ex) { test(ex.kindOfObject.Equals("object")); test(ex.id.Equals("unknown/unknown")); } Console.Out.WriteLine("ok"); Console.Out.Write("testing reference with unknown adapter... "); Console.Out.Flush(); try { communicator.stringToProxy("test @ TestAdapterUnknown").ice_ping(); test(false); } catch (Ice.NotRegisteredException ex) { test(ex.kindOfObject.Equals("object adapter")); test(ex.id.Equals("TestAdapterUnknown")); } Console.Out.WriteLine("ok"); IceGrid.RegistryPrx registry = IceGrid.RegistryPrxHelper.checkedCast( communicator.stringToProxy(communicator.getDefaultLocator().ice_getIdentity().category + "/Registry")); test(registry != null); IceGrid.AdminSessionPrx session = null; try { session = registry.createAdminSession("foo", "bar"); } catch (IceGrid.PermissionDeniedException) { test(false); } session.ice_getConnection().setACM(registry.getACMTimeout(), Ice.Util.None, Ice.ACMHeartbeat.HeartbeatAlways); IceGrid.AdminPrx admin = session.getAdmin(); test(admin != null); try { admin.enableServer("server", false); admin.stopServer("server"); } catch (IceGrid.ServerNotExistException) { test(false); } catch (IceGrid.ServerStopException) { test(false); } catch (IceGrid.NodeUnreachableException) { test(false); } Console.Out.Write("testing whether server is still reachable... "); Console.Out.Flush(); try { obj = TestIntfPrxHelper.checkedCast(@base); test(false); } catch (Ice.NoEndpointException) { } try { obj2 = TestIntfPrxHelper.checkedCast(@base2); test(false); } catch (Ice.NoEndpointException) { } try { admin.enableServer("server", true); } catch (IceGrid.ServerNotExistException) { test(false); } catch (IceGrid.NodeUnreachableException) { test(false); } try { obj = TestIntfPrxHelper.checkedCast(@base); } catch (Ice.NoEndpointException) { test(false); } try { obj2 = TestIntfPrxHelper.checkedCast(@base2); } catch (Ice.NoEndpointException) { test(false); } Console.Out.WriteLine("ok"); try { admin.stopServer("server"); } catch (IceGrid.ServerNotExistException) { test(false); } catch (IceGrid.ServerStopException) { test(false); } catch (IceGrid.NodeUnreachableException) { test(false); } session.destroy(); }
internal static void twoways(Ice.Communicator communicator, Test.MyClassPrx p) { { byte[] i = new byte[_length]; for(int c = 0; c < _length; ++c) { i[c] = (byte)c; } byte[] o; byte[] r; r = p.opAByteS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { List<byte> i = new List<byte>(_length); for(int c = 0; c < _length; ++c) { i.Add((byte)c); } List<byte> o; List<byte> r; r = p.opLByteS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { LinkedList<byte> i = new LinkedList<byte>(); for(int c = 0; c < _length; ++c) { i.AddLast((byte)c); } LinkedList<byte> o; LinkedList<byte> r; r = p.opKByteS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Queue<byte> i = new Queue<byte>(); for(int c = 0; c < _length; ++c) { i.Enqueue((byte)c); } Queue<byte> o; Queue<byte> r; r = p.opQByteS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Stack<byte> i = new Stack<byte>(); for(int c = 0; c < _length; ++c) { i.Push((byte)c); } Stack<byte> o; Stack<byte> r; r = p.opSByteS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { CByteS i = new CByteS(_length); for(int c = 0; c < _length; ++c) { i.Add((byte)c); } CByteS o; CByteS r; r = p.opCByteS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { bool[] i = new bool[_length]; for(int c = 0; c < _length; ++c) { i[c] = c % 1 == 1; } bool[] o; bool[] r; r = p.opABoolS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { List<bool> i = new List<bool>(_length); for(int c = 0; c < _length; ++c) { i.Add(c % 1 == 1); } List<bool> o; List<bool> r; r = p.opLBoolS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { LinkedList<bool> i = new LinkedList<bool>(); for(int c = 0; c < _length; ++c) { i.AddLast(c % 1 == 1); } LinkedList<bool> o; LinkedList<bool> r; r = p.opKBoolS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Queue<bool> i = new Queue<bool>(); for(int c = 0; c < _length; ++c) { i.Enqueue(c % 1 == 1); } Queue<bool> o; Queue<bool> r; r = p.opQBoolS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Stack<bool> i = new Stack<bool>(); for(int c = 0; c < _length; ++c) { i.Push(c % 1 == 1); } Stack<bool> o; Stack<bool> r; r = p.opSBoolS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { CBoolS i = new CBoolS(_length); for(int c = 0; c < _length; ++c) { i.Add(c % 1 == 1); } CBoolS o; CBoolS r; r = p.opCBoolS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { short[] i = new short[_length]; for(int c = 0; c < _length; ++c) { i[c] = (short)c; } short[] o; short[] r; { r = p.opAShortS(i, out o); } test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { List<short> i = new List<short>(_length); for(int c = 0; c < _length; ++c) { i.Add((short)c); } List<short> o; List<short> r; r = p.opLShortS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { LinkedList<short> i = new LinkedList<short>(); for(int c = 0; c < _length; ++c) { i.AddLast((short)c); } LinkedList<short> o; LinkedList<short> r; r = p.opKShortS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Queue<short> i = new Queue<short>(); for(int c = 0; c < _length; ++c) { i.Enqueue((short)c); } Queue<short> o; Queue<short> r; r = p.opQShortS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Stack<short> i = new Stack<short>(); for(int c = 0; c < _length; ++c) { i.Push((short)c); } Stack<short> o; Stack<short> r; r = p.opSShortS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { CShortS i = new CShortS(_length); for(int c = 0; c < _length; ++c) { i.Add((short)c); } CShortS o; CShortS r; r = p.opCShortS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { int[] i = new int[_length]; for(int c = 0; c < _length; ++c) { i[c] = (int)c; } int[] o; int[] r; r = p.opAIntS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { List<int> i = new List<int>(_length); for(int c = 0; c < _length; ++c) { i.Add((int)c); } List<int> o; List<int> r; r = p.opLIntS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { LinkedList<int> i = new LinkedList<int>(); for(int c = 0; c < _length; ++c) { i.AddLast((int)c); } LinkedList<int> o; LinkedList<int> r; r = p.opKIntS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Queue<int> i = new Queue<int>(); for(int c = 0; c < _length; ++c) { i.Enqueue((int)c); } Queue<int> o; Queue<int> r; r = p.opQIntS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Stack<int> i = new Stack<int>(); for(int c = 0; c < _length; ++c) { i.Push((int)c); } Stack<int> o; Stack<int> r; r = p.opSIntS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { CIntS i = new CIntS(_length); for(int c = 0; c < _length; ++c) { i.Add((int)c); } CIntS o; CIntS r; r = p.opCIntS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { long[] i = new long[_length]; for(int c = 0; c < _length; ++c) { i[c] = (long)c; } long[] o; long[] r; r = p.opALongS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { List<long> i = new List<long>(_length); for(int c = 0; c < _length; ++c) { i.Add((long)c); } List<long> o; List<long> r; r = p.opLLongS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { LinkedList<long> i = new LinkedList<long>(); for(int c = 0; c < _length; ++c) { i.AddLast((long)c); } LinkedList<long> o; LinkedList<long> r; r = p.opKLongS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Queue<long> i = new Queue<long>(); for(int c = 0; c < _length; ++c) { i.Enqueue((long)c); } Queue<long> o; Queue<long> r; r = p.opQLongS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Stack<long> i = new Stack<long>(); for(int c = 0; c < _length; ++c) { i.Push((long)c); } Stack<long> o; Stack<long> r; r = p.opSLongS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { CLongS i = new CLongS(_length); for(int c = 0; c < _length; ++c) { i.Add((long)c); } CLongS o; CLongS r; r = p.opCLongS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { float[] i = new float[_length]; for(int c = 0; c < _length; ++c) { i[c] = (float)c; } float[] o; float[] r; r = p.opAFloatS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { List<float> i = new List<float>(_length); for(int c = 0; c < _length; ++c) { i.Add((float)c); } List<float> o; List<float> r; r = p.opLFloatS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { LinkedList<float> i = new LinkedList<float>(); for(int c = 0; c < _length; ++c) { i.AddLast((float)c); } LinkedList<float> o; LinkedList<float> r; r = p.opKFloatS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Queue<float> i = new Queue<float>(); for(int c = 0; c < _length; ++c) { i.Enqueue((float)c); } Queue<float> o; Queue<float> r; r = p.opQFloatS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Stack<float> i = new Stack<float>(); for(int c = 0; c < _length; ++c) { i.Push((float)c); } Stack<float> o; Stack<float> r; r = p.opSFloatS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { CFloatS i = new CFloatS(_length); for(int c = 0; c < _length; ++c) { i.Add((float)c); } CFloatS o; CFloatS r; r = p.opCFloatS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { double[] i = new double[_length]; for(int c = 0; c < _length; ++c) { i[c] = (double)c; } double[] o; double[] r; r = p.opADoubleS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { List<double> i = new List<double>(_length); for(int c = 0; c < _length; ++c) { i.Add((double)c); } List<double> o; List<double> r; r = p.opLDoubleS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { LinkedList<double> i = new LinkedList<double>(); for(int c = 0; c < _length; ++c) { i.AddLast((double)c); } LinkedList<double> o; LinkedList<double> r; r = p.opKDoubleS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Queue<double> i = new Queue<double>(); for(int c = 0; c < _length; ++c) { i.Enqueue((double)c); } Queue<double> o; Queue<double> r; r = p.opQDoubleS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Stack<double> i = new Stack<double>(); for(int c = 0; c < _length; ++c) { i.Push((double)c); } Stack<double> o; Stack<double> r; r = p.opSDoubleS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { CDoubleS i = new CDoubleS(_length); for(int c = 0; c < _length; ++c) { i.Add((double)c); } CDoubleS o; CDoubleS r; r = p.opCDoubleS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { string[] i = new string[_length]; for(int c = 0; c < _length; ++c) { i[c] = c.ToString(); } string[] o; string[] r; r = p.opAStringS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { List<string> i = new List<string>(_length); for(int c = 0; c < _length; ++c) { i.Add(c.ToString()); } List<string> o; List<string> r; r = p.opLStringS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { LinkedList<string> i = new LinkedList<string>(); for(int c = 0; c < _length; ++c) { i.AddLast(c.ToString()); } LinkedList<string> o; LinkedList<string> r; r = p.opKStringS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Queue<string> i = new Queue<string>(); for(int c = 0; c < _length; ++c) { i.Enqueue(c.ToString()); } Queue<string> o; Queue<string> r; r = p.opQStringS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Stack<string> i = new Stack<string>(); for(int c = 0; c < _length; ++c) { i.Push(c.ToString()); } Stack<string> o; Stack<string> r; r = p.opSStringS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { CStringS i = new CStringS(_length); for(int c = 0; c < _length; ++c) { i.Add(c.ToString()); } CStringS o; CStringS r; r = p.opCStringS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Ice.Object[] i = new CV[_length]; for(int c = 0; c < _length; ++c) { i[c] = new CV(c); } Ice.Object[] o; Ice.Object[] r; r = p.opAObjectS(i, out o); System.Collections.IEnumerator eo = o.GetEnumerator(); System.Collections.IEnumerator er = r.GetEnumerator(); foreach(CV obj in i) { eo.MoveNext(); er.MoveNext(); test(obj.i == ((CV)eo.Current).i); test(obj.i == ((CV)er.Current).i); } } { List<Ice.Object> i = new List<Ice.Object>(_length); for(int c = 0; c < _length; ++c) { i.Add(new CV(c)); } List<Ice.Object> o; List<Ice.Object> r; r = p.opLObjectS(i, out o); IEnumerator<Ice.Object> eo = o.GetEnumerator(); IEnumerator<Ice.Object> er = r.GetEnumerator(); foreach(CV obj in i) { eo.MoveNext(); er.MoveNext(); test(obj.i == ((CV)eo.Current).i); test(obj.i == ((CV)er.Current).i); } } { CObjectS i = new CObjectS(_length); for(int c = 0; c < _length; ++c) { i.Add(new CV(c)); } CObjectS o; CObjectS r; r = p.opCObjectS(i, out o); IEnumerator<Ice.Object> eo = (IEnumerator<Ice.Object>)o.GetEnumerator(); IEnumerator<Ice.Object> er = (IEnumerator<Ice.Object>)r.GetEnumerator(); foreach(CV obj in i) { eo.MoveNext(); er.MoveNext(); test(obj.i == ((CV)eo.Current).i); test(obj.i == ((CV)er.Current).i); } } { Ice.ObjectPrx[] i = new Ice.ObjectPrx[_length]; for(int c = 0; c < _length; ++c) { i[c] = communicator.stringToProxy(c.ToString()); } Ice.ObjectPrx[] o; Ice.ObjectPrx[] r; r = p.opAObjectPrxS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { List<Ice.ObjectPrx> i = new List<Ice.ObjectPrx>(_length); for(int c = 0; c < _length; ++c) { i.Add(communicator.stringToProxy(c.ToString())); } List<Ice.ObjectPrx> o; List<Ice.ObjectPrx> r; r = p.opLObjectPrxS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { LinkedList<Ice.ObjectPrx> i = new LinkedList<Ice.ObjectPrx>(); for(int c = 0; c < _length; ++c) { i.AddLast(communicator.stringToProxy(c.ToString())); } LinkedList<Ice.ObjectPrx> o; LinkedList<Ice.ObjectPrx> r; r = p.opKObjectPrxS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Queue<Ice.ObjectPrx> i = new Queue<Ice.ObjectPrx>(); for(int c = 0; c < _length; ++c) { i.Enqueue(communicator.stringToProxy(c.ToString())); } Queue<Ice.ObjectPrx> o; Queue<Ice.ObjectPrx> r; r = p.opQObjectPrxS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Stack<Ice.ObjectPrx> i = new Stack<Ice.ObjectPrx>(); for(int c = 0; c < _length; ++c) { i.Push(communicator.stringToProxy(c.ToString())); } Stack<Ice.ObjectPrx> o; Stack<Ice.ObjectPrx> r; r = p.opSObjectPrxS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { CObjectPrxS i = new CObjectPrxS(_length); for(int c = 0; c < _length; ++c) { i.Add(communicator.stringToProxy(c.ToString())); } CObjectPrxS o; CObjectPrxS r; r = p.opCObjectPrxS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { S[] i = new S[_length]; for(int c = 0; c < _length; ++c) { i[c].i = c; } S[] o; S[] r; r = p.opAStructS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { List<S> i = new List<S>(_length); for(int c = 0; c < _length; ++c) { i.Add(new S(c)); } List<S> o; List<S> r; r = p.opLStructS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { LinkedList<S> i = new LinkedList<S>(); for(int c = 0; c < _length; ++c) { i.AddLast(new S(c)); } LinkedList<S> o; LinkedList<S> r; r = p.opKStructS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Queue<S> i = new Queue<S>(); for(int c = 0; c < _length; ++c) { i.Enqueue(new S(c)); } Queue<S> o; Queue<S> r; r = p.opQStructS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Stack<S> i = new Stack<S>(); for(int c = 0; c < _length; ++c) { i.Push(new S(c)); } Stack<S> o; Stack<S> r; r = p.opSStructS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { CStructS i = new CStructS(_length); for(int c = 0; c < _length; ++c) { i.Add(new S(c)); } CStructS o; CStructS r; r = p.opCStructS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { SD[] i = new SD[_length]; for(int c = 0; c < _length; ++c) { i[c] = new SD(c); } SD[] o; SD[] r; r = p.opAStructSD(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { List<SD> i = new List<SD>(_length); for(int c = 0; c < _length; ++c) { i.Add(new SD(c)); } List<SD> o; List<SD> r; r = p.opLStructSD(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { LinkedList<SD> i = new LinkedList<SD>(); for(int c = 0; c < _length; ++c) { i.AddLast(new SD(c)); } LinkedList<SD> o; LinkedList<SD> r; r = p.opKStructSD(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Queue<SD> i = new Queue<SD>(); for(int c = 0; c < _length; ++c) { i.Enqueue(new SD(c)); } Queue<SD> o; Queue<SD> r; r = p.opQStructSD(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Stack<SD> i = new Stack<SD>(); for(int c = 0; c < _length; ++c) { i.Push(new SD(c)); } Stack<SD> o; Stack<SD> r; r = p.opSStructSD(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { CStructSD i = new CStructSD(_length); for(int c = 0; c < _length; ++c) { i.Add(new SD(c)); } CStructSD o; CStructSD r; r = p.opCStructSD(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { CV[] i = new CV[_length]; for(int c = 0; c < _length; ++c) { i[c] = new CV(c); } CV[] o; CV[] r; r = p.opACVS(i, out o); System.Collections.IEnumerator eo = o.GetEnumerator(); System.Collections.IEnumerator er = r.GetEnumerator(); foreach(CV obj in i) { eo.MoveNext(); er.MoveNext(); test(obj.i == ((CV)eo.Current).i); test(obj.i == ((CV)er.Current).i); } } { List<CV> i = new List<CV>(_length); for(int c = 0; c < _length; ++c) { i.Add(new CV(c)); } List<CV> o; List<CV> r; r = p.opLCVS(i, out o); IEnumerator<CV> eo = o.GetEnumerator(); IEnumerator<CV> er = r.GetEnumerator(); foreach(CV obj in i) { eo.MoveNext(); er.MoveNext(); test(obj.i == eo.Current.i); test(obj.i == er.Current.i); } } { CCVS i = new CCVS(_length); for(int c = 0; c < _length; ++c) { i.Add(new CV(c)); } CCVS o; CCVS r; r = p.opCCVS(i, out o); IEnumerator<CV> eo = (IEnumerator<CV>)o.GetEnumerator(); IEnumerator<CV> er = (IEnumerator<CV>)r.GetEnumerator(); foreach(CV obj in i) { eo.MoveNext(); er.MoveNext(); test(obj.i == eo.Current.i); test(obj.i == er.Current.i); } } { CR[] i = new CR[_length]; for(int c = 0; c < _length; ++c) { i[c] = new CR(new CV(c)); } CR[] o; CR[] r; r = p.opACRS(i, out o); System.Collections.IEnumerator eo = o.GetEnumerator(); System.Collections.IEnumerator er = r.GetEnumerator(); foreach(CR obj in i) { eo.MoveNext(); er.MoveNext(); test(obj.v.i == ((CR)eo.Current).v.i); test(obj.v.i == ((CR)er.Current).v.i); } } { List<CR> i = new List<CR>(_length); for(int c = 0; c < _length; ++c) { i.Add(new CR(new CV(c))); } List<CR> o; List<CR> r; r = p.opLCRS(i, out o); IEnumerator<CR> eo = o.GetEnumerator(); IEnumerator<CR> er = r.GetEnumerator(); foreach(CR obj in i) { eo.MoveNext(); er.MoveNext(); test(obj.v.i == eo.Current.v.i); test(obj.v.i == er.Current.v.i); } } { CCRS i = new CCRS(_length); for(int c = 0; c < _length; ++c) { i.Add(new CR(new CV(c))); } CCRS o; CCRS r; r = p.opCCRS(i, out o); IEnumerator<CR> eo = (IEnumerator<CR>)o.GetEnumerator(); IEnumerator<CR> er = (IEnumerator<CR>)r.GetEnumerator(); foreach(CR obj in i) { eo.MoveNext(); er.MoveNext(); test(obj.v.i == eo.Current.v.i); test(obj.v.i == er.Current.v.i); } } { En[] i = new En[_length]; for(int c = 0; c < _length; ++c) { i[c] = (En)(c % 3); } En[] o; En[] r; r = p.opAEnS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { List<En> i = new List<En>(_length); for(int c = 0; c < _length; ++c) { i.Add((En)(c % 3)); } List<En> o; List<En> r; r = p.opLEnS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { LinkedList<En> i = new LinkedList<En>(); for(int c = 0; c < _length; ++c) { i.AddLast((En)(c % 3)); } LinkedList<En> o; LinkedList<En> r; r = p.opKEnS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Queue<En> i = new Queue<En>(); for(int c = 0; c < _length; ++c) { i.Enqueue((En)(c % 3)); } Queue<En> o; Queue<En> r; r = p.opQEnS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Stack<En> i = new Stack<En>(); for(int c = 0; c < _length; ++c) { i.Push((En)(c % 3)); } Stack<En> o; Stack<En> r; r = p.opSEnS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { CEnS i = new CEnS(_length); for(int c = 0; c < _length; ++c) { i.Add((En)(c % 3)); } CEnS o; CEnS r; r = p.opCEnS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { CVPrx[] i = new CVPrx[_length]; for(int c = 0; c < _length; ++c) { i[c] = CVPrxHelper.uncheckedCast(communicator.stringToProxy(c.ToString())); } CVPrx[] o; CVPrx[] r; r = p.opACVPrxS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { List<CVPrx> i = new List<CVPrx>(_length); for(int c = 0; c < _length; ++c) { i.Add(CVPrxHelper.uncheckedCast(communicator.stringToProxy(c.ToString()))); } List<CVPrx> o; List<CVPrx> r; r = p.opLCVPrxS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { LinkedList<CVPrx> i = new LinkedList<CVPrx>(); for(int c = 0; c < _length; ++c) { i.AddLast(CVPrxHelper.uncheckedCast(communicator.stringToProxy(c.ToString()))); } LinkedList<CVPrx> o; LinkedList<CVPrx> r; r = p.opKCVPrxS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Queue<CVPrx> i = new Queue<CVPrx>(); for(int c = 0; c < _length; ++c) { i.Enqueue(CVPrxHelper.uncheckedCast(communicator.stringToProxy(c.ToString()))); } Queue<CVPrx> o; Queue<CVPrx> r; r = p.opQCVPrxS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Stack<CVPrx> i = new Stack<CVPrx>(); for(int c = 0; c < _length; ++c) { i.Push(CVPrxHelper.uncheckedCast(communicator.stringToProxy(c.ToString()))); } Stack<CVPrx> o; Stack<CVPrx> r; r = p.opSCVPrxS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { CCVPrxS i = new CCVPrxS(_length); for(int c = 0; c < _length; ++c) { i.Add(CVPrxHelper.uncheckedCast(communicator.stringToProxy(c.ToString()))); } CCVPrxS o; CCVPrxS r; r = p.opCCVPrxS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Custom<int> i = new Custom<int>(); for(int c = 0; c < _length; ++c) { i.Add(c); } Custom<int> o; Custom<int> r; r = p.opCustomIntS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Custom<CV> i = new Custom<CV>(); for(int c = 0; c < _length; ++c) { i.Add(new CV(c)); } i.Add(null); Custom<CV> o; Custom<CV> r; r = p.opCustomCVS(i, out o); IEnumerator<CV> eo = (IEnumerator<CV>)o.GetEnumerator(); IEnumerator<CV> er = (IEnumerator<CV>)r.GetEnumerator(); foreach(CV obj in i) { eo.MoveNext(); er.MoveNext(); if(obj == null) { test(eo.Current == null); test(er.Current == null); } else { test(obj.i == eo.Current.i); test(obj.i == er.Current.i); } } } { Custom<Custom<int>> i = new Custom<Custom<int>>(); for(int c = 0; c < _length; ++c) { Custom<int> inner = new Custom<int>(); for(int j = 0; j < c; ++j) { inner.Add(j); } i.Add(inner); } Custom<Custom<int>> o; Custom<Custom<int>> r; r = p.opCustomIntSS(i, out o); test(Ice.CollectionComparer.Equals(i, o)); test(Ice.CollectionComparer.Equals(i, r)); } { Custom<Custom<CV>> i = new Custom<Custom<CV>>(); for(int c = 0; c < _length; ++c) { Custom<CV> inner = new Custom<CV>(); for(int j = 0; j < c; ++j) { inner.Add(new CV(j)); } i.Add(inner); } Custom<Custom<CV>> o; Custom<Custom<CV>> r; r = p.opCustomCVSS(i, out o); IEnumerator<Custom<CV>> eo = (IEnumerator<Custom<CV>>)o.GetEnumerator(); IEnumerator<Custom<CV>> er = (IEnumerator<Custom<CV>>)r.GetEnumerator(); foreach(Custom<CV> s in i) { eo.MoveNext(); er.MoveNext(); IEnumerator<CV> io = (IEnumerator<CV>)eo.Current.GetEnumerator(); IEnumerator<CV> ir = (IEnumerator<CV>)er.Current.GetEnumerator(); foreach(CV obj in s) { io.MoveNext(); ir.MoveNext(); if(obj == null) { test(io.Current == null); test(ir.Current == null); } else { test(obj.i == io.Current.i); test(obj.i == ir.Current.i); } } } } #if !COMPACT && !SILVERLIGHT { Serialize.Small i = null; Serialize.Small o; Serialize.Small r; r = p.opSerialSmallCSharp(i, out o); test(o == null); test(r == null); } { Serialize.Small i = new Serialize.Small(); i.i = 99; Serialize.Small o; Serialize.Small r; try { r = p.opSerialSmallCSharp(i, out o); test(o.i == 99); test(r.i == 99); } catch(Ice.OperationNotExistException) { // OK, talking to non-C# server. } } { Serialize.Large i = new Serialize.Large(); i.d1 = 1.0; i.d2 = 2.0; i.d3 = 3.0; i.d4 = 4.0; i.d5 = 5.0; i.d6 = 6.0; i.d7 = 7.0; i.d8 = 8.0; i.d9 = 9.0; i.d10 = 10.0; Serialize.Large o; Serialize.Large r; try { r = p.opSerialLargeCSharp(i, out o); test(o.d1 == 1.0); test(o.d2 == 2.0); test(o.d3 == 3.0); test(o.d4 == 4.0); test(o.d5 == 5.0); test(o.d6 == 6.0); test(o.d7 == 7.0); test(o.d8 == 8.0); test(o.d9 == 9.0); test(o.d10 == 10.0); test(r.d1 == 1.0); test(r.d2 == 2.0); test(r.d3 == 3.0); test(r.d4 == 4.0); test(r.d5 == 5.0); test(r.d6 == 6.0); test(r.d7 == 7.0); test(r.d8 == 8.0); test(r.d9 == 9.0); test(r.d10 == 10.0); } catch(Ice.OperationNotExistException) { // OK, talking to non-C# server. } } { Serialize.Struct i = new Serialize.Struct(); i.o = null; i.o2 = i; i.s = null; i.s2 = "Hello"; Serialize.Struct o; Serialize.Struct r; try { r = p.opSerialStructCSharp(i, out o); test(o.o == null); test(o.o2 != null); test(((Serialize.Struct)(o.o2)).o == null); test(((Serialize.Struct)(o.o2)).o2 == o.o2); test(o.s == null); test(o.s2.Equals("Hello")); test(r.o == null); test(r.o2 != null); test(((Serialize.Struct)(r.o2)).o == null); test(((Serialize.Struct)(r.o2)).o2 == r.o2); test(r.s == null); test(r.s2.Equals("Hello")); } catch(Ice.OperationNotExistException) { // OK, talking to non-C# server. } } #endif }
getInvocationObserver(Ice.ObjectPrx p, string o, Dictionary <string, string> c) { return(invocationObserver); }
internal static void twowaysAMI(Ice.Communicator communicator, Test.MyClassPrx p) { { byte[] i = new byte[_length]; for(int c = 0; c < _length; ++c) { i[c] = (byte)c; } AMI_MyClass_opAByteSI cb = new AMI_MyClass_opAByteSI(i); p.opAByteS_async(cb, i); cb.check(); } { List<byte> i = new List<byte>(); for(int c = 0; c < _length; ++c) { i.Add((byte)c); } AMI_MyClass_opLByteSI cb = new AMI_MyClass_opLByteSI(i); p.opLByteS_async(cb, i); cb.check(); } { LinkedList<byte> i = new LinkedList<byte>(); for(int c = 0; c < _length; ++c) { i.AddLast((byte)c); } AMI_MyClass_opKByteSI cb = new AMI_MyClass_opKByteSI(i); p.opKByteS_async(cb, i); cb.check(); } { Queue<byte> i = new Queue<byte>(); for(int c = 0; c < _length; ++c) { i.Enqueue((byte)c); } AMI_MyClass_opQByteSI cb = new AMI_MyClass_opQByteSI(i); p.opQByteS_async(cb, i); cb.check(); } { Stack<byte> i = new Stack<byte>(); for(int c = 0; c < _length; ++c) { i.Push((byte)c); } AMI_MyClass_opSByteSI cb = new AMI_MyClass_opSByteSI(i); p.opSByteS_async(cb, i); cb.check(); } { CByteS i = new CByteS(); for(int c = 0; c < _length; ++c) { i.Add((byte)c); } AMI_MyClass_opCByteSI cb = new AMI_MyClass_opCByteSI(i); p.opCByteS_async(cb, i); cb.check(); } { bool[] i = new bool[_length]; for(int c = 0; c < _length; ++c) { i[c] = c % 1 == 1; } AMI_MyClass_opABoolSI cb = new AMI_MyClass_opABoolSI(i); p.opABoolS_async(cb, i); cb.check(); } { List<bool> i = new List<bool>(); for(int c = 0; c < _length; ++c) { i.Add(c % 1 == 1); } AMI_MyClass_opLBoolSI cb = new AMI_MyClass_opLBoolSI(i); p.opLBoolS_async(cb, i); cb.check(); } { LinkedList<bool> i = new LinkedList<bool>(); for(int c = 0; c < _length; ++c) { i.AddLast(c % 1 == 1); } AMI_MyClass_opKBoolSI cb = new AMI_MyClass_opKBoolSI(i); p.opKBoolS_async(cb, i); cb.check(); } { Queue<bool> i = new Queue<bool>(); for(int c = 0; c < _length; ++c) { i.Enqueue(c % 1 == 1); } AMI_MyClass_opQBoolSI cb = new AMI_MyClass_opQBoolSI(i); p.opQBoolS_async(cb, i); cb.check(); } { Stack<bool> i = new Stack<bool>(); for(int c = 0; c < _length; ++c) { i.Push(c % 1 == 1); } AMI_MyClass_opSBoolSI cb = new AMI_MyClass_opSBoolSI(i); p.opSBoolS_async(cb, i); cb.check(); } { CBoolS i = new CBoolS(); for(int c = 0; c < _length; ++c) { i.Add(c % 1 == 1); } AMI_MyClass_opCBoolSI cb = new AMI_MyClass_opCBoolSI(i); p.opCBoolS_async(cb, i); cb.check(); } { short[] i = new short[_length]; for(int c = 0; c < _length; ++c) { i[c] = (short)c; } AMI_MyClass_opAShortSI cb = new AMI_MyClass_opAShortSI(i); p.opAShortS_async(cb, i); cb.check(); } { List<short> i = new List<short>(); for(int c = 0; c < _length; ++c) { i.Add((short)c); } AMI_MyClass_opLShortSI cb = new AMI_MyClass_opLShortSI(i); p.opLShortS_async(cb, i); cb.check(); } { LinkedList<short> i = new LinkedList<short>(); for(int c = 0; c < _length; ++c) { i.AddLast((short)c); } AMI_MyClass_opKShortSI cb = new AMI_MyClass_opKShortSI(i); p.opKShortS_async(cb, i); cb.check(); } { Queue<short> i = new Queue<short>(); for(int c = 0; c < _length; ++c) { i.Enqueue((short)c); } AMI_MyClass_opQShortSI cb = new AMI_MyClass_opQShortSI(i); p.opQShortS_async(cb, i); cb.check(); } { Stack<short> i = new Stack<short>(); for(int c = 0; c < _length; ++c) { i.Push((short)c); } AMI_MyClass_opSShortSI cb = new AMI_MyClass_opSShortSI(i); p.opSShortS_async(cb, i); cb.check(); } { CShortS i = new CShortS(); for(int c = 0; c < _length; ++c) { i.Add((short)c); } AMI_MyClass_opCShortSI cb = new AMI_MyClass_opCShortSI(i); p.opCShortS_async(cb, i); cb.check(); } { int[] i = new int[_length]; for(int c = 0; c < _length; ++c) { i[c] = (int)c; } AMI_MyClass_opAIntSI cb = new AMI_MyClass_opAIntSI(i); p.opAIntS_async(cb, i); cb.check(); } { List<int> i = new List<int>(); for(int c = 0; c < _length; ++c) { i.Add((int)c); } AMI_MyClass_opLIntSI cb = new AMI_MyClass_opLIntSI(i); p.opLIntS_async(cb, i); cb.check(); } { LinkedList<int> i = new LinkedList<int>(); for(int c = 0; c < _length; ++c) { i.AddLast((int)c); } AMI_MyClass_opKIntSI cb = new AMI_MyClass_opKIntSI(i); p.opKIntS_async(cb, i); cb.check(); } { Queue<int> i = new Queue<int>(); for(int c = 0; c < _length; ++c) { i.Enqueue((int)c); } AMI_MyClass_opQIntSI cb = new AMI_MyClass_opQIntSI(i); p.opQIntS_async(cb, i); cb.check(); } { Stack<int> i = new Stack<int>(); for(int c = 0; c < _length; ++c) { i.Push((int)c); } AMI_MyClass_opSIntSI cb = new AMI_MyClass_opSIntSI(i); p.opSIntS_async(cb, i); cb.check(); } { CIntS i = new CIntS(); for(int c = 0; c < _length; ++c) { i.Add((int)c); } AMI_MyClass_opCIntSI cb = new AMI_MyClass_opCIntSI(i); p.opCIntS_async(cb, i); cb.check(); } { long[] i = new long[_length]; for(int c = 0; c < _length; ++c) { i[c] = (long)c; } AMI_MyClass_opALongSI cb = new AMI_MyClass_opALongSI(i); p.opALongS_async(cb, i); cb.check(); } { List<long> i = new List<long>(); for(int c = 0; c < _length; ++c) { i.Add((long)c); } AMI_MyClass_opLLongSI cb = new AMI_MyClass_opLLongSI(i); p.opLLongS_async(cb, i); cb.check(); } { LinkedList<long> i = new LinkedList<long>(); for(int c = 0; c < _length; ++c) { i.AddLast((long)c); } AMI_MyClass_opKLongSI cb = new AMI_MyClass_opKLongSI(i); p.opKLongS_async(cb, i); cb.check(); } { Queue<long> i = new Queue<long>(); for(int c = 0; c < _length; ++c) { i.Enqueue((long)c); } AMI_MyClass_opQLongSI cb = new AMI_MyClass_opQLongSI(i); p.opQLongS_async(cb, i); cb.check(); } { Stack<long> i = new Stack<long>(); for(int c = 0; c < _length; ++c) { i.Push((long)c); } AMI_MyClass_opSLongSI cb = new AMI_MyClass_opSLongSI(i); p.opSLongS_async(cb, i); cb.check(); } { CLongS i = new CLongS(); for(int c = 0; c < _length; ++c) { i.Add((long)c); } AMI_MyClass_opCLongSI cb = new AMI_MyClass_opCLongSI(i); p.opCLongS_async(cb, i); cb.check(); } { float[] i = new float[_length]; for(int c = 0; c < _length; ++c) { i[c] = (float)c; } AMI_MyClass_opAFloatSI cb = new AMI_MyClass_opAFloatSI(i); p.opAFloatS_async(cb, i); cb.check(); } { List<float> i = new List<float>(); for(int c = 0; c < _length; ++c) { i.Add((float)c); } AMI_MyClass_opLFloatSI cb = new AMI_MyClass_opLFloatSI(i); p.opLFloatS_async(cb, i); cb.check(); } { LinkedList<float> i = new LinkedList<float>(); for(int c = 0; c < _length; ++c) { i.AddLast((float)c); } AMI_MyClass_opKFloatSI cb = new AMI_MyClass_opKFloatSI(i); p.opKFloatS_async(cb, i); cb.check(); } { Queue<float> i = new Queue<float>(); for(int c = 0; c < _length; ++c) { i.Enqueue((float)c); } AMI_MyClass_opQFloatSI cb = new AMI_MyClass_opQFloatSI(i); p.opQFloatS_async(cb, i); cb.check(); } { Stack<float> i = new Stack<float>(); for(int c = 0; c < _length; ++c) { i.Push((float)c); } AMI_MyClass_opSFloatSI cb = new AMI_MyClass_opSFloatSI(i); p.opSFloatS_async(cb, i); cb.check(); } { CFloatS i = new CFloatS(); for(int c = 0; c < _length; ++c) { i.Add((float)c); } AMI_MyClass_opCFloatSI cb = new AMI_MyClass_opCFloatSI(i); p.opCFloatS_async(cb, i); cb.check(); } { double[] i = new double[_length]; for(int c = 0; c < _length; ++c) { i[c] = (double)c; } AMI_MyClass_opADoubleSI cb = new AMI_MyClass_opADoubleSI(i); p.opADoubleS_async(cb, i); cb.check(); } { List<double> i = new List<double>(); for(int c = 0; c < _length; ++c) { i.Add((double)c); } AMI_MyClass_opLDoubleSI cb = new AMI_MyClass_opLDoubleSI(i); p.opLDoubleS_async(cb, i); cb.check(); } { LinkedList<double> i = new LinkedList<double>(); for(int c = 0; c < _length; ++c) { i.AddLast((double)c); } AMI_MyClass_opKDoubleSI cb = new AMI_MyClass_opKDoubleSI(i); p.opKDoubleS_async(cb, i); cb.check(); } { Queue<double> i = new Queue<double>(); for(int c = 0; c < _length; ++c) { i.Enqueue((double)c); } AMI_MyClass_opQDoubleSI cb = new AMI_MyClass_opQDoubleSI(i); p.opQDoubleS_async(cb, i); cb.check(); } { Stack<double> i = new Stack<double>(); for(int c = 0; c < _length; ++c) { i.Push((double)c); } AMI_MyClass_opSDoubleSI cb = new AMI_MyClass_opSDoubleSI(i); p.opSDoubleS_async(cb, i); cb.check(); } { CDoubleS i = new CDoubleS(); for(int c = 0; c < _length; ++c) { i.Add((double)c); } AMI_MyClass_opCDoubleSI cb = new AMI_MyClass_opCDoubleSI(i); p.opCDoubleS_async(cb, i); cb.check(); } { string[] i = new string[_length]; for(int c = 0; c < _length; ++c) { i[c] = c.ToString(); } AMI_MyClass_opAStringSI cb = new AMI_MyClass_opAStringSI(i); p.opAStringS_async(cb, i); cb.check(); } { List<string> i = new List<string>(); for(int c = 0; c < _length; ++c) { i.Add(c.ToString()); } AMI_MyClass_opLStringSI cb = new AMI_MyClass_opLStringSI(i); p.opLStringS_async(cb, i); cb.check(); } { LinkedList<string> i = new LinkedList<string>(); for(int c = 0; c < _length; ++c) { i.AddLast(c.ToString()); } AMI_MyClass_opKStringSI cb = new AMI_MyClass_opKStringSI(i); p.opKStringS_async(cb, i); cb.check(); } { Queue<string> i = new Queue<string>(); for(int c = 0; c < _length; ++c) { i.Enqueue(c.ToString()); } AMI_MyClass_opQStringSI cb = new AMI_MyClass_opQStringSI(i); p.opQStringS_async(cb, i); cb.check(); } { Stack<string> i = new Stack<string>(); for(int c = 0; c < _length; ++c) { i.Push(c.ToString()); } AMI_MyClass_opSStringSI cb = new AMI_MyClass_opSStringSI(i); p.opSStringS_async(cb, i); cb.check(); } { CStringS i = new CStringS(); for(int c = 0; c < _length; ++c) { i.Add(c.ToString()); } AMI_MyClass_opCStringSI cb = new AMI_MyClass_opCStringSI(i); p.opCStringS_async(cb, i); cb.check(); } { Ice.Object[] i = new Ice.Object[_length]; for(int c = 0; c < _length; ++c) { i[c] = new CV(c); } AMI_MyClass_opAObjectSI cb = new AMI_MyClass_opAObjectSI(i); p.opAObjectS_async(cb, i); cb.check(); } { List<Ice.Object> i = new List<Ice.Object>(); for(int c = 0; c < _length; ++c) { i.Add(new CV(c)); } AMI_MyClass_opLObjectSI cb = new AMI_MyClass_opLObjectSI(i); p.opLObjectS_async(cb, i); cb.check(); } { CObjectS i = new CObjectS(); for(int c = 0; c < _length; ++c) { i.Add(new CV(c)); } AMI_MyClass_opCObjectSI cb = new AMI_MyClass_opCObjectSI(i); p.opCObjectS_async(cb, i); cb.check(); } { Ice.ObjectPrx[] i = new Ice.ObjectPrx[_length]; for(int c = 0; c < _length; ++c) { i[c] = communicator.stringToProxy(c.ToString()); } AMI_MyClass_opAObjectPrxSI cb = new AMI_MyClass_opAObjectPrxSI(i); p.opAObjectPrxS_async(cb, i); cb.check(); } { List<Ice.ObjectPrx> i = new List<Ice.ObjectPrx>(); for(int c = 0; c < _length; ++c) { i.Add(communicator.stringToProxy(c.ToString())); } AMI_MyClass_opLObjectPrxSI cb = new AMI_MyClass_opLObjectPrxSI(i); p.opLObjectPrxS_async(cb, i); cb.check(); } { LinkedList<Ice.ObjectPrx> i = new LinkedList<Ice.ObjectPrx>(); for(int c = 0; c < _length; ++c) { i.AddLast(communicator.stringToProxy(c.ToString())); } AMI_MyClass_opKObjectPrxSI cb = new AMI_MyClass_opKObjectPrxSI(i); p.opKObjectPrxS_async(cb, i); cb.check(); } { Queue<Ice.ObjectPrx> i = new Queue<Ice.ObjectPrx>(); for(int c = 0; c < _length; ++c) { i.Enqueue(communicator.stringToProxy(c.ToString())); } AMI_MyClass_opQObjectPrxSI cb = new AMI_MyClass_opQObjectPrxSI(i); p.opQObjectPrxS_async(cb, i); cb.check(); } { Stack<Ice.ObjectPrx> i = new Stack<Ice.ObjectPrx>(); for(int c = 0; c < _length; ++c) { i.Push(communicator.stringToProxy(c.ToString())); } AMI_MyClass_opSObjectPrxSI cb = new AMI_MyClass_opSObjectPrxSI(i); p.opSObjectPrxS_async(cb, i); cb.check(); } { CObjectPrxS i = new CObjectPrxS(); for(int c = 0; c < _length; ++c) { i.Add(communicator.stringToProxy(c.ToString())); } AMI_MyClass_opCObjectPrxSI cb = new AMI_MyClass_opCObjectPrxSI(i); p.opCObjectPrxS_async(cb, i); cb.check(); } { S[] i = new S[_length]; for(int c = 0; c < _length; ++c) { i[c].i = c; } AMI_MyClass_opAStructSI cb = new AMI_MyClass_opAStructSI(i); p.opAStructS_async(cb, i); cb.check(); } { List<S> i = new List<S>(); for(int c = 0; c < _length; ++c) { i.Add(new S(c)); } AMI_MyClass_opLStructSI cb = new AMI_MyClass_opLStructSI(i); p.opLStructS_async(cb, i); cb.check(); } { LinkedList<S> i = new LinkedList<S>(); for(int c = 0; c < _length; ++c) { i.AddLast(new S(c)); } AMI_MyClass_opKStructSI cb = new AMI_MyClass_opKStructSI(i); p.opKStructS_async(cb, i); cb.check(); } { Queue<S> i = new Queue<S>(); for(int c = 0; c < _length; ++c) { i.Enqueue(new S(c)); } AMI_MyClass_opQStructSI cb = new AMI_MyClass_opQStructSI(i); p.opQStructS_async(cb, i); cb.check(); } { Stack<S> i = new Stack<S>(); for(int c = 0; c < _length; ++c) { i.Push(new S(c)); } AMI_MyClass_opSStructSI cb = new AMI_MyClass_opSStructSI(i); p.opSStructS_async(cb, i); cb.check(); } { CStructS i = new CStructS(); for(int c = 0; c < _length; ++c) { i.Add(new S(c)); } AMI_MyClass_opCStructSI cb = new AMI_MyClass_opCStructSI(i); p.opCStructS_async(cb, i); cb.check(); } { SD[] i = new SD[_length]; for(int c = 0; c < _length; ++c) { i[c] = new SD(c); } AMI_MyClass_opAStructSDI cb = new AMI_MyClass_opAStructSDI(i); p.opAStructSD_async(cb, i); cb.check(); } { List<SD> i = new List<SD>(); for(int c = 0; c < _length; ++c) { i.Add(new SD(c)); } AMI_MyClass_opLStructSDI cb = new AMI_MyClass_opLStructSDI(i); p.opLStructSD_async(cb, i); cb.check(); } { LinkedList<SD> i = new LinkedList<SD>(); for(int c = 0; c < _length; ++c) { i.AddLast(new SD(c)); } AMI_MyClass_opKStructSDI cb = new AMI_MyClass_opKStructSDI(i); p.opKStructSD_async(cb, i); cb.check(); } { Queue<SD> i = new Queue<SD>(); for(int c = 0; c < _length; ++c) { i.Enqueue(new SD(c)); } AMI_MyClass_opQStructSDI cb = new AMI_MyClass_opQStructSDI(i); p.opQStructSD_async(cb, i); cb.check(); } { Stack<SD> i = new Stack<SD>(); for(int c = 0; c < _length; ++c) { i.Push(new SD(c)); } AMI_MyClass_opSStructSDI cb = new AMI_MyClass_opSStructSDI(i); p.opSStructSD_async(cb, i); cb.check(); } { CStructSD i = new CStructSD(); for(int c = 0; c < _length; ++c) { i.Add(new SD(c)); } AMI_MyClass_opCStructSDI cb = new AMI_MyClass_opCStructSDI(i); p.opCStructSD_async(cb, i); cb.check(); } { CV[] i = new CV[_length]; for(int c = 0; c < _length; ++c) { i[c] = new CV(c); } AMI_MyClass_opACVSI cb = new AMI_MyClass_opACVSI(i); p.opACVS_async(cb, i); cb.check(); } { List<CV> i = new List<CV>(); for(int c = 0; c < _length; ++c) { i.Add(new CV(c)); } AMI_MyClass_opLCVSI cb = new AMI_MyClass_opLCVSI(i); p.opLCVS_async(cb, i); cb.check(); } { CCVS i = new CCVS(); for(int c = 0; c < _length; ++c) { i.Add(new CV(c)); } AMI_MyClass_opCCVSI cb = new AMI_MyClass_opCCVSI(i); p.opCCVS_async(cb, i); cb.check(); } { CVPrx[] i = new CVPrx[_length]; for(int c = 0; c < _length; ++c) { i[c] = CVPrxHelper.uncheckedCast(communicator.stringToProxy(c.ToString())); } AMI_MyClass_opACVPrxSI cb = new AMI_MyClass_opACVPrxSI(i); p.opACVPrxS_async(cb, i); cb.check(); } { List<CVPrx> i = new List<CVPrx>(); for(int c = 0; c < _length; ++c) { i.Add(CVPrxHelper.uncheckedCast(communicator.stringToProxy(c.ToString()))); } AMI_MyClass_opLCVPrxSI cb = new AMI_MyClass_opLCVPrxSI(i); p.opLCVPrxS_async(cb, i); cb.check(); } { LinkedList<CVPrx> i = new LinkedList<CVPrx>(); for(int c = 0; c < _length; ++c) { i.AddLast(CVPrxHelper.uncheckedCast(communicator.stringToProxy(c.ToString()))); } AMI_MyClass_opKCVPrxSI cb = new AMI_MyClass_opKCVPrxSI(i); p.opKCVPrxS_async(cb, i); cb.check(); } { Queue<CVPrx> i = new Queue<CVPrx>(); for(int c = 0; c < _length; ++c) { i.Enqueue(CVPrxHelper.uncheckedCast(communicator.stringToProxy(c.ToString()))); } AMI_MyClass_opQCVPrxSI cb = new AMI_MyClass_opQCVPrxSI(i); p.opQCVPrxS_async(cb, i); cb.check(); } { Stack<CVPrx> i = new Stack<CVPrx>(); for(int c = 0; c < _length; ++c) { i.Push(CVPrxHelper.uncheckedCast(communicator.stringToProxy(c.ToString()))); } AMI_MyClass_opSCVPrxSI cb = new AMI_MyClass_opSCVPrxSI(i); p.opSCVPrxS_async(cb, i); cb.check(); } { CCVPrxS i = new CCVPrxS(); for(int c = 0; c < _length; ++c) { i.Add(CVPrxHelper.uncheckedCast(communicator.stringToProxy(c.ToString()))); } AMI_MyClass_opCCVPrxSI cb = new AMI_MyClass_opCCVPrxSI(i); p.opCCVPrxS_async(cb, i); cb.check(); } { CR[] i = new CR[_length]; for(int c = 0; c < _length; ++c) { i[c] = new CR(new CV(c)); } AMI_MyClass_opACRSI cb = new AMI_MyClass_opACRSI(i); p.opACRS_async(cb, i); cb.check(); } { List<CR> i = new List<CR>(); for(int c = 0; c < _length; ++c) { i.Add(new CR(new CV(c))); } AMI_MyClass_opLCRSI cb = new AMI_MyClass_opLCRSI(i); p.opLCRS_async(cb, i); cb.check(); } { CCRS i = new CCRS(); for(int c = 0; c < _length; ++c) { i.Add(new CR(new CV(c))); } AMI_MyClass_opCCRSI cb = new AMI_MyClass_opCCRSI(i); p.opCCRS_async(cb, i); cb.check(); } { En[] i = new En[_length]; for(int c = 0; c < _length; ++c) { i[c] = (En)(c % 3); } AMI_MyClass_opAEnSI cb = new AMI_MyClass_opAEnSI(i); p.opAEnS_async(cb, i); cb.check(); } { List<En> i = new List<En>(); for(int c = 0; c < _length; ++c) { i.Add((En)(c % 3)); } AMI_MyClass_opLEnSI cb = new AMI_MyClass_opLEnSI(i); p.opLEnS_async(cb, i); cb.check(); } { LinkedList<En> i = new LinkedList<En>(); for(int c = 0; c < _length; ++c) { i.AddLast((En)(c % 3)); } AMI_MyClass_opKEnSI cb = new AMI_MyClass_opKEnSI(i); p.opKEnS_async(cb, i); cb.check(); } { Queue<En> i = new Queue<En>(); for(int c = 0; c < _length; ++c) { i.Enqueue((En)(c % 3)); } AMI_MyClass_opQEnSI cb = new AMI_MyClass_opQEnSI(i); p.opQEnS_async(cb, i); cb.check(); } { Stack<En> i = new Stack<En>(); for(int c = 0; c < _length; ++c) { i.Push((En)(c % 3)); } AMI_MyClass_opSEnSI cb = new AMI_MyClass_opSEnSI(i); p.opSEnS_async(cb, i); cb.check(); } { CEnS i = new CEnS(); for(int c = 0; c < _length; ++c) { i.Add((En)(c % 3)); } AMI_MyClass_opCEnSI cb = new AMI_MyClass_opCEnSI(i); p.opCEnS_async(cb, i); cb.check(); } { Custom<int> i = new Custom<int>(); for(int c = 0; c < _length; ++c) { i.Add(c); } AMI_MyClass_opCustomIntSI cb = new AMI_MyClass_opCustomIntSI(i); p.opCustomIntS_async(cb, i); cb.check(); } { Custom<CV> i = new Custom<CV>(); for(int c = 0; c < _length; ++c) { i.Add(new CV(c)); } AMI_MyClass_opCustomCVSI cb = new AMI_MyClass_opCustomCVSI(i); p.opCustomCVS_async(cb, i); cb.check(); } { Custom<Custom<int>> i = new Custom<Custom<int>>(); for(int c = 0; c < _length; ++c) { Custom<int> inner = new Custom<int>(); for(int j = 0; j < c; ++j) { inner.Add(j); } i.Add(inner); } AMI_MyClass_opCustomIntSSI cb = new AMI_MyClass_opCustomIntSSI(i); p.opCustomIntSS_async(cb, i); cb.check(); } { Custom<Custom<CV>> i = new Custom<Custom<CV>>(); for(int c = 0; c < _length; ++c) { Custom<CV> inner = new Custom<CV>(); for(int j = 0; j < c; ++j) { inner.Add(new CV(j)); } i.Add(inner); } AMI_MyClass_opCustomCVSSI cb = new AMI_MyClass_opCustomCVSSI(i); p.opCustomCVSS_async(cb, i); cb.check(); } #if !COMPACT && !SILVERLIGHT { Serialize.Small i = null; AMI_MyClass_opSerialSmallCSharpNull cb = new AMI_MyClass_opSerialSmallCSharpNull(); p.opSerialSmallCSharp_async(cb, i); cb.check(); } { Serialize.Small i = new Serialize.Small(); i.i = 99; AMI_MyClass_opSerialSmallCSharp cb = new AMI_MyClass_opSerialSmallCSharp(); p.opSerialSmallCSharp_async(cb, i); cb.check(); } { Serialize.Large i = new Serialize.Large(); i.d1 = 1.0; i.d2 = 2.0; i.d3 = 3.0; i.d4 = 4.0; i.d5 = 5.0; i.d6 = 6.0; i.d7 = 7.0; i.d8 = 8.0; i.d9 = 9.0; i.d10 = 10.0; AMI_MyClass_opSerialLargeCSharp cb = new AMI_MyClass_opSerialLargeCSharp(); p.opSerialLargeCSharp_async(cb, i); cb.check(); } { Serialize.Struct i = new Serialize.Struct(); i.o = null; i.o2 = i; i.s = null; i.s2 = "Hello"; AMI_MyClass_opSerialStructCSharp cb = new AMI_MyClass_opSerialStructCSharp(); p.opSerialStructCSharp_async(cb, i); cb.check(); } #endif }
public static void allTests(Test.TestHelper helper, List <int> ports) { Ice.Communicator communicator = helper.communicator(); var output = helper.getWriter(); output.Write("testing stringToProxy... "); output.Flush(); string refString = "test"; for (int i = 0; i < ports.Count; i++) { refString += ":" + helper.getTestEndpoint(ports[i]); } Ice.ObjectPrx basePrx = communicator.stringToProxy(refString); test(basePrx != null); output.WriteLine("ok"); output.Write("testing checked cast... "); output.Flush(); TestIntfPrx obj = TestIntfPrxHelper.checkedCast(basePrx); test(obj != null); test(obj.Equals(basePrx)); output.WriteLine("ok"); int oldPid = 0; bool ami = false; for (int i = 1, j = 0; i <= ports.Count; ++i, ++j) { if (j > 3) { j = 0; ami = !ami; } if (!ami) { output.Write("testing server #" + i + "... "); output.Flush(); int pid = obj.pid(); test(pid != oldPid); output.WriteLine("ok"); oldPid = pid; } else { output.Write("testing server #" + i + " with AMI... "); output.Flush(); Callback cb = new Callback(); int pid = -1; obj.begin_pid().whenCompleted( (int p) => { pid = p; cb.called(); }, (Ice.Exception ex) => { output.WriteLine(ex.ToString()); test(false); }); cb.check(); test(pid != oldPid); output.WriteLine("ok"); oldPid = pid; } if (j == 0) { if (!ami) { output.Write("shutting down server #" + i + "... "); output.Flush(); obj.shutdown(); output.WriteLine("ok"); } else { output.Write("shutting down server #" + i + " with AMI... "); Callback cb = new Callback(); obj.begin_shutdown().whenCompleted( () => { cb.called(); }, (Ice.Exception ex) => { output.WriteLine(ex.ToString()); test(false); }); cb.check(); output.WriteLine("ok"); } } else if (j == 1 || i + 1 > ports.Count) { if (!ami) { output.Write("aborting server #" + i + "... "); output.Flush(); try { obj.abort(); test(false); } catch (Ice.ConnectionLostException) { output.WriteLine("ok"); } catch (Ice.ConnectFailedException) { output.WriteLine("ok"); } catch (Ice.SocketException) { output.WriteLine("ok"); } } else { output.Write("aborting server #" + i + " with AMI... "); output.Flush(); Callback cb = new Callback(); obj.begin_abort().whenCompleted( () => { test(false); }, (Ice.Exception ex) => { exceptAbortI(ex, output); cb.called(); }); cb.check(); output.WriteLine("ok"); } } else if (j == 2 || j == 3) { if (!ami) { output.Write("aborting server #" + i + " and #" + (i + 1) + " with idempotent call... "); output.Flush(); try { obj.idempotentAbort(); test(false); } catch (Ice.ConnectionLostException) { output.WriteLine("ok"); } catch (Ice.ConnectFailedException) { output.WriteLine("ok"); } catch (Ice.SocketException) { output.WriteLine("ok"); } } else { output.Write("aborting server #" + i + " and #" + (i + 1) + " with idempotent AMI call... "); output.Flush(); Callback cb = new Callback(); obj.begin_idempotentAbort().whenCompleted( () => { test(false); }, (Ice.Exception ex) => { exceptAbortI(ex, output); cb.called(); }); cb.check(); output.WriteLine("ok"); } ++i; } else { Debug.Assert(false); } } output.Write("testing whether all servers are gone... "); output.Flush(); try { obj.ice_ping(); test(false); } catch (Ice.LocalException) { output.WriteLine("ok"); } }