internal static void batchOneways(Test.MyClassPrx p)
{
byte[] bs1 = new byte[10 * 1024];
Test.MyClassPrx batch = Test.MyClassPrxHelper.uncheckedCast(p.ice_batchOneway());
batch.end_ice_flushBatchRequests(batch.begin_ice_flushBatchRequests());
test(batch.begin_ice_flushBatchRequests().isSent());
test(batch.begin_ice_flushBatchRequests().isCompleted_());
test(batch.begin_ice_flushBatchRequests().sentSynchronously());
for(int i = 0 ; i < 30 ; ++i)
{
batch.begin_opByteSOneway(bs1).whenCompleted(
() =>
{
},
(Ice.Exception ex) =>
{
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.begin_ice_ping();
batch2.begin_ice_ping();
batch1.end_ice_flushBatchRequests(batch1.begin_ice_flushBatchRequests());
batch1.ice_getConnection().close(false);
batch1.begin_ice_ping();
batch2.begin_ice_ping();
batch1.ice_getConnection();
batch2.ice_getConnection();
batch1.begin_ice_ping();
batch1.ice_getConnection().close(false);
batch1.begin_ice_ping();
batch2.begin_ice_ping();
}
Ice.Identity identity = new Ice.Identity();
identity.name = "invalid";
Ice.ObjectPrx batch3 = batch.ice_identity(identity);
batch3.begin_ice_ping();
batch3.end_ice_flushBatchRequests(batch3.begin_ice_flushBatchRequests());
// Make sure that a bogus batch request doesn't cause troubles to other ones.
batch3.begin_ice_ping();
batch.begin_ice_ping();
batch.end_ice_flushBatchRequests(batch.begin_ice_flushBatchRequests());
batch.begin_ice_ping();
}
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(false);
batch1.ice_ping();
batch2.ice_ping();
batch1.ice_getConnection();
batch2.ice_getConnection();
batch1.ice_ping();
batch1.ice_getConnection().close(false);
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;
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();
}
}
private static void validationTests(Configuration configuration, Test.BackgroundPrx background,
Test.BackgroundControllerPrx ctl)
{
try
{
background.op();
}
catch(Ice.LocalException)
{
test(false);
}
closeConnection(background);
try
{
// Get the read() of connection validation to throw right away.
configuration.readException(new Ice.SocketException());
background.op();
test(false);
}
catch(Ice.SocketException)
{
configuration.readException(null);
}
for(int i = 0; i < 2; ++i)
{
configuration.readException(new Ice.SocketException());
BackgroundPrx prx = i == 0 ? background : (BackgroundPrx)background.ice_oneway();
Ice.AsyncResult r = prx.begin_op();
test(!r.sentSynchronously());
try
{
prx.end_op(r);
test(false);
}
catch(Ice.SocketException)
{
}
test(r.IsCompleted);
configuration.readException(null);
}
if(!background.ice_getCommunicator().getProperties().getProperty("Ice.Default.Protocol").Equals("test-ssl") &&
!background.ice_getCommunicator().getProperties().getProperty("Ice.Default.Protocol").Equals("test-wss"))
{
try
{
// Get the read() of the connection validation to return "would block"
configuration.readReady(false);
background.op();
configuration.readReady(true);
}
catch(Ice.LocalException ex)
{
Console.Error.WriteLine(ex);
test(false);
}
closeConnection(background);
try
{
// Get the read() of the connection validation to return "would block" and then throw.
configuration.readReady(false);
configuration.readException(new Ice.SocketException());
background.op();
test(false);
}
catch(Ice.SocketException)
{
configuration.readException(null);
configuration.readReady(true);
}
for(int i = 0; i < 2; ++i)
{
configuration.readReady(false);
configuration.readException(new Ice.SocketException());
Ice.AsyncResult r = background.begin_op();
test(!r.sentSynchronously());
try
{
background.end_op(r);
test(false);
}
catch(Ice.SocketException)
{
}
test(r.IsCompleted);
configuration.readException(null);
configuration.readReady(true);
}
}
{
ctl.holdAdapter(); // Hold to block in connection validation
Ice.AsyncResult r = background.begin_op();
Ice.AsyncResult r2 = background.begin_op();
test(!r.sentSynchronously() && !r2.sentSynchronously());
test(!r.IsCompleted && !r2.IsCompleted);
ctl.resumeAdapter();
background.end_op(r);
background.end_op(r2);
test(r.IsCompleted && r2.IsCompleted);
}
try
{
// Get the write() of connection validation to throw right away.
ctl.writeException(true);
background.op();
test(false);
}
catch(Ice.ConnectionLostException)
{
ctl.writeException(false);
}
try
{
// Get the write() of the connection validation to return "would block"
ctl.writeReady(false);
background.op();
ctl.writeReady(true);
}
catch(Ice.LocalException ex)
{
Console.Error.WriteLine(ex);
test(false);
}
closeConnection(background);
try
{
// Get the write() of the connection validation to return "would block" and then throw.
ctl.writeReady(false);
ctl.writeException(true);
background.op();
test(false);
}
catch(Ice.ConnectionLostException)
{
ctl.writeException(false);
ctl.writeReady(true);
}
byte[] seq = new byte[512 * 1024];
BackgroundPrx backgroundBatchOneway = BackgroundPrxHelper.uncheckedCast(background.ice_batchOneway());
//
// First send small requests to test without auto-flushing.
//
ctl.holdAdapter();
backgroundBatchOneway.op();
backgroundBatchOneway.op();
backgroundBatchOneway.op();
backgroundBatchOneway.op();
ctl.resumeAdapter();
backgroundBatchOneway.ice_flushBatchRequests();
//
// Send bigger requests to test with auto-flushing.
//
ctl.holdAdapter();
backgroundBatchOneway.opWithPayload(seq);
backgroundBatchOneway.opWithPayload(seq);
backgroundBatchOneway.opWithPayload(seq);
backgroundBatchOneway.opWithPayload(seq);
ctl.resumeAdapter();
backgroundBatchOneway.ice_flushBatchRequests();
//
// Then try the same thing with async flush.
//
ctl.holdAdapter();
backgroundBatchOneway.op();
backgroundBatchOneway.op();
backgroundBatchOneway.op();
backgroundBatchOneway.op();
ctl.resumeAdapter();
backgroundBatchOneway.begin_ice_flushBatchRequests();
closeConnection(backgroundBatchOneway);
ctl.holdAdapter();
backgroundBatchOneway.opWithPayload(seq);
backgroundBatchOneway.opWithPayload(seq);
backgroundBatchOneway.opWithPayload(seq);
backgroundBatchOneway.opWithPayload(seq);
ctl.resumeAdapter();
Ice.AsyncResult r3 = backgroundBatchOneway.begin_ice_flushBatchRequests();
//
// We can't close the connection before ensuring all the batches have been sent since
// with auto-flushing the close connection message might be sent once the first call
// opWithPayload is sent and before the flushBatchRequests (this would therefore result
// in the flush to report a CloseConnectionException). Instead we flush a second time
// with the same callback to wait for the first flush to complete.
//
//backgroundBatchOneway.ice_getConnection().close(false);
backgroundBatchOneway.end_ice_flushBatchRequests(r3);
closeConnection(backgroundBatchOneway);
}
internal static void batchOneways(Test.MyClassPrx p)
{
byte[] tbs1 = new byte[10 * 1024];
byte[] tbs2 = new byte[99 * 1024];
byte[] tbs3 = new byte[100 * 1024];
Test.ByteS bs1 = new Test.ByteS(tbs1);
Test.ByteS bs2 = new Test.ByteS(tbs2);
Test.ByteS bs3 = new Test.ByteS(tbs3);
try
{
p.opByteSOneway(bs1);
test(true);
}
catch(Ice.MemoryLimitException)
{
test(false);
}
try
{
p.opByteSOneway(bs2);
test(true);
}
catch(Ice.MemoryLimitException)
{
test(false);
}
try
{
p.opByteSOneway(bs3);
test(false);
}
catch(Ice.MemoryLimitException)
{
test(true);
}
Test.MyClassPrx batch = Test.MyClassPrxHelper.uncheckedCast(p.ice_batchOneway());
for(int i = 0 ; i < 30 ; ++i)
{
try
{
batch.opByteSOneway(bs1);
test(true);
}
catch(Ice.MemoryLimitException)
{
test(false);
}
}
batch.ice_getConnection().flushBatchRequests();
Test.MyClassPrx batch2 = Test.MyClassPrxHelper.uncheckedCast(p.ice_batchOneway());
batch.ice_ping();
batch2.ice_ping();
batch.ice_flushBatchRequests();
batch.ice_getConnection().close(false);
batch.ice_ping();
batch2.ice_ping();
batch.ice_getConnection();
batch2.ice_getConnection();
batch.ice_ping();
batch.ice_getConnection().close(false);
try
{
batch.ice_ping();
test(false);
}
catch(Ice.CloseConnectionException)
{
}
try
{
batch2.ice_ping();
test(false);
}
catch(Ice.CloseConnectionException)
{
}
batch.ice_ping();
batch2.ice_ping();
}
internal static void batchOneways(Test.MyClassPrx p)
{
byte[] bs1 = new byte[10 * 1024];
byte[] bs2 = new byte[99 * 1024];
try
{
p.opByteSOneway(bs1);
test(true);
}
catch(Ice.MemoryLimitException)
{
test(false);
}
try
{
p.opByteSOneway(bs2);
test(true);
}
catch(Ice.MemoryLimitException)
{
test(false);
}
Test.MyClassPrx batch = Test.MyClassPrxHelper.uncheckedCast(p.ice_batchOneway());
batch.ice_flushBatchRequests();
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)
{
batch.ice_getConnection().flushBatchRequests();
Test.MyClassPrx batch2 = Test.MyClassPrxHelper.uncheckedCast(p.ice_batchOneway());
batch.ice_ping();
batch2.ice_ping();
batch.ice_flushBatchRequests();
batch.ice_getConnection().close(false);
batch.ice_ping();
batch2.ice_ping();
batch.ice_getConnection();
batch2.ice_getConnection();
batch.ice_ping();
batch.ice_getConnection().close(false);
try
{
batch.ice_ping();
test(false);
}
catch(Ice.CloseConnectionException)
{
}
try
{
batch2.ice_ping();
test(false);
}
catch(Ice.CloseConnectionException)
{
}
batch.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();
}
internal static void batchOneways(Test.MyClassPrx p)
{
byte[] bs1 = new byte[10 * 1024];
byte[] bs2 = new byte[99 * 1024];
Callback cb = new Callback();
p.begin_opByteSOneway(bs1).whenCompleted(
() =>
{
cb.called();
},
(Ice.Exception ex) =>
{
test(false);
});
cb.check();
p.begin_opByteSOneway(bs2).whenCompleted(
() =>
{
cb.called();
},
(Ice.Exception ex) =>
{
test(false);
});
cb.check();
Test.MyClassPrx batch = Test.MyClassPrxHelper.uncheckedCast(p.ice_batchOneway());
batch.end_ice_flushBatchRequests(batch.begin_ice_flushBatchRequests());
for(int i = 0 ; i < 30 ; ++i)
{
p.begin_opByteSOneway(bs1).whenCompleted(
() =>
{
},
(Ice.Exception ex) =>
{
test(false);
});
}
if(batch.ice_getConnection() != null)
{
batch.ice_getConnection().end_flushBatchRequests(batch.ice_getConnection().begin_flushBatchRequests());
Test.MyClassPrx batch2 = Test.MyClassPrxHelper.uncheckedCast(p.ice_batchOneway());
batch.begin_ice_ping();
batch2.begin_ice_ping();
batch.end_ice_flushBatchRequests(batch.begin_ice_flushBatchRequests());
batch.ice_getConnection().close(false);
batch.begin_ice_ping();
batch2.begin_ice_ping();
batch.ice_getConnection();
batch2.ice_getConnection();
batch.begin_ice_ping();
batch.ice_getConnection().close(false);
batch.begin_ice_ping().whenCompleted(
() =>
{
test(false);
},
(Ice.Exception ex) =>
{
test(ex is Ice.CloseConnectionException);
});
batch2.begin_ice_ping().whenCompleted(
() =>
{
test(false);
},
(Ice.Exception ex) =>
{
test(ex is Ice.CloseConnectionException);
});
batch.begin_ice_ping();
batch2.begin_ice_ping();
}
Ice.Identity identity = new Ice.Identity();
identity.name = "invalid";
Ice.ObjectPrx batch3 = batch.ice_identity(identity);
batch3.begin_ice_ping();
batch3.end_ice_flushBatchRequests(batch3.begin_ice_flushBatchRequests());
// Make sure that a bogus batch request doesn't cause troubles to other ones.
batch3.begin_ice_ping();
batch.begin_ice_ping();
batch.end_ice_flushBatchRequests(batch.begin_ice_flushBatchRequests());
batch.begin_ice_ping();
}