void
batchOnewaysAMI(const Test::MyClassPrx& p)
{
const Test::ByteS bs1(10 * 1024);
const Test::ByteS bs2(99 * 1024);
const Test::ByteS bs3(100 * 1024);
CallbackPtr cb = new Callback();
p->begin_opByteSOneway(bs1, Test::newCallback_MyClass_opByteSOneway(new Callback_ByteSOneway1(cb),
&Callback_ByteSOneway1::response, &Callback_ByteSOneway1::exception));
cb->check();
p->begin_opByteSOneway(bs2, Test::newCallback_MyClass_opByteSOneway(new Callback_ByteSOneway1(cb),
&Callback_ByteSOneway1::response, &Callback_ByteSOneway1::exception));
cb->check();
Test::MyClassPrx batch = Test::MyClassPrx::uncheckedCast(p->ice_batchOneway());
batch->end_ice_flushBatchRequests(batch->begin_ice_flushBatchRequests());
int i;
for(i = 0 ; i < 30 ; ++i)
{
p->begin_opByteSOneway(bs1, Test::newCallback_MyClass_opByteSOneway(new Callback_ByteSOneway3(),
&Callback_ByteSOneway3::response,
&Callback_ByteSOneway3::exception));
}
if(batch->ice_getConnection())
{
batch->ice_getConnection()->end_flushBatchRequests(batch->ice_getConnection()->begin_flushBatchRequests());
Test::MyClassPrx batch2 = Test::MyClassPrx::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(Ice::newCallback_Object_ice_ping(new Callback_ping(cb), &Callback_ping::response, &Callback_ping::exception));
cb->check();
batch2->begin_ice_ping(Ice::newCallback_Object_ice_ping(new Callback_ping(cb), &Callback_ping::response, &Callback_ping::exception));
cb->check();
batch->begin_ice_ping();
batch2->begin_ice_ping();
}
Ice::Identity 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();
}
void
onewaysAMI(const Ice::CommunicatorPtr&, const Test::MyClassPrx& proxy)
{
Test::MyClassPrx p = Test::MyClassPrx::uncheckedCast(proxy->ice_oneway());
{
CallbackPtr cb = new Callback;
Ice::Callback_Object_ice_pingPtr callback =
Ice::newCallback_Object_ice_ping(cb, &Callback::noException, &Callback::sent);
p->begin_ice_ping(callback);
cb->check();
}
{
try
{
p->begin_ice_isA(Test::MyClass::ice_staticId());
test(false);
}
catch(const IceUtil::IllegalArgumentException&)
{
}
}
{
try
{
p->begin_ice_id();
test(false);
}
catch(const IceUtil::IllegalArgumentException&)
{
}
}
{
try
{
p->begin_ice_ids();
test(false);
}
catch(const IceUtil::IllegalArgumentException&)
{
}
}
{
CallbackPtr cb = new Callback;
Test::Callback_MyClass_opVoidPtr callback =
Test::newCallback_MyClass_opVoid(cb, &Callback::noException, &Callback::sent);
p->begin_opVoid(callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Test::Callback_MyClass_opIdempotentPtr callback =
Test::newCallback_MyClass_opIdempotent(cb, &Callback::noException, &Callback::sent);
p->begin_opIdempotent(callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Test::Callback_MyClass_opNonmutatingPtr callback =
Test::newCallback_MyClass_opNonmutating(cb, &Callback::noException, &Callback::sent);
p->begin_opNonmutating(callback);
cb->check();
}
{
try
{
p->begin_opByte(Ice::Byte(0xff), Ice::Byte(0x0f));
test(false);
}
catch(const IceUtil::IllegalArgumentException&)
{
}
}
#ifdef ICE_CPP11
{
CallbackPtr cb = new Callback;
p->begin_ice_ping(nullptr,
[=](const Ice::Exception& ex){ cb->noException(ex); },
[=](bool sent){ cb->sent(sent); });
cb->check();
}
{
try
{
p->begin_ice_isA(Test::MyClass::ice_staticId(), [=](bool){ test(false); });
test(false);
}
catch(const IceUtil::IllegalArgumentException&)
{
}
}
{
try
{
p->begin_ice_id([=](const string&){ test(false); });
test(false);
}
catch(const IceUtil::IllegalArgumentException&)
{
}
}
{
try
{
p->begin_ice_ids([=](const Ice::StringSeq&){ test(false); });
test(false);
}
catch(const IceUtil::IllegalArgumentException&)
{
}
}
{
CallbackPtr cb = new Callback;
p->begin_opVoid(nullptr,
[=](const Ice::Exception& ex){ cb->noException(ex); },
[=](bool sent){ cb->sent(sent); });
cb->check();
}
{
CallbackPtr cb = new Callback;
p->begin_opIdempotent(nullptr,
[=](const Ice::Exception& ex){ cb->noException(ex); },
[=](bool sent){ cb->sent(sent); });
cb->check();
}
{
CallbackPtr cb = new Callback;
p->begin_opNonmutating(nullptr,
[=](const Ice::Exception& ex){ cb->noException(ex); },
[=](bool sent){ cb->sent(sent); });
cb->check();
}
{
try
{
p->begin_opByte(Ice::Byte(0xff), Ice::Byte(0x0f), [=](const Ice::Byte&, const Ice::Byte&){ test(false); });
test(false);
}
catch(const IceUtil::IllegalArgumentException&)
{
}
}
#endif
}