void opString(const Ice::AsyncResultPtr& result)
{
string cmp = testString;
if(_useCookie)
{
CookiePtr cookie = CookiePtr::dynamicCast(result->getCookie());
cmp = cookie->getString();
}
Ice::ByteSeq outParams;
if(result->getProxy()->end_ice_invoke(outParams, result))
{
Ice::InputStreamPtr in = Ice::createInputStream(_communicator, outParams);
in->startEncapsulation();
string s;
in->read(s);
test(s == cmp);
in->read(s);
test(s == cmp);
in->endEncapsulation();
called();
}
else
{
test(false);
};
}
void opExceptionWC(bool ok, const Ice::ByteSeq& outParams, const CookiePtr& cookie)
{
test(cookie->getString() == testString);
if(ok)
{
test(false);
}
else
{
Ice::InputStreamPtr in = Ice::createInputStream(_communicator, outParams);
in->startEncapsulation();
try
{
in->throwException();
}
catch(const Test::MyException&)
{
in->endEncapsulation();
called();
}
catch(...)
{
test(false);
}
}
}
void opExceptionPairNC(bool ok, const pair<const Ice::Byte*, const Ice::Byte*>& outParams)
{
if(ok)
{
test(false);
}
else
{
Ice::InputStreamPtr in = Ice::createInputStream(_communicator, outParams);
in->startEncapsulation();
try
{
in->throwException();
}
catch(const Test::MyException&)
{
in->endEncapsulation();
called();
}
catch(...)
{
test(false);
}
}
}
void opException(const Ice::AsyncResultPtr& result)
{
if(_useCookie)
{
CookiePtr cookie = CookiePtr::dynamicCast(result->getCookie());
test(cookie->getString() == testString);
}
Ice::ByteSeq outParams;
if(result->getProxy()->end_ice_invoke(outParams, result))
{
test(false);
}
else
{
Ice::InputStreamPtr in = Ice::createInputStream(_communicator, outParams);
in->startEncapsulation();
try
{
in->throwException();
}
catch(const Test::MyException&)
{
in->endEncapsulation();
called();
}
catch(...)
{
test(false);
}
}
}
void opStringWC(bool ok, const Ice::ByteSeq& outParams, const CookiePtr& cookie)
{
if(ok)
{
Ice::InputStreamPtr in = Ice::createInputStream(_communicator, outParams);
in->startEncapsulation();
string s;
in->read(s);
test(s == cookie->getString());
in->read(s);
test(s == cookie->getString());
in->endEncapsulation();
called();
}
else
{
test(false);
}
}
void opStringPairNC(bool ok, const pair<const Ice::Byte*, const Ice::Byte*>& outParams)
{
if(ok)
{
Ice::InputStreamPtr in = Ice::createInputStream(_communicator, outParams);
in->startEncapsulation();
string s;
in->read(s);
test(s == testString);
in->read(s);
test(s == testString);
in->endEncapsulation();
called();
}
else
{
test(false);
}
}
Test::MyClassPrxPtr
allTests(const Ice::CommunicatorPtr& communicator)
{
string ref = "test:" + getTestEndpoint(communicator, 0);
Ice::ObjectPrxPtr base = communicator->stringToProxy(ref);
test(base);
Test::MyClassPrxPtr cl = ICE_CHECKED_CAST(Test::MyClassPrx, base);
test(cl);
Test::MyClassPrxPtr oneway = cl->ice_oneway();
Test::MyClassPrxPtr batchOneway = cl->ice_batchOneway();
cout << "testing ice_invoke... " << flush;
{
Ice::ByteSeq inEncaps, outEncaps;
if(!oneway->ice_invoke("opOneway", ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps))
{
test(false);
}
test(batchOneway->ice_invoke("opOneway", ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps));
test(batchOneway->ice_invoke("opOneway", ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps));
test(batchOneway->ice_invoke("opOneway", ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps));
test(batchOneway->ice_invoke("opOneway", ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps));
batchOneway->ice_flushBatchRequests();
Ice::OutputStreamPtr out = Ice::createOutputStream(communicator);
out->startEncapsulation();
out->write(testString);
out->endEncapsulation();
out->finished(inEncaps);
// ice_invoke
if(cl->ice_invoke("opString", ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps))
{
Ice::InputStreamPtr in = Ice::createInputStream(communicator, outEncaps);
in->startEncapsulation();
string s;
in->read(s);
test(s == testString);
in->read(s);
test(s == testString);
in->endEncapsulation();
}
else
{
test(false);
}
// ice_invoke with array mapping
pair<const ::Ice::Byte*, const ::Ice::Byte*> inPair(&inEncaps[0], &inEncaps[0] + inEncaps.size());
if(cl->ice_invoke("opString", ICE_ENUM(OperationMode, Normal), inPair, outEncaps))
{
Ice::InputStreamPtr in = Ice::createInputStream(communicator, outEncaps);
in->startEncapsulation();
string s;
in->read(s);
test(s == testString);
in->read(s);
test(s == testString);
in->endEncapsulation();
}
else
{
test(false);
}
}
{
Ice::ByteSeq inEncaps, outEncaps;
if(cl->ice_invoke("opException", ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps))
{
test(false);
}
else
{
Ice::InputStreamPtr in = Ice::createInputStream(communicator, outEncaps);
in->startEncapsulation();
try
{
in->throwException();
}
catch(const Test::MyException&)
{
}
catch(...)
{
test(false);
}
in->endEncapsulation();
}
}
cout << "ok" << endl;
cout << "testing asynchronous ice_invoke... " << flush;
#ifdef ICE_CPP11_MAPPING
{
promise<bool> completed;
Ice::ByteSeq inEncaps, outEncaps;
oneway->ice_invoke_async(
"opOneway",
OperationMode::Normal,
inEncaps,
nullptr,
[&](exception_ptr ex)
{
completed.set_exception(ex);
},
[&](bool)
{
completed.set_value(true);
});
test(completed.get_future().get());
}
{
promise<bool> completed;
Ice::ByteSeq inEncaps, outEncaps;
Ice::OutputStreamPtr out = Ice::createOutputStream(communicator);
out->startEncapsulation();
out->write(testString);
out->endEncapsulation();
out->finished(inEncaps);
cl->ice_invoke_async("opString", OperationMode::Normal, inEncaps,
[&](bool ok, vector<Ice::Byte> outParams)
{
outEncaps = move(outParams);
completed.set_value(ok);
},
[&](exception_ptr ex)
{
completed.set_exception(ex);
});
test(completed.get_future().get());
Ice::InputStreamPtr in = Ice::createInputStream(communicator, outEncaps);
in->startEncapsulation();
string s;
in->read(s);
test(s == testString);
in->read(s);
test(s == testString);
in->endEncapsulation();
}
{
promise<bool> completed;
promise<void> sent;
Ice::ByteSeq inEncaps, outEncaps;
Ice::OutputStreamPtr out = Ice::createOutputStream(communicator);
out->startEncapsulation();
out->write(testString);
out->endEncapsulation();
out->finished(inEncaps);
pair<const ::Ice::Byte*, const ::Ice::Byte*> inPair(&inEncaps[0], &inEncaps[0] + inEncaps.size());
cl->ice_invoke_async("opString", OperationMode::Normal, inPair,
[&](bool ok, pair<const Ice::Byte*, const Ice::Byte*> outParams)
{
vector<Ice::Byte>(outParams.first, outParams.second).swap(outEncaps);
completed.set_value(ok);
},
[&](exception_ptr ex)
{
completed.set_exception(ex);
},
[&](bool)
{
sent.set_value();
});
sent.get_future().get(); // Ensure sent callback was called
test(completed.get_future().get());
Ice::InputStreamPtr in = Ice::createInputStream(communicator, outEncaps);
in->startEncapsulation();
string s;
in->read(s);
test(s == testString);
in->read(s);
test(s == testString);
in->endEncapsulation();
}
{
promise<bool> completed;
promise<void> sent;
Ice::ByteSeq inEncaps, outEncaps;
cl->ice_invoke_async("opException", OperationMode::Normal, inEncaps,
[&](bool ok, vector<Ice::Byte> outParams)
{
outEncaps = move(outParams);
completed.set_value(ok);
},
[&](exception_ptr ex)
{
completed.set_exception(ex);
},
[&](bool)
{
sent.set_value();
});
sent.get_future().get(); // Ensure sent callback was called
test(!completed.get_future().get());
Ice::InputStreamPtr in = Ice::createInputStream(communicator, outEncaps);
in->startEncapsulation();
try
{
in->throwException();
test(false);
}
catch(const Test::MyException&)
{
}
catch(...)
{
test(false);
}
}
#else
void (::Callback::*nullEx)(const Ice::Exception&) = 0;
void (::Callback::*nullExWC)(const Ice::Exception&, const CookiePtr&) = 0;
{
CookiePtr cookie = new Cookie();
Ice::ByteSeq inEncaps, outEncaps;
Ice::AsyncResultPtr result = oneway->begin_ice_invoke("opOneway", Ice::Normal, inEncaps);
if(!oneway->end_ice_invoke(outEncaps, result))
{
test(false);
}
Ice::OutputStreamPtr out = Ice::createOutputStream(communicator);
out->startEncapsulation();
out->write(testString);
out->endEncapsulation();
out->finished(inEncaps);
// begin_ice_invoke with no callback
result = cl->begin_ice_invoke("opString", Ice::Normal, inEncaps);
if(cl->end_ice_invoke(outEncaps, result))
{
Ice::InputStreamPtr in = Ice::createInputStream(communicator, outEncaps);
in->startEncapsulation();
string s;
in->read(s);
test(s == testString);
in->read(s);
test(s == testString);
in->endEncapsulation();
}
else
{
test(false);
};
// begin_ice_invoke with no callback and array mapping
pair<const ::Ice::Byte*, const ::Ice::Byte*> inPair(&inEncaps[0], &inEncaps[0] + inEncaps.size());
result = cl->begin_ice_invoke("opString", Ice::Normal, inPair);
if(cl->end_ice_invoke(outEncaps, result))
{
Ice::InputStreamPtr in = Ice::createInputStream(communicator, outEncaps);
in->startEncapsulation();
string s;
in->read(s);
test(s == testString);
in->read(s);
test(s == testString);
in->endEncapsulation();
}
else
{
test(false);
};
// begin_ice_invoke with Callback
::CallbackPtr cb = new ::Callback(communicator, false);
cl->begin_ice_invoke("opString", Ice::Normal, inEncaps, Ice::newCallback(cb, &Callback::opString));
cb->check();
// begin_ice_invoke with Callback and Cookie
cb = new ::Callback(communicator, true);
cl->begin_ice_invoke("opString", Ice::Normal, inEncaps, Ice::newCallback(cb, &Callback::opString), cookie);
cb->check();
// begin_ice_invoke with Callback_Object_ice_invoke
cb = new ::Callback(communicator, false);
Ice::Callback_Object_ice_invokePtr d = Ice::newCallback_Object_ice_invoke(cb, &Callback::opStringNC, nullEx);
cl->begin_ice_invoke("opString", Ice::Normal, inEncaps, d);
cb->check();
// begin_ice_invoke with Callback_Object_ice_invoke with Cookie
cb = new ::Callback(communicator, false);
d = Ice::newCallback_Object_ice_invoke(cb, &Callback::opStringWC, nullExWC);
cl->begin_ice_invoke("opString", Ice::Normal, inEncaps, d, cookie);
cb->check();
// begin_ice_invoke with Callback_Object_ice_invoke and array mapping
cb = new ::Callback(communicator, false);
d = Ice::newCallback_Object_ice_invoke(cb, &Callback::opStringNC, nullEx);
cl->begin_ice_invoke("opString", Ice::Normal, inPair, d);
cb->check();
// begin_ice_invoke with Callback_Object_ice_invoke and array mapping with Cookie
cb = new ::Callback(communicator, false);
d = Ice::newCallback_Object_ice_invoke(cb, &Callback::opStringWC, nullExWC);
cl->begin_ice_invoke("opString", Ice::Normal, inPair, d, cookie);
cb->check();
}
{
CookiePtr cookie = new Cookie();
Ice::ByteSeq inEncaps, outEncaps;
// begin_ice_invoke with no callback
Ice::AsyncResultPtr result = cl->begin_ice_invoke("opException", Ice::Normal, inEncaps);
if(cl->end_ice_invoke(outEncaps, result))
{
test(false);
}
else
{
Ice::InputStreamPtr in = Ice::createInputStream(communicator, outEncaps);
in->startEncapsulation();
try
{
in->throwException();
}
catch(const Test::MyException&)
{
}
catch(...)
{
test(false);
}
in->endEncapsulation();
}
// begin_ice_invoke with Callback
::CallbackPtr cb = new ::Callback(communicator, false);
cl->begin_ice_invoke("opException", Ice::Normal, inEncaps, Ice::newCallback(cb, &Callback::opException));
cb->check();
// begin_ice_invoke with Callback and Cookie
cb = new ::Callback(communicator, true);
cl->begin_ice_invoke("opException", Ice::Normal, inEncaps, Ice::newCallback(cb, &Callback::opException),
cookie);
cb->check();
// begin_ice_invoke with Callback_Object_ice_invoke
cb = new ::Callback(communicator, false);
Ice::Callback_Object_ice_invokePtr d = Ice::newCallback_Object_ice_invoke(cb, &Callback::opExceptionNC, nullEx);
cl->begin_ice_invoke("opException", Ice::Normal, inEncaps, d);
cb->check();
// begin_ice_invoke with Callback_Object_ice_invoke with Cookie
cb = new ::Callback(communicator, false);
d = Ice::newCallback_Object_ice_invoke(cb, &Callback::opExceptionWC, nullExWC);
cl->begin_ice_invoke("opException", Ice::Normal, inEncaps, d, cookie);
cb->check();
}
#endif
cout << "ok" << endl;
return cl;
}
int
InvokeClient::run(int argc, char*[])
{
if(argc > 1)
{
cerr << appName() << ": too many arguments" << endl;
return EXIT_FAILURE;
}
Ice::ObjectPrx obj = communicator()->propertyToProxy("Printer.Proxy");
menu();
char ch;
do
{
try
{
cout << "==> ";
cin >> ch;
if(ch == '1')
{
//
// Marshal the in parameter.
//
Ice::ByteSeq inParams, outParams;
Ice::OutputStreamPtr out = Ice::createOutputStream(communicator());
out->startEncapsulation();
out->write("The streaming API works!");
out->endEncapsulation();
out->finished(inParams);
//
// Invoke operation.
//
if(!obj->ice_invoke("printString", Ice::Normal, inParams, outParams))
{
cout << "Unknown user exception" << endl;
}
}
else if(ch == '2')
{
//
// Marshal the in parameter.
//
Ice::ByteSeq inParams, outParams;
Ice::OutputStreamPtr out = Ice::createOutputStream(communicator());
out->startEncapsulation();
Demo::StringSeq arr;
arr.push_back("The");
arr.push_back("streaming");
arr.push_back("API");
arr.push_back("works!");
out->write(arr);
out->endEncapsulation();
out->finished(inParams);
//
// Invoke operation.
//
if(!obj->ice_invoke("printStringSequence", Ice::Normal, inParams, outParams))
{
cout << "Unknown user exception" << endl;
}
}
else if(ch == '3')
{
//
// Marshal the in parameter.
//
Ice::ByteSeq inParams, outParams;
Ice::OutputStreamPtr out = Ice::createOutputStream(communicator());
out->startEncapsulation();
Demo::StringDict dict;
dict["The"] = "streaming";
dict["API"] = "works!";
out->write(dict);
out->endEncapsulation();
out->finished(inParams);
//
// Invoke operation.
//
if(!obj->ice_invoke("printDictionary", Ice::Normal, inParams, outParams))
{
cout << "Unknown user exception" << endl;
}
}
else if(ch == '4')
{
//
// Marshal the in parameter.
//
Ice::ByteSeq inParams, outParams;
Ice::OutputStreamPtr out = Ice::createOutputStream(communicator());
out->startEncapsulation();
out->write(Demo::green);
out->endEncapsulation();
out->finished(inParams);
//
// Invoke operation.
//
if(!obj->ice_invoke("printEnum", Ice::Normal, inParams, outParams))
{
cout << "Unknown user exception" << endl;
}
}
else if(ch == '5')
{
//
// Marshal the in parameter.
//
Ice::ByteSeq inParams, outParams;
Ice::OutputStreamPtr out = Ice::createOutputStream(communicator());
out->startEncapsulation();
Demo::Structure s;
s.name = "red";
s.value = Demo::red;
out->write(s);
out->endEncapsulation();
out->finished(inParams);
//
// Invoke operation.
//
if(!obj->ice_invoke("printStruct", Ice::Normal, inParams, outParams))
{
cout << "Unknown user exception" << endl;
}
}
else if(ch == '6')
{
//
// Marshal the in parameter.
//
Ice::ByteSeq inParams, outParams;
Ice::OutputStreamPtr out = Ice::createOutputStream(communicator());
out->startEncapsulation();
Demo::StructureSeq arr;
arr.push_back(Demo::Structure());
arr.back().name = "red";
arr.back().value = Demo::red;
arr.push_back(Demo::Structure());
arr.back().name = "green";
arr.back().value = Demo::green;
arr.push_back(Demo::Structure());
arr.back().name = "blue";
arr.back().value = Demo::blue;
out->write(arr);
out->endEncapsulation();
out->finished(inParams);
//
// Invoke operation.
//
if(!obj->ice_invoke("printStructSequence", Ice::Normal, inParams, outParams))
{
cout << "Unknown user exception" << endl;
}
}
else if(ch == '7')
{
//
// Marshal the in parameter.
//
Ice::ByteSeq inParams, outParams;
Ice::OutputStreamPtr out = Ice::createOutputStream(communicator());
out->startEncapsulation();
Demo::CPtr c = new Demo::C;
c->s.name = "blue";
c->s.value = Demo::blue;
out->write(c);
out->writePendingObjects();
out->endEncapsulation();
out->finished(inParams);
//
// Invoke operation.
//
if(!obj->ice_invoke("printClass", Ice::Normal, inParams, outParams))
{
cout << "Unknown user exception" << endl;
}
}
else if(ch == '8')
{
//
// Invoke operation.
//
Ice::ByteSeq inParams, outParams;
if(!obj->ice_invoke("getValues", Ice::Normal, inParams, outParams))
{
cout << "Unknown user exception" << endl;
continue;
}
//
// Unmarshal the results.
//
Ice::InputStreamPtr in = Ice::createInputStream(communicator(), outParams);
in->startEncapsulation();
Demo::CPtr c;
in->read(c);
string str;
in->read(str);
in->readPendingObjects();
in->endEncapsulation();
cout << "Got string `" << str << "' and class: s.name=" << c->s.name
<< ", s.value=" << c->s.value << endl;
}
else if(ch == '9')
{
//
// Invoke operation.
//
Ice::ByteSeq inParams, outParams;
if(obj->ice_invoke("throwPrintFailure", Ice::Normal, inParams, outParams))
{
cout << "Expected exception" << endl;
continue;
}
Ice::InputStreamPtr in = Ice::createInputStream(communicator(), outParams);
in->startEncapsulation();
try
{
in->throwException();
}
catch(const Demo::PrintFailure&)
{
// Expected.
}
catch(const Ice::UserException&)
{
cout << "Unknown user exception" << endl;
}
in->endEncapsulation();
}
else if(ch == 's')
{
Ice::ByteSeq inParams, outParams;
obj->ice_invoke("shutdown", Ice::Normal, inParams, outParams);
}
else if(ch == 'x')
{
// Nothing to do.
}
else if(ch == '?')
{
menu();
}
else
{
cout << "unknown command `" << ch << "'" << endl;
menu();
}
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
}
}
while(cin.good() && ch != 'x');
return EXIT_SUCCESS;
}