public static void allTests(global::Test.TestHelper helper) { var communicator = helper.Communicator(); TestHelper.Assert(communicator != null); var controller = IControllerPrx.Parse($"controller:{helper.GetTestEndpoint(1)}", communicator); try { allTestsWithController(helper, controller); } catch (Exception) { // Ensure the adapter is not in the holding state when an unexpected exception occurs to prevent // the test from hanging on exit in case a connection which disables timeouts is still opened. controller.resumeAdapter(); throw; } }
public static void allTests(global::Test.TestHelper helper) { Communicator?communicator = helper.Communicator(); TestHelper.Assert(communicator != null); var output = helper.GetWriter(); output.Write("testing proxy endpoint information... "); output.Flush(); { var p1 = IObjectPrx.Parse( "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", communicator); var endps = p1.Endpoints; Endpoint endpoint = endps[0]; TcpEndpoint?tcpEndpoint = getTCPEndpoint(endpoint); TestHelper.Assert(tcpEndpoint != null); TestHelper.Assert(tcpEndpoint.Host.Equals("tcphost")); TestHelper.Assert(tcpEndpoint.Port == 10000); TestHelper.Assert(tcpEndpoint.SourceAddress !.ToString().Equals("10.10.10.10")); TestHelper.Assert(tcpEndpoint.Timeout == 1200); TestHelper.Assert(tcpEndpoint.HasCompressionFlag); TestHelper.Assert(!tcpEndpoint.IsDatagram); TestHelper.Assert(tcpEndpoint.Type == EndpointType.TCP && !tcpEndpoint.IsSecure || tcpEndpoint.Type == EndpointType.SSL && tcpEndpoint.IsSecure || tcpEndpoint.Type == EndpointType.WS && !tcpEndpoint.IsSecure || tcpEndpoint.Type == EndpointType.WSS && tcpEndpoint.IsSecure); TestHelper.Assert(tcpEndpoint.Type == EndpointType.TCP && endpoint is TcpEndpoint || tcpEndpoint.Type == EndpointType.SSL && endpoint is IceSSL.Endpoint || tcpEndpoint.Type == EndpointType.WS && endpoint is WSEndpoint || tcpEndpoint.Type == EndpointType.WSS && endpoint is WSEndpoint); UdpEndpoint udpEndpoint = (UdpEndpoint)endps[1]; TestHelper.Assert(udpEndpoint.Host.Equals("udphost")); TestHelper.Assert(udpEndpoint.Port == 10001); TestHelper.Assert(udpEndpoint.McastInterface.Equals("eth0")); TestHelper.Assert(udpEndpoint.McastTtl == 5); TestHelper.Assert(udpEndpoint.SourceAddress !.ToString().Equals("10.10.10.10")); TestHelper.Assert(udpEndpoint.Timeout == -1); TestHelper.Assert(!udpEndpoint.HasCompressionFlag); TestHelper.Assert(!udpEndpoint.IsSecure); TestHelper.Assert(udpEndpoint.IsDatagram); TestHelper.Assert(udpEndpoint.Type == EndpointType.UDP); OpaqueEndpoint opaqueEndpoint = (OpaqueEndpoint)endps[2]; TestHelper.Assert(opaqueEndpoint.Bytes.Length > 0); TestHelper.Assert(opaqueEndpoint.Encoding.Equals(new Encoding(1, 8))); } output.WriteLine("ok"); ObjectAdapter adapter; output.Write("test object adapter endpoint information... "); output.Flush(); { string host = communicator.GetPropertyAsInt("Ice.IPv6") != 0 ? "::1" : "127.0.0.1"; communicator.SetProperty("TestAdapter.Endpoints", "tcp -h \"" + host + "\" -t 15000:udp -h \"" + host + "\""); adapter = communicator.CreateObjectAdapter("TestAdapter"); var endpoints = adapter.GetEndpoints(); TestHelper.Assert(endpoints.Count == 2); var publishedEndpoints = adapter.GetPublishedEndpoints(); TestHelper.Assert(global::Test.Collections.Equals(endpoints, publishedEndpoints)); TcpEndpoint?tcpEndpoint = getTCPEndpoint(endpoints[0]); TestHelper.Assert(tcpEndpoint != null); TestHelper.Assert( tcpEndpoint.Type == EndpointType.TCP || tcpEndpoint.Type == EndpointType.SSL || tcpEndpoint.Type == EndpointType.WS || tcpEndpoint.Type == EndpointType.WSS); TestHelper.Assert(tcpEndpoint.Host.Equals(host)); TestHelper.Assert(tcpEndpoint.Port > 0); TestHelper.Assert(tcpEndpoint.Timeout == 15000); UdpEndpoint udpEndpoint = (UdpEndpoint)endpoints[1]; TestHelper.Assert(udpEndpoint.Host.Equals(host)); TestHelper.Assert(udpEndpoint.IsDatagram); TestHelper.Assert(udpEndpoint.Port > 0); endpoints = new List <Endpoint> { endpoints[0] }; TestHelper.Assert(endpoints.Count == 1); adapter.SetPublishedEndpoints(endpoints); publishedEndpoints = adapter.GetPublishedEndpoints(); TestHelper.Assert(Collections.Equals(endpoints, publishedEndpoints)); adapter.Destroy(); int port = helper.GetTestPort(1); communicator.SetProperty("TestAdapter.Endpoints", $"default -h * -p {port}"); communicator.SetProperty("TestAdapter.PublishedEndpoints", helper.GetTestEndpoint(1)); adapter = communicator.CreateObjectAdapter("TestAdapter"); endpoints = adapter.GetEndpoints(); TestHelper.Assert(endpoints.Count >= 1); publishedEndpoints = adapter.GetPublishedEndpoints(); TestHelper.Assert(publishedEndpoints.Count == 1); foreach (var endpoint in endpoints) { tcpEndpoint = getTCPEndpoint(endpoint); TestHelper.Assert(tcpEndpoint !.Port == port); } tcpEndpoint = getTCPEndpoint(publishedEndpoints[0]); TestHelper.Assert(tcpEndpoint !.Host == "127.0.0.1"); TestHelper.Assert(tcpEndpoint !.Port == port); adapter.Destroy(); } output.WriteLine("ok"); int endpointPort = helper.GetTestPort(0); var testIntf = Test.ITestIntfPrx.Parse("test:" + helper.GetTestEndpoint(0) + ":" + helper.GetTestEndpoint(0, "udp"), communicator); string defaultHost = communicator.GetProperty("Ice.Default.Host") ?? ""; output.Write("test connection endpoint information... "); output.Flush(); { Endpoint endpoint = testIntf.GetConnection().Endpoint; TcpEndpoint?tcpEndpoint = getTCPEndpoint(endpoint); TestHelper.Assert(tcpEndpoint != null); TestHelper.Assert(tcpEndpoint.Port == endpointPort); TestHelper.Assert(!tcpEndpoint.HasCompressionFlag); TestHelper.Assert(tcpEndpoint.Host.Equals(defaultHost)); Dictionary <string, string> ctx = testIntf.getEndpointInfoAsContext(); TestHelper.Assert(ctx["host"].Equals(tcpEndpoint.Host)); TestHelper.Assert(ctx["compress"].Equals("false")); int port = int.Parse(ctx["port"]); TestHelper.Assert(port > 0); endpoint = testIntf.Clone(invocationMode: InvocationMode.Datagram).GetConnection().Endpoint; UdpEndpoint udp = (UdpEndpoint)endpoint; TestHelper.Assert(udp.Port == endpointPort); TestHelper.Assert(udp.Host.Equals(defaultHost)); } output.WriteLine("ok"); output.Write("testing connection information... "); output.Flush(); { Connection connection = testIntf.GetConnection(); connection.SetBufferSize(1024, 2048); ConnectionInfo info = connection.GetConnectionInfo(); TCPConnectionInfo ipInfo = getTCPConnectionInfo(info) !; TestHelper.Assert(!info.Incoming); TestHelper.Assert(info.AdapterName !.Length == 0); TestHelper.Assert(ipInfo.RemotePort == endpointPort); TestHelper.Assert(ipInfo.LocalPort > 0); if (defaultHost.Equals("127.0.0.1")) { TestHelper.Assert(ipInfo.LocalAddress.Equals(defaultHost)); TestHelper.Assert(ipInfo.RemoteAddress.Equals(defaultHost)); } TestHelper.Assert(ipInfo.RcvSize >= 1024); TestHelper.Assert(ipInfo.SndSize >= 2048); Dictionary <string, string> ctx = testIntf.getConnectionInfoAsContext(); TestHelper.Assert(ctx["incoming"].Equals("true")); TestHelper.Assert(ctx["adapterName"].Equals("TestAdapter")); TestHelper.Assert(ctx["remoteAddress"].Equals(ipInfo.LocalAddress)); TestHelper.Assert(ctx["localAddress"].Equals(ipInfo.RemoteAddress)); TestHelper.Assert(ctx["remotePort"].Equals(ipInfo.LocalPort.ToString())); TestHelper.Assert(ctx["localPort"].Equals(ipInfo.RemotePort.ToString())); if (testIntf.GetConnection().Type().Equals("ws") || testIntf.GetConnection().Type().Equals("wss")) { Dictionary <string, string> headers = ((WSConnectionInfo)info).Headers !; TestHelper.Assert(headers["Upgrade"].Equals("websocket")); TestHelper.Assert(headers["Connection"].Equals("Upgrade")); TestHelper.Assert(headers["Sec-WebSocket-Protocol"].Equals("ice.zeroc.com")); TestHelper.Assert(headers["Sec-WebSocket-Accept"] != null); TestHelper.Assert(ctx["ws.Upgrade"].Equals("websocket")); TestHelper.Assert(ctx["ws.Connection"].Equals("Upgrade")); TestHelper.Assert(ctx["ws.Sec-WebSocket-Protocol"].Equals("ice.zeroc.com")); TestHelper.Assert(ctx["ws.Sec-WebSocket-Version"].Equals("13")); TestHelper.Assert(ctx["ws.Sec-WebSocket-Key"] != null); } connection = testIntf.Clone(invocationMode: InvocationMode.Datagram).GetConnection(); connection.SetBufferSize(2048, 1024); UDPConnectionInfo udpInfo = (UDPConnectionInfo)connection.GetConnectionInfo(); TestHelper.Assert(!udpInfo.Incoming); TestHelper.Assert(udpInfo.AdapterName !.Length == 0); TestHelper.Assert(udpInfo.LocalPort > 0); TestHelper.Assert(udpInfo.RemotePort == endpointPort); if (defaultHost.Equals("127.0.0.1")) { TestHelper.Assert(udpInfo.RemoteAddress.Equals(defaultHost)); TestHelper.Assert(udpInfo.LocalAddress.Equals(defaultHost)); } TestHelper.Assert(udpInfo.RcvSize >= 2048); TestHelper.Assert(udpInfo.SndSize >= 1024); } output.WriteLine("ok"); testIntf.shutdown(); communicator.Shutdown(); communicator.WaitForShutdown(); }
public static Test.IMyClassPrx allTests(global::Test.TestHelper helper) { Communicator?communicator = helper.Communicator(); TestHelper.Assert(communicator != null); var cl = Test.IMyClassPrx.Parse($"test:{helper.GetTestEndpoint(0)}", communicator); Test.IMyClassPrx oneway = cl.Clone(oneway: true); System.IO.TextWriter output = helper.GetWriter(); output.Write("testing Invoke... "); output.Flush(); { var request = OutgoingRequestFrame.WithEmptyParamList(oneway, "opOneway", idempotent: false); // Whether the proxy is oneway or not does not matter for Invoke's oneway parameter. IncomingResponseFrame response = cl.Invoke(request, oneway: true); TestHelper.Assert(response.ReplyStatus == ReplyStatus.OK); response = cl.Invoke(request, oneway: false); TestHelper.Assert(response.ReplyStatus == ReplyStatus.UserException); response = oneway.Invoke(request, oneway: true); TestHelper.Assert(response.ReplyStatus == ReplyStatus.OK); response = oneway.Invoke(request, oneway: false); TestHelper.Assert(response.ReplyStatus == ReplyStatus.UserException); request = OutgoingRequestFrame.WithParamList(cl, "opString", idempotent: false, format: null, context: null, _testString, OutputStream.IceWriterFromString); response = cl.Invoke(request); (string s1, string s2) = response.ReadReturnValue(istr => { string s1 = istr.ReadString(); string s2 = istr.ReadString(); return(s1, s2); }); TestHelper.Assert(s1.Equals(_testString) && s2.Equals(_testString)); } for (int i = 0; i < 2; ++i) { Dictionary <string, string>?ctx = null; if (i == 1) { ctx = new Dictionary <string, string> { ["raise"] = "" }; } var request = OutgoingRequestFrame.WithEmptyParamList(cl, "opException", idempotent: false, context: ctx); IncomingResponseFrame response = cl.Invoke(request); try { response.ReadVoidReturnValue(); } catch (Test.MyException) { // expected } catch (System.Exception) { TestHelper.Assert(false); } } output.WriteLine("ok"); output.Write("testing InvokeAsync... "); output.Flush(); { var request = OutgoingRequestFrame.WithEmptyParamList(oneway, "opOneway", idempotent: false); try { oneway.InvokeAsync(request, oneway: true).Wait(); } catch (System.Exception) { TestHelper.Assert(false); } request = OutgoingRequestFrame.WithParamList(cl, "opString", idempotent: false, format: null, context: null, _testString, OutputStream.IceWriterFromString); IncomingResponseFrame response = cl.InvokeAsync(request).Result; (string s1, string s2) = response.ReadReturnValue(istr => { string s1 = istr.ReadString(); string s2 = istr.ReadString(); return(s1, s2); }); TestHelper.Assert(s1.Equals(_testString)); TestHelper.Assert(s2.Equals(_testString)); } { var request = OutgoingRequestFrame.WithEmptyParamList(cl, "opException", idempotent: false); IncomingResponseFrame response = cl.InvokeAsync(request).Result; try { response.ReadVoidReturnValue(); TestHelper.Assert(false); } catch (Test.MyException) { } catch (System.Exception) { TestHelper.Assert(false); } } output.WriteLine("ok"); return(cl); }
public static void allTests(global::Test.TestHelper helper) { Communicator?communicator = helper.Communicator(); TestHelper.Assert(communicator != null); TextWriter output = helper.GetWriter(); output.Write("testing communicator operations... "); output.Flush(); { // // Test: Exercise AddAdminFacet, FindAdminFacet, RemoveAdminFacet with a typical configuration. // var properties = new Dictionary <string, string> { ["Ice.Admin.Endpoints"] = "tcp -h 127.0.0.1", ["Ice.Admin.InstanceName"] = "Test" }; var com = new Communicator(properties); TestFacets(com, true, false); com.Destroy(); } { // // Test: Verify that the operations work correctly in the presence of facet filters. // var properties = new Dictionary <string, string> { ["Ice.Admin.Endpoints"] = "tcp -h 127.0.0.1", ["Ice.Admin.InstanceName"] = "Test", ["Ice.Admin.Facets"] = "Properties" }; var com = new Communicator(properties); TestFacets(com, false, true); com.Destroy(); } { // // Test: Verify that the operations work correctly with the Admin object disabled. // var com = new Communicator(); TestFacets(com, false, false); com.Destroy(); } { // // Test: Verify that the operations work correctly with Ice.Admin.Enabled=1 // var properties = new Dictionary <string, string>() { { "Ice.Admin.Enabled", "1" } }; var com = new Communicator(properties); TestHelper.Assert(com.GetAdmin() == null); var id = Identity.Parse("test-admin"); try { com.CreateAdmin(null, id); TestHelper.Assert(false); } catch (InvalidConfigurationException) { } ObjectAdapter adapter = com.CreateObjectAdapter(); TestHelper.Assert(com.CreateAdmin(adapter, id) != null); TestHelper.Assert(com.GetAdmin() != null); TestFacets(com, true, false); com.Destroy(); } { // // Test: Verify that the operations work correctly when creation of the Admin object is delayed. // var properties = new Dictionary <string, string>() { { "Ice.Admin.Endpoints", "tcp -h 127.0.0.1" }, { "Ice.Admin.InstanceName", "Test" }, { "Ice.Admin.DelayCreation", "1" } }; var com = new Communicator(properties); TestFacets(com, true, false); com.GetAdmin(); TestFacets(com, true, false); com.Destroy(); } output.WriteLine("ok"); var factory = IRemoteCommunicatorFactoryPrx.Parse($"factory:{helper.GetTestEndpoint(0)} -t 10000", communicator); output.Write("testing process facet... "); output.Flush(); { // // Test: Verify that Process::shutdown() operation shuts down the communicator. // var props = new Dictionary <string, string> { { "Ice.Admin.Endpoints", "tcp -h 127.0.0.1" }, { "Ice.Admin.InstanceName", "Test" } }; IRemoteCommunicatorPrx?com = factory.createCommunicator(props); TestHelper.Assert(com != null); IObjectPrx?obj = com.getAdmin(); TestHelper.Assert(obj != null); IProcessPrx proc = obj.Clone("Process", IProcessPrx.Factory); proc.Shutdown(); com.waitForShutdown(); com.destroy(); } output.WriteLine("ok"); output.Write("testing properties facet... "); output.Flush(); { var props = new Dictionary <string, string> { { "Ice.Admin.Endpoints", "tcp -h 127.0.0.1" }, { "Ice.Admin.InstanceName", "Test" }, { "Prop1", "1" }, { "Prop2", "2" }, { "Prop3", "3" } }; IRemoteCommunicatorPrx?com = factory.createCommunicator(props); TestHelper.Assert(com != null); IObjectPrx?obj = com.getAdmin(); TestHelper.Assert(obj != null); IPropertiesAdminPrx pa = obj.Clone("Properties", IPropertiesAdminPrx.Factory); // // Test: PropertiesAdmin::getProperty() // TestHelper.Assert(pa.GetProperty("Prop2") == "2"); TestHelper.Assert(pa.GetProperty("Bogus") == ""); // // Test: PropertiesAdmin::getProperties() // Dictionary <string, string> pd = pa.GetPropertiesForPrefix(""); TestHelper.Assert(pd.Count == 6); TestHelper.Assert(pd["Ice.ProgramName"] == "server"); TestHelper.Assert(pd["Ice.Admin.Endpoints"] == "tcp -h 127.0.0.1"); TestHelper.Assert(pd["Ice.Admin.InstanceName"] == "Test"); TestHelper.Assert(pd["Prop1"] == "1"); TestHelper.Assert(pd["Prop2"] == "2"); TestHelper.Assert(pd["Prop3"] == "3"); Dictionary <string, string> changes; // // Test: PropertiesAdmin::setProperties() // var setProps = new Dictionary <string, string> { { "Prop1", "10" }, // Changed { "Prop2", "20" }, // Changed { "Prop3", "" }, // Removed { "Prop4", "4" }, // Added { "Prop5", "5" } // Added }; pa.SetProperties(setProps); TestHelper.Assert(pa.GetProperty("Prop1").Equals("10")); TestHelper.Assert(pa.GetProperty("Prop2").Equals("20")); TestHelper.Assert(pa.GetProperty("Prop3").Equals("")); TestHelper.Assert(pa.GetProperty("Prop4").Equals("4")); TestHelper.Assert(pa.GetProperty("Prop5").Equals("5")); changes = com.getChanges(); TestHelper.Assert(changes.Count == 5); TestHelper.Assert(changes["Prop1"].Equals("10")); TestHelper.Assert(changes["Prop2"].Equals("20")); TestHelper.Assert(changes["Prop3"].Equals("")); TestHelper.Assert(changes["Prop4"].Equals("4")); TestHelper.Assert(changes["Prop5"].Equals("5")); pa.SetProperties(setProps); changes = com.getChanges(); TestHelper.Assert(changes.Count == 0); com.destroy(); } output.WriteLine("ok"); output.Write("testing logger facet... "); output.Flush(); { var props = new Dictionary <string, string> { { "Ice.Admin.Endpoints", "tcp -h 127.0.0.1" }, { "Ice.Admin.InstanceName", "Test" }, { "NullLogger", "1" } }; IRemoteCommunicatorPrx?com = factory.createCommunicator(props); TestHelper.Assert(com != null); com.trace("testCat", "trace"); com.warning("warning"); com.error("error"); com.print("print"); IObjectPrx?obj = com.getAdmin(); TestHelper.Assert(obj != null); ILoggerAdminPrx logger = obj.Clone("Logger", ILoggerAdminPrx.Factory); // // Get all // (LogMessage[] logMessages, string prefix) = logger.GetLog(Array.Empty <LogMessageType>(), Array.Empty <string>(), -1); TestHelper.Assert(logMessages.Length == 4); TestHelper.Assert(prefix.Equals("NullLogger")); TestHelper.Assert(logMessages[0].TraceCategory.Equals("testCat") && logMessages[0].Message.Equals("trace")); TestHelper.Assert(logMessages[1].Message.Equals("warning")); TestHelper.Assert(logMessages[2].Message.Equals("error")); TestHelper.Assert(logMessages[3].Message.Equals("print")); // // Get only errors and warnings // com.error("error2"); com.print("print2"); com.trace("testCat", "trace2"); com.warning("warning2"); LogMessageType[] messageTypes = { LogMessageType.ErrorMessage, LogMessageType.WarningMessage }; (logMessages, prefix) = logger.GetLog(messageTypes, Array.Empty <string>(), -1); TestHelper.Assert(logMessages.Length == 4); TestHelper.Assert(prefix.Equals("NullLogger")); foreach (LogMessage msg in logMessages) { TestHelper.Assert(msg.Type == LogMessageType.ErrorMessage || msg.Type == LogMessageType.WarningMessage); } // // Get only errors and traces with Cat = "testCat" // com.trace("testCat2", "A"); com.trace("testCat", "trace3"); com.trace("testCat2", "B"); messageTypes = new LogMessageType[] { LogMessageType.ErrorMessage, LogMessageType.TraceMessage }; string[] categories = { "testCat" }; (logMessages, prefix) = logger.GetLog(messageTypes, categories, -1); TestHelper.Assert(logMessages.Length == 5); TestHelper.Assert(prefix.Equals("NullLogger")); foreach (LogMessage msg in logMessages) { TestHelper.Assert(msg.Type == LogMessageType.ErrorMessage || (msg.Type == LogMessageType.TraceMessage && msg.TraceCategory.Equals("testCat"))); } // // Same, but limited to last 2 messages(trace3 + error3) // com.error("error3"); (logMessages, prefix) = logger.GetLog(messageTypes, categories, 2); TestHelper.Assert(logMessages.Length == 2); TestHelper.Assert(prefix.Equals("NullLogger")); TestHelper.Assert(logMessages[0].Message.Equals("trace3")); TestHelper.Assert(logMessages[1].Message.Equals("error3")); // // Now, test RemoteLogger // ObjectAdapter adapter = communicator.CreateObjectAdapterWithEndpoints("RemoteLoggerAdapter", "tcp -h localhost"); var remoteLogger = new RemoteLogger(); IRemoteLoggerPrx myProxy = adapter.AddWithUUID(remoteLogger, IRemoteLoggerPrx.Factory); adapter.Activate(); // // No filtering // (logMessages, prefix) = logger.GetLog(Array.Empty <LogMessageType>(), Array.Empty <string>(), -1); logger.AttachRemoteLogger(myProxy, Array.Empty <LogMessageType>(), Array.Empty <string>(), -1); remoteLogger.Wait(1); foreach (LogMessage m in logMessages) { remoteLogger.CheckNextInit(prefix, m.Type, m.Message, m.TraceCategory); } com.trace("testCat", "rtrace"); com.warning("rwarning"); com.error("rerror"); com.print("rprint"); remoteLogger.Wait(4); remoteLogger.CheckNextLog(LogMessageType.TraceMessage, "rtrace", "testCat"); remoteLogger.CheckNextLog(LogMessageType.WarningMessage, "rwarning", ""); remoteLogger.CheckNextLog(LogMessageType.ErrorMessage, "rerror", ""); remoteLogger.CheckNextLog(LogMessageType.PrintMessage, "rprint", ""); TestHelper.Assert(logger.DetachRemoteLogger(myProxy)); TestHelper.Assert(!logger.DetachRemoteLogger(myProxy)); // // Use Error + Trace with "traceCat" filter with 4 limit // (logMessages, prefix) = logger.GetLog(messageTypes, categories, 4); TestHelper.Assert(logMessages.Length == 4); logger.AttachRemoteLogger(myProxy, messageTypes, categories, 4); remoteLogger.Wait(1); foreach (LogMessage m in logMessages) { remoteLogger.CheckNextInit(prefix, m.Type, m.Message, m.TraceCategory); } com.warning("rwarning2"); com.trace("testCat", "rtrace2"); com.warning("rwarning3"); com.error("rerror2"); com.print("rprint2"); remoteLogger.Wait(2); remoteLogger.CheckNextLog(LogMessageType.TraceMessage, "rtrace2", "testCat"); remoteLogger.CheckNextLog(LogMessageType.ErrorMessage, "rerror2", ""); // // Attempt reconnection with slightly different proxy // try { logger.AttachRemoteLogger(myProxy.Clone(oneway: true), messageTypes, categories, 4); TestHelper.Assert(false); } catch (RemoteLoggerAlreadyAttachedException) { // expected } com.destroy(); } output.WriteLine("ok"); output.Write("testing custom facet... "); output.Flush(); { // // Test: Verify that the custom facet is present. // var props = new Dictionary <string, string> { { "Ice.Admin.Endpoints", "tcp -h 127.0.0.1" }, { "Ice.Admin.InstanceName", "Test" } }; IRemoteCommunicatorPrx?com = factory.createCommunicator(props); TestHelper.Assert(com != null); IObjectPrx?obj = com.getAdmin(); TestHelper.Assert(obj != null); ITestFacetPrx tf = obj.Clone("TestFacet", ITestFacetPrx.Factory); tf.op(); com.destroy(); } output.WriteLine("ok"); output.Write("testing facet filtering... "); output.Flush(); { // // Test: Set Ice.Admin.Facets to expose only the Properties facet, // meaning no other facet is available. // var props = new Dictionary <string, string> { { "Ice.Admin.Endpoints", "tcp -h 127.0.0.1" }, { "Ice.Admin.InstanceName", "Test" }, { "Ice.Admin.Facets", "Properties" } }; IRemoteCommunicatorPrx?com = factory.createCommunicator(props); TestHelper.Assert(com != null); IObjectPrx?obj = com.getAdmin(); TestHelper.Assert(obj != null); try { IProcessPrx.CheckedCast(obj.Clone(facet: "Process", IObjectPrx.Factory)); TestHelper.Assert(false); } catch (ObjectNotExistException) { } try { ITestFacetPrx.CheckedCast(obj.Clone(facet: "TestFacet", IObjectPrx.Factory)); TestHelper.Assert(false); } catch (ObjectNotExistException) { } com.destroy(); } { // // Test: Set Ice.Admin.Facets to expose only the Process facet, // meaning no other facet is available. // var props = new Dictionary <string, string> { { "Ice.Admin.Endpoints", "tcp -h 127.0.0.1" }, { "Ice.Admin.InstanceName", "Test" }, { "Ice.Admin.Facets", "Process" } }; IRemoteCommunicatorPrx?com = factory.createCommunicator(props); TestHelper.Assert(com != null); IObjectPrx?obj = com.getAdmin(); TestHelper.Assert(obj != null); try { IPropertiesAdminPrx.CheckedCast(obj.Clone(facet: "Properties", IObjectPrx.Factory)); TestHelper.Assert(false); } catch (ObjectNotExistException) { } try { ITestFacetPrx.CheckedCast(obj.Clone(facet: "TestFacet", IObjectPrx.Factory)); TestHelper.Assert(false); } catch (ObjectNotExistException) { } com.destroy(); } { // // Test: Set Ice.Admin.Facets to expose only the TestFacet facet, // meaning no other facet is available. // var props = new Dictionary <string, string> { { "Ice.Admin.Endpoints", "tcp -h 127.0.0.1" }, { "Ice.Admin.InstanceName", "Test" }, { "Ice.Admin.Facets", "TestFacet" } }; IRemoteCommunicatorPrx?com = factory.createCommunicator(props); TestHelper.Assert(com != null); IObjectPrx?obj = com.getAdmin(); TestHelper.Assert(obj != null); try { IPropertiesAdminPrx.CheckedCast(obj.Clone(facet: "Properties", IObjectPrx.Factory)); TestHelper.Assert(false); } catch (ObjectNotExistException) { } try { IProcessPrx.CheckedCast(obj.Clone(facet: "Process", IObjectPrx.Factory)); TestHelper.Assert(false); } catch (ObjectNotExistException) { } com.destroy(); } { // // Test: Set Ice.Admin.Facets to expose two facets. Use whitespace to separate the // facet names. // var props = new Dictionary <string, string> { { "Ice.Admin.Endpoints", "tcp -h 127.0.0.1" }, { "Ice.Admin.InstanceName", "Test" }, { "Ice.Admin.Facets", "Properties TestFacet" } }; IRemoteCommunicatorPrx?com = factory.createCommunicator(props); TestHelper.Assert(com != null); IObjectPrx?obj = com.getAdmin(); TestHelper.Assert(obj != null); IPropertiesAdminPrx pa = obj.Clone("Properties", IPropertiesAdminPrx.Factory); TestHelper.Assert(pa.GetProperty("Ice.Admin.InstanceName").Equals("Test")); var tf = ITestFacetPrx.CheckedCast(obj.Clone(facet: "TestFacet", IObjectPrx.Factory)); tf !.op(); try { IProcessPrx.CheckedCast(obj.Clone(facet: "Process", IObjectPrx.Factory)); TestHelper.Assert(false); } catch (ObjectNotExistException) { } com.destroy(); } { // // Test: Set Ice.Admin.Facets to expose two facets. Use a comma to separate the // facet names. // var props = new Dictionary <string, string> { { "Ice.Admin.Endpoints", "tcp -h 127.0.0.1" }, { "Ice.Admin.InstanceName", "Test" }, { "Ice.Admin.Facets", "TestFacet, Process" } }; IRemoteCommunicatorPrx?com = factory.createCommunicator(props); TestHelper.Assert(com != null); IObjectPrx?obj = com.getAdmin(); TestHelper.Assert(obj != null); try { IPropertiesAdminPrx.CheckedCast(obj.Clone(facet: "Properties", IObjectPrx.Factory)); TestHelper.Assert(false); } catch (ObjectNotExistException) { } var tf = ITestFacetPrx.CheckedCast(obj.Clone(facet: "TestFacet", IObjectPrx.Factory)); TestHelper.Assert(tf != null); tf.op(); var proc = IProcessPrx.CheckedCast(obj.Clone(facet: "Process", IObjectPrx.Factory)); TestHelper.Assert(proc != null); proc.Shutdown(); com.waitForShutdown(); com.destroy(); } output.WriteLine("ok"); factory.shutdown(); }
public static Test.IInitialPrx allTests(global::Test.TestHelper helper) { Communicator?communicator = helper.Communicator(); TestHelper.Assert(communicator != null); System.IO.TextWriter output = helper.GetWriter(); var initial = Test.IInitialPrx.Parse($"initial:{helper.GetTestEndpoint(0)}", communicator); output.Write("getting proxies for interface hierarchy... "); output.Flush(); Test.MA.IIAPrx? ia = initial.iaop(); Test.MB.IIB1Prx?ib1 = initial.ib1op(); Test.MB.IIB2Prx?ib2 = initial.ib2op(); Test.MA.IICPrx? ic = initial.icop(); TestHelper.Assert(ia != null); TestHelper.Assert(ib1 != null); TestHelper.Assert(ib2 != null); TestHelper.Assert(ic != null); TestHelper.Assert(ia != ib1); TestHelper.Assert(ia != ib2); TestHelper.Assert(ia != ic); TestHelper.Assert(ib1 != ic); TestHelper.Assert(ib2 != ic); output.WriteLine("ok"); output.Write("invoking proxy operations on interface hierarchy... "); output.Flush(); Test.MA.IIAPrx? iao; Test.MB.IIB1Prx?ib1o; Test.MB.IIB2Prx?ib2o; Test.MA.IICPrx? ico; iao = ia.iaop(ia); TestHelper.Assert(iao !.Equals(ia)); iao = ia.iaop(ib1); TestHelper.Assert(iao !.Equals(ib1)); iao = ia.iaop(ib2); TestHelper.Assert(iao !.Equals(ib2)); iao = ia.iaop(ic); TestHelper.Assert(iao !.Equals(ic)); iao = ib1.iaop(ia); TestHelper.Assert(iao !.Equals(ia)); iao = ib1.iaop(ib1); TestHelper.Assert(iao !.Equals(ib1)); iao = ib1.iaop(ib2); TestHelper.Assert(iao !.Equals(ib2)); iao = ib1.iaop(ic); TestHelper.Assert(iao !.Equals(ic)); iao = ib2.iaop(ia); TestHelper.Assert(iao !.Equals(ia)); iao = ib2.iaop(ib1); TestHelper.Assert(iao !.Equals(ib1)); iao = ib2.iaop(ib2); TestHelper.Assert(iao !.Equals(ib2)); iao = ib2.iaop(ic); TestHelper.Assert(iao !.Equals(ic)); iao = ic.iaop(ia); TestHelper.Assert(iao !.Equals(ia)); iao = ic.iaop(ib1); TestHelper.Assert(iao !.Equals(ib1)); iao = ic.iaop(ib2); TestHelper.Assert(iao !.Equals(ib2)); iao = ic.iaop(ic); TestHelper.Assert(iao !.Equals(ic)); iao = ib1.ib1op(ib1); TestHelper.Assert(iao !.Equals(ib1)); ib1o = ib1.ib1op(ib1); TestHelper.Assert(ib1o !.Equals(ib1)); iao = ib1.ib1op(ic); TestHelper.Assert(iao !.Equals(ic)); ib1o = ib1.ib1op(ic); TestHelper.Assert(ib1o !.Equals(ic)); iao = ic.ib1op(ib1); TestHelper.Assert(iao !.Equals(ib1)); ib1o = ic.ib1op(ib1); TestHelper.Assert(ib1o !.Equals(ib1)); iao = ic.ib1op(ic); TestHelper.Assert(iao !.Equals(ic)); ib1o = ic.ib1op(ic); TestHelper.Assert(ib1o !.Equals(ic)); iao = ib2.ib2op(ib2); TestHelper.Assert(iao !.Equals(ib2)); ib2o = ib2.ib2op(ib2); TestHelper.Assert(ib2o !.Equals(ib2)); iao = ib2.ib2op(ic); TestHelper.Assert(iao !.Equals(ic)); ib2o = ib2.ib2op(ic); TestHelper.Assert(ib2o !.Equals(ic)); iao = ic.ib2op(ib2); TestHelper.Assert(iao !.Equals(ib2)); ib2o = ic.ib2op(ib2); TestHelper.Assert(ib2o !.Equals(ib2)); iao = ic.ib2op(ic); TestHelper.Assert(iao !.Equals(ic)); ib2o = ic.ib2op(ic); TestHelper.Assert(ib2o !.Equals(ic)); iao = ic.icop(ic); TestHelper.Assert(iao !.Equals(ic)); ib1o = ic.icop(ic); TestHelper.Assert(ib1o !.Equals(ic)); ib2o = ic.icop(ic); TestHelper.Assert(ib2o !.Equals(ic)); ico = ic.icop(ic); TestHelper.Assert(ico !.Equals(ic)); output.WriteLine("ok"); return(initial); }
public static void allTests(global::Test.TestHelper helper) { Communicator?communicator = helper.Communicator(); TestHelper.Assert(communicator != null); var manager = IServerManagerPrx.Parse($"ServerManager :{helper.GetTestEndpoint(0)}", communicator); var locator = ITestLocatorPrx.UncheckedCast(communicator.DefaultLocator !); Console.WriteLine("registry checkedcast"); var registry = ITestLocatorRegistryPrx.CheckedCast(locator.GetRegistry() !); TestHelper.Assert(registry != null); System.IO.TextWriter output = helper.GetWriter(); output.Write("testing stringToProxy... "); output.Flush(); var base1 = IObjectPrx.Parse("test @ TestAdapter", communicator); var base2 = IObjectPrx.Parse("test @ TestAdapter", communicator); var base3 = IObjectPrx.Parse("test", communicator); var base4 = IObjectPrx.Parse("ServerManager", communicator); var base5 = IObjectPrx.Parse("test2", communicator); var base6 = IObjectPrx.Parse("test @ ReplicatedAdapter", communicator); output.WriteLine("ok"); output.Write("testing ice_locator and ice_getLocator... "); TestHelper.Assert(default(ProxyIdentityComparer).Equals(base1.Locator !, communicator.DefaultLocator !)); var anotherLocator = ILocatorPrx.Parse("anotherLocator", communicator); base1 = base1.Clone(locator: anotherLocator); TestHelper.Assert(default(ProxyIdentityComparer).Equals(base1.Locator !, anotherLocator)); communicator.DefaultLocator = null; base1 = IObjectPrx.Parse("test @ TestAdapter", communicator); TestHelper.Assert(base1.Locator == null); base1 = base1.Clone(locator: anotherLocator); TestHelper.Assert(default(ProxyIdentityComparer).Equals(base1.Locator !, anotherLocator)); communicator.DefaultLocator = locator; base1 = IObjectPrx.Parse("test @ TestAdapter", communicator); TestHelper.Assert(default(ProxyIdentityComparer).Equals(base1.Locator !, communicator.DefaultLocator !)); // // We also test ice_router/ice_getRouter(perhaps we should add a // test/Ice/router test?) // TestHelper.Assert(base1.Router == null); var anotherRouter = IRouterPrx.Parse("anotherRouter", communicator); base1 = base1.Clone(router: anotherRouter); TestHelper.Assert(default(ProxyIdentityComparer).Equals(base1.Router !, anotherRouter)); var router = IRouterPrx.Parse("dummyrouter", communicator); communicator.DefaultRouter = router; base1 = IObjectPrx.Parse("test @ TestAdapter", communicator); TestHelper.Assert(default(ProxyIdentityComparer).Equals(base1.Router !, communicator.DefaultRouter !)); communicator.DefaultRouter = null; base1 = IObjectPrx.Parse("test @ TestAdapter", communicator); TestHelper.Assert(base1.Router == null); output.WriteLine("ok"); output.Write("starting server... "); output.Flush(); manager.startServer(); output.WriteLine("ok"); output.Write("testing checked cast... "); output.Flush(); var obj1 = ITestIntfPrx.CheckedCast(base1); TestHelper.Assert(obj1 != null); var obj2 = ITestIntfPrx.CheckedCast(base2); TestHelper.Assert(obj2 != null); var obj3 = ITestIntfPrx.CheckedCast(base3); TestHelper.Assert(obj3 != null); var obj4 = IServerManagerPrx.CheckedCast(base4); TestHelper.Assert(obj4 != null); var obj5 = ITestIntfPrx.CheckedCast(base5); TestHelper.Assert(obj5 != null); var obj6 = ITestIntfPrx.CheckedCast(base6); TestHelper.Assert(obj6 != null); output.WriteLine("ok"); output.Write("testing id@AdapterId indirect proxy... "); output.Flush(); obj1.shutdown(); manager.startServer(); try { obj2.IcePing(); } catch (Exception) { TestHelper.Assert(false); } output.WriteLine("ok"); output.Write("testing id@ReplicaGroupId indirect proxy... "); output.Flush(); obj1.shutdown(); manager.startServer(); try { obj6.IcePing(); } catch (Exception) { TestHelper.Assert(false); } output.WriteLine("ok"); output.Write("testing identity indirect proxy... "); output.Flush(); obj1.shutdown(); manager.startServer(); try { obj3.IcePing(); } catch (Exception) { TestHelper.Assert(false); } try { obj2.IcePing(); } catch (Exception) { TestHelper.Assert(false); } obj1.shutdown(); manager.startServer(); try { obj2.IcePing(); } catch (Exception) { TestHelper.Assert(false); } try { obj3.IcePing(); } catch (Exception) { TestHelper.Assert(false); } obj1.shutdown(); manager.startServer(); try { obj2.IcePing(); } catch (Exception) { TestHelper.Assert(false); } obj1.shutdown(); manager.startServer(); try { obj3.IcePing(); } catch (Exception) { TestHelper.Assert(false); } obj1.shutdown(); manager.startServer(); try { obj5 = ITestIntfPrx.CheckedCast(base5); TestHelper.Assert(obj5 != null); obj5.IcePing(); } catch (Exception) { TestHelper.Assert(false); } output.WriteLine("ok"); output.Write("testing proxy with unknown identity... "); output.Flush(); try { base1 = IObjectPrx.Parse("unknown/unknown", communicator); base1.IcePing(); TestHelper.Assert(false); } catch (ObjectNotFoundException) { } output.WriteLine("ok"); output.Write("testing proxy with unknown adapter... "); output.Flush(); try { base1 = IObjectPrx.Parse("test @ TestAdapterUnknown", communicator); base1.IcePing(); TestHelper.Assert(false); } catch (AdapterNotFoundException) { } output.WriteLine("ok"); output.Write("testing locator cache timeout... "); output.Flush(); IObjectPrx basencc = IObjectPrx.Parse("test@TestAdapter", communicator).Clone(cacheConnection: false); int count = locator.getRequestCount(); basencc.Clone(locatorCacheTimeout: 0).IcePing(); // No locator cache. TestHelper.Assert(++count == locator.getRequestCount()); basencc.Clone(locatorCacheTimeout: 0).IcePing(); // No locator cache. TestHelper.Assert(++count == locator.getRequestCount()); basencc.Clone(locatorCacheTimeout: 2).IcePing(); // 2s timeout. TestHelper.Assert(count == locator.getRequestCount()); System.Threading.Thread.Sleep(1300); // 1300ms basencc.Clone(locatorCacheTimeout: 1).IcePing(); // 1s timeout. TestHelper.Assert(++count == locator.getRequestCount()); IObjectPrx.Parse("test", communicator).Clone(locatorCacheTimeout: 0).IcePing(); // No locator cache. count += 2; TestHelper.Assert(count == locator.getRequestCount()); IObjectPrx.Parse("test", communicator).Clone(locatorCacheTimeout: 2).IcePing(); // 2s timeout TestHelper.Assert(count == locator.getRequestCount()); System.Threading.Thread.Sleep(1300); // 1300ms IObjectPrx.Parse("test", communicator).Clone(locatorCacheTimeout: 1).IcePing(); // 1s timeout count += 2; TestHelper.Assert(count == locator.getRequestCount()); IObjectPrx.Parse("test@TestAdapter", communicator).Clone(locatorCacheTimeout: -1).IcePing(); TestHelper.Assert(count == locator.getRequestCount()); IObjectPrx.Parse("test", communicator).Clone(locatorCacheTimeout: -1).IcePing(); TestHelper.Assert(count == locator.getRequestCount()); IObjectPrx.Parse("test@TestAdapter", communicator).IcePing(); TestHelper.Assert(count == locator.getRequestCount()); IObjectPrx.Parse("test", communicator).IcePing(); TestHelper.Assert(count == locator.getRequestCount()); TestHelper.Assert(IObjectPrx.Parse("test", communicator).Clone(locatorCacheTimeout: 99).LocatorCacheTimeout == 99); output.WriteLine("ok"); output.Write("testing proxy from server... "); output.Flush(); obj1 = ITestIntfPrx.Parse("test@TestAdapter", communicator); IHelloPrx?hello = obj1.getHello(); TestHelper.Assert(hello != null); TestHelper.Assert(hello.AdapterId.Equals("TestAdapter")); hello.sayHello(); hello = obj1.getReplicatedHello(); TestHelper.Assert(hello != null); TestHelper.Assert(hello.AdapterId.Equals("ReplicatedAdapter")); hello.sayHello(); output.WriteLine("ok"); output.Write("testing locator request queuing... "); output.Flush(); hello = obj1.getReplicatedHello() !.Clone(locatorCacheTimeout: 0, cacheConnection: false); TestHelper.Assert(hello != null); count = locator.getRequestCount(); hello.IcePing(); TestHelper.Assert(++count == locator.getRequestCount()); var results = new List <Task>(); for (int i = 0; i < 1000; i++) { results.Add(hello.sayHelloAsync()); } Task.WaitAll(results.ToArray()); results.Clear(); TestHelper.Assert(locator.getRequestCount() > count && locator.getRequestCount() < count + 999); if (locator.getRequestCount() > count + 800) { output.Write("queuing = " + (locator.getRequestCount() - count)); } count = locator.getRequestCount(); hello = hello.Clone(adapterId: "unknown"); for (int i = 0; i < 1000; i++) { results.Add(hello.sayHelloAsync().ContinueWith((Task t) => { try { t.Wait(); } catch (AggregateException ex) when(ex.InnerException is AdapterNotFoundException) { } })); } Task.WaitAll(results.ToArray()); results.Clear(); // XXX: // Take into account the retries. TestHelper.Assert(locator.getRequestCount() > count && locator.getRequestCount() < count + 1999); if (locator.getRequestCount() > count + 800) { output.Write("queuing = " + (locator.getRequestCount() - count)); } output.WriteLine("ok"); output.Write("testing adapter locator cache... "); output.Flush(); try { IObjectPrx.Parse("test@TestAdapter3", communicator).IcePing(); TestHelper.Assert(false); } catch (AdapterNotFoundException) { } registry.SetAdapterDirectProxy("TestAdapter3", locator.FindAdapterById("TestAdapter")); try { IObjectPrx.Parse("test@TestAdapter3", communicator).IcePing(); registry.SetAdapterDirectProxy("TestAdapter3", IObjectPrx.Parse($"dummy:{helper.GetTestEndpoint(99)}", communicator)); IObjectPrx.Parse("test@TestAdapter3", communicator).IcePing(); } catch (System.Exception) { TestHelper.Assert(false); } try { IObjectPrx.Parse("test@TestAdapter3", communicator).Clone(locatorCacheTimeout: 0).IcePing(); TestHelper.Assert(false); } catch (ConnectionRefusedException) { } try { IObjectPrx.Parse("test@TestAdapter3", communicator).IcePing(); } catch (ConnectionRefusedException) { } registry.SetAdapterDirectProxy("TestAdapter3", locator.FindAdapterById("TestAdapter")); try { IObjectPrx.Parse("test@TestAdapter3", communicator).IcePing(); } catch (System.Exception) { TestHelper.Assert(false); } output.WriteLine("ok"); output.Write("testing well-known object locator cache... "); output.Flush(); registry.addObject(IObjectPrx.Parse("test3@TestUnknown", communicator)); try { IObjectPrx.Parse("test3", communicator).IcePing(); TestHelper.Assert(false); } catch (AdapterNotFoundException) { } registry.addObject(IObjectPrx.Parse("test3@TestAdapter4", communicator)); // Update registry.SetAdapterDirectProxy("TestAdapter4", IObjectPrx.Parse($"dummy:{helper.GetTestEndpoint(99)}", communicator)); try { IObjectPrx.Parse("test3", communicator).IcePing(); TestHelper.Assert(false); } catch (ConnectionRefusedException) { } registry.SetAdapterDirectProxy("TestAdapter4", locator.FindAdapterById("TestAdapter")); try { IObjectPrx.Parse("test3", communicator).IcePing(); } catch (System.Exception) { TestHelper.Assert(false); } registry.SetAdapterDirectProxy("TestAdapter4", IObjectPrx.Parse($"dummy:{helper.GetTestEndpoint(99)}", communicator)); try { IObjectPrx.Parse("test3", communicator).IcePing(); } catch (System.Exception) { TestHelper.Assert(false); } try { IObjectPrx.Parse("test@TestAdapter4", communicator).Clone(locatorCacheTimeout: 0).IcePing(); TestHelper.Assert(false); } catch (ConnectionRefusedException) { } try { IObjectPrx.Parse("test@TestAdapter4", communicator).IcePing(); TestHelper.Assert(false); } catch (ConnectionRefusedException) { } try { IObjectPrx.Parse("test3", communicator).IcePing(); TestHelper.Assert(false); } catch (ConnectionRefusedException) { } registry.addObject(IObjectPrx.Parse("test3@TestAdapter", communicator)); try { IObjectPrx.Parse("test3", communicator).IcePing(); } catch (System.Exception) { TestHelper.Assert(false); } registry.addObject(IObjectPrx.Parse("test4", communicator)); try { IObjectPrx.Parse("test4", communicator).IcePing(); TestHelper.Assert(false); } catch (NoEndpointException) { } output.WriteLine("ok"); output.Write("testing locator cache background updates... "); output.Flush(); { Dictionary <string, string> properties = communicator.GetProperties(); properties["Ice.BackgroundLocatorCacheUpdates"] = "1"; Communicator ic = helper.Initialize(properties); registry.SetAdapterDirectProxy("TestAdapter5", locator.FindAdapterById("TestAdapter")); registry.addObject(IObjectPrx.Parse("test3@TestAdapter", communicator)); count = locator.getRequestCount(); IObjectPrx.Parse("test@TestAdapter5", ic).Clone(locatorCacheTimeout: 0).IcePing(); // No locator cache. IObjectPrx.Parse("test3", ic).Clone(locatorCacheTimeout: 0).IcePing(); // No locator cache. count += 3; TestHelper.Assert(count == locator.getRequestCount()); registry.SetAdapterDirectProxy("TestAdapter5", null); registry.addObject(IObjectPrx.Parse($"test3:{helper.GetTestEndpoint(99)}", communicator)); IObjectPrx.Parse("test@TestAdapter5", ic).Clone(locatorCacheTimeout: 10).IcePing(); // 10s timeout. IObjectPrx.Parse("test3", ic).Clone(locatorCacheTimeout: 10).IcePing(); // 10s timeout. TestHelper.Assert(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. IObjectPrx.Parse("test@TestAdapter5", ic).Clone(locatorCacheTimeout: 1).IcePing(); // 1s timeout. IObjectPrx.Parse("test3", ic).Clone(locatorCacheTimeout: 1).IcePing(); // 1s timeout. try { while (true) { IObjectPrx.Parse("test@TestAdapter5", ic).Clone(locatorCacheTimeout: 1).IcePing(); // 1s timeout. System.Threading.Thread.Sleep(10); } } catch (System.Exception) { // Expected to fail once they endpoints have been updated in the background. } try { while (true) { IObjectPrx.Parse("test3", ic).Clone(locatorCacheTimeout: 1).IcePing(); // 1s timeout. System.Threading.Thread.Sleep(10); } } catch (System.Exception) { // Expected to fail once they endpoints have been updated in the background. } ic.Destroy(); } output.WriteLine("ok"); output.Write("testing proxy from server after shutdown... "); output.Flush(); hello = obj1.getReplicatedHello(); TestHelper.Assert(hello != null); obj1.shutdown(); manager.startServer(); hello.sayHello(); output.WriteLine("ok"); output.Write("testing object migration... "); output.Flush(); hello = IHelloPrx.Parse("hello", communicator); obj1.migrateHello(); hello.GetConnection().Close(ConnectionClose.GracefullyWithWait); hello.sayHello(); obj1.migrateHello(); hello.sayHello(); obj1.migrateHello(); hello.sayHello(); output.WriteLine("ok"); output.Write("testing locator encoding resolution... "); output.Flush(); hello = IHelloPrx.Parse("hello", communicator); count = locator.getRequestCount(); IObjectPrx.Parse("test@TestAdapter", communicator).Clone(encoding: Encoding.V1_1).IcePing(); TestHelper.Assert(count == locator.getRequestCount()); output.WriteLine("ok"); output.Write("shutdown server... "); output.Flush(); obj1.shutdown(); output.WriteLine("ok"); output.Write("testing whether server is gone... "); output.Flush(); try { obj2.IcePing(); TestHelper.Assert(false); } catch (AdapterNotFoundException) { } try { obj3.IcePing(); TestHelper.Assert(false); } catch (AdapterNotFoundException) { } try { TestHelper.Assert(obj5 != null); obj5.IcePing(); TestHelper.Assert(false); } catch (AdapterNotFoundException) { } output.WriteLine("ok"); output.Write("testing indirect proxies to collocated objects... "); output.Flush(); communicator.SetProperty("Hello.AdapterId", Guid.NewGuid().ToString()); ObjectAdapter adapter = communicator.CreateObjectAdapterWithEndpoints("Hello", "default"); var id = new Identity(Guid.NewGuid().ToString(), ""); adapter.Add(id, new Hello()); adapter.Activate(); // Ensure that calls on the well-known proxy is collocated. IHelloPrx?helloPrx; helloPrx = IHelloPrx.Parse($"\"{id.ToString(communicator.ToStringMode)}\"", communicator); TestHelper.Assert(helloPrx.GetConnection() == null); // Ensure that calls on the indirect proxy (with adapter ID) is collocated helloPrx = IHelloPrx.CheckedCast(adapter.CreateIndirectProxy(id, IObjectPrx.Factory)); TestHelper.Assert(helloPrx != null && helloPrx.GetConnection() == null); // Ensure that calls on the direct proxy is collocated helloPrx = IHelloPrx.CheckedCast(adapter.CreateDirectProxy(id, IObjectPrx.Factory)); TestHelper.Assert(helloPrx != null && helloPrx.GetConnection() == null); output.WriteLine("ok"); output.Write("shutdown server manager... "); output.Flush(); manager.shutdown(); output.WriteLine("ok"); }