void Chat::runLeaveChat() { QLOG_TRACE() << __PRETTY_FUNCTION__; bool success = true; QString message; try { sdc::ByteSeq plainLog; Ice::OutputStreamPtr out = Ice::createOutputStream(sessionPrx->ice_getCommunicator()); QMutexLocker logLocker(&logMutex); out->write(log); out->finished(plainLog); logLocker.unlock(); QSharedPointer<const LoginUser> user = session.getUser(); sdc::SecureContainer cryptLog; cryptLog.data = user->encrypt(plainLog); cryptLog.signature = user->sign(plainLog); sessionPrx->saveLog(chatID.toStdString(), QDateTime::currentDateTimeUtc().toTime_t(), cryptLog); sessionPrx->leaveChat(chatID.toStdString()); } catch (const sdc::LogException &e) { success = false; message = e.what.c_str(); } catch (const sdc::SessionException &e) { success = false; message = e.what.c_str(); } catch (const sdc::InterServerException &e) { success = false; message = e.what.c_str(); } catch (const sdc::SecurityException &e) { success = false; message = e.what(); } catch (...) { success = false; message = "Unexpected exception"; } emit leaveChatCompleted(chatID); emit leaveChatCompleted(success, message); }
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; }
TestIntfPrx allTests(const Ice::CommunicatorPtr& communicator) { string ref = "test:default -p 12010"; Ice::ObjectPrx obj = communicator->stringToProxy(ref); test(obj); TestIntfPrx proxy = TestIntfPrx::checkedCast(obj); test(proxy); cout << "testing enum values... " << flush; test(static_cast<int>(benum1) == 0); test(static_cast<int>(benum2) == 1); test(static_cast<int>(benum3) == ByteConst1); test(static_cast<int>(benum4) == ByteConst1 + 1); test(static_cast<int>(benum5) == ShortConst1); test(static_cast<int>(benum6) == ShortConst1 + 1); test(static_cast<int>(benum7) == IntConst1); test(static_cast<int>(benum8) == IntConst1 + 1); test(static_cast<int>(benum9) == LongConst1); test(static_cast<int>(benum10) == LongConst1 + 1); test(static_cast<int>(benum11) == ByteConst2); test(static_cast<int>(senum1) == 3); test(static_cast<int>(senum2) == 4); test(static_cast<int>(senum3) == ByteConst1); test(static_cast<int>(senum4) == ByteConst1 + 1); test(static_cast<int>(senum5) == ShortConst1); test(static_cast<int>(senum6) == ShortConst1 + 1); test(static_cast<int>(senum7) == IntConst1); test(static_cast<int>(senum8) == IntConst1 + 1); test(static_cast<int>(senum9) == LongConst1); test(static_cast<int>(senum10) == LongConst1 + 1); test(static_cast<int>(senum11) == ShortConst2); test(static_cast<int>(ienum1) == 0); test(static_cast<int>(ienum2) == 1); test(static_cast<int>(ienum3) == ByteConst1); test(static_cast<int>(ienum4) == ByteConst1 + 1); test(static_cast<int>(ienum5) == ShortConst1); test(static_cast<int>(ienum6) == ShortConst1 + 1); test(static_cast<int>(ienum7) == IntConst1); test(static_cast<int>(ienum8) == IntConst1 + 1); test(static_cast<int>(ienum9) == LongConst1); test(static_cast<int>(ienum10) == LongConst1 + 1); test(static_cast<int>(ienum11) == IntConst2); test(static_cast<int>(ienum12) == LongConst2); test(static_cast<int>(red) == 0); test(static_cast<int>(green) == 1); test(static_cast<int>(blue) == 2); cout << "ok" << endl; cout << "testing enum streaming... " << flush; Ice::OutputStreamPtr out; Ice::ByteSeq bytes; const bool encoding_1_0 = communicator->getProperties()->getProperty("Ice.Default.EncodingVersion") == "1.0"; out = Ice::createOutputStream(communicator); out->write(benum11); out->finished(bytes); test(bytes.size() == 1); // ByteEnum should require one byte out = Ice::createOutputStream(communicator); out->write(senum11); out->finished(bytes); test(bytes.size() == (encoding_1_0 ? 2 : 5)); out = Ice::createOutputStream(communicator); out->write(ienum11); out->finished(bytes); test(bytes.size() == (encoding_1_0 ? 4 : 5)); out = Ice::createOutputStream(communicator); out->write(blue); out->finished(bytes); test(bytes.size() == 1); // SimpleEnum should require one byte cout << "ok" << endl; cout << "testing enum operations... " << flush; ByteEnum byteEnum; test(proxy->opByte(benum1, byteEnum) == benum1); test(byteEnum == benum1); test(proxy->opByte(benum11, byteEnum) == benum11); test(byteEnum == benum11); ShortEnum shortEnum; test(proxy->opShort(senum1, shortEnum) == senum1); test(shortEnum == senum1); test(proxy->opShort(senum11, shortEnum) == senum11); test(shortEnum == senum11); IntEnum intEnum; test(proxy->opInt(ienum1, intEnum) == ienum1); test(intEnum == ienum1); test(proxy->opInt(ienum11, intEnum) == ienum11); test(intEnum == ienum11); test(proxy->opInt(ienum12, intEnum) == ienum12); test(intEnum == ienum12); SimpleEnum s; test(proxy->opSimple(green, s) == green); test(s == green); cout << "ok" << endl; cout << "testing enum exceptions... " << flush; try { proxy->opByte(static_cast<ByteEnum>(-1), byteEnum); // Negative enumerators are not supported test(false); } catch(const Ice::MarshalException&) { } try { proxy->opByte(static_cast<ByteEnum>(127), byteEnum); // Invalid enumerator test(false); } catch(const Ice::MarshalException&) { } try { proxy->opShort(static_cast<ShortEnum>(-1), shortEnum); // Negative enumerators are not supported test(false); } catch(const Ice::MarshalException&) { } try { proxy->opShort(static_cast<ShortEnum>(0), shortEnum); // Invalid enumerator test(false); } catch(const Ice::MarshalException&) { } try { proxy->opShort(static_cast<ShortEnum>(32767), shortEnum); // Invalid enumerator test(false); } catch(const Ice::MarshalException&) { } try { proxy->opInt(static_cast<IntEnum>(-1), intEnum); // Negative enumerators are not supported test(false); } catch(const Ice::MarshalException&) { } cout << "ok" << endl; return proxy; }
Test::MyClassPrx allTests(const Ice::CommunicatorPtr& communicator) { string ref = "test:default -p 12010"; Ice::ObjectPrx base = communicator->stringToProxy(ref); test(base); Test::MyClassPrx cl = Test::MyClassPrx::checkedCast(base); test(cl); Test::MyClassPrx oneway = cl->ice_oneway(); void (Callback::*nullEx)(const Ice::Exception&) = 0; void (Callback::*nullExWC)(const Ice::Exception&, const CookiePtr&) = 0; cout << "testing ice_invoke... " << flush; { Ice::ByteSeq inParams, outParams; if(!oneway->ice_invoke("opOneway", Ice::Normal, inParams, outParams)) { test(false); } Ice::OutputStreamPtr out = Ice::createOutputStream(communicator); out->write(testString); out->finished(inParams); // ice_invoke if(cl->ice_invoke("opString", Ice::Normal, inParams, outParams)) { Ice::InputStreamPtr in = Ice::createInputStream(communicator, outParams); string s; in->read(s); test(s == testString); in->read(s); test(s == testString); } else { test(false); } // ice_invoke with array mapping pair<const ::Ice::Byte*, const ::Ice::Byte*> inPair(&inParams[0], &inParams[0] + inParams.size()); if(cl->ice_invoke("opString", Ice::Normal, inPair, outParams)) { Ice::InputStreamPtr in = Ice::createInputStream(communicator, outParams); string s; in->read(s); test(s == testString); in->read(s); test(s == testString); } else { test(false); } } { Ice::ByteSeq inParams, outParams; if(cl->ice_invoke("opException", Ice::Normal, inParams, outParams)) { test(false); } else { Ice::InputStreamPtr in = Ice::createInputStream(communicator, outParams); try { in->throwException(); } catch(const Test::MyException&) { } catch(...) { test(false); } } } cout << "ok" << endl; cout << "testing asynchronous ice_invoke... " << flush; { CookiePtr cookie = new Cookie(); Ice::ByteSeq inParams, outParams; Ice::AsyncResultPtr result = oneway->begin_ice_invoke("opOneway", Ice::Normal, inParams); if(!oneway->end_ice_invoke(outParams, result)) { test(false); } Ice::OutputStreamPtr out = Ice::createOutputStream(communicator); out->write(testString); out->finished(inParams); // begin_ice_invoke with no callback result = cl->begin_ice_invoke("opString", Ice::Normal, inParams); if(cl->end_ice_invoke(outParams, result)) { Ice::InputStreamPtr in = Ice::createInputStream(communicator, outParams); string s; in->read(s); test(s == testString); in->read(s); test(s == testString); } else { test(false); }; // begin_ice_invoke with no callback and array mapping pair<const ::Ice::Byte*, const ::Ice::Byte*> inPair(&inParams[0], &inParams[0] + inParams.size()); result = cl->begin_ice_invoke("opString", Ice::Normal, inPair); if(cl->end_ice_invoke(outParams, result)) { Ice::InputStreamPtr in = Ice::createInputStream(communicator, outParams); string s; in->read(s); test(s == testString); in->read(s); test(s == testString); } else { test(false); }; // begin_ice_invoke with Callback CallbackPtr cb = new Callback(communicator, false); cl->begin_ice_invoke("opString", Ice::Normal, inParams, 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, inParams, 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, inParams, 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, inParams, 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 inParams, outParams; // begin_ice_invoke with no callback Ice::AsyncResultPtr result = cl->begin_ice_invoke("opException", Ice::Normal, inParams); if(cl->end_ice_invoke(outParams, result)) { test(false); } else { Ice::InputStreamPtr in = Ice::createInputStream(communicator, outParams); try { in->throwException(); } catch(const Test::MyException&) { } catch(...) { test(false); } } // begin_ice_invoke with Callback CallbackPtr cb = new Callback(communicator, false); cl->begin_ice_invoke("opException", Ice::Normal, inParams, 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, inParams, 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, inParams, 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, inParams, d, cookie); cb->check(); } cout << "ok" << endl; return cl; }