/// <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");
}
}
