void oneways(const Ice::CommunicatorPtr&, const Test::MyClassPrxPtr& proxy) { Test::MyClassPrxPtr p = ICE_UNCHECKED_CAST(Test::MyClassPrx, proxy->ice_oneway()); { p->ice_ping(); } { try { p->ice_isA("dummy"); test(false); } #ifdef ICE_CPP11_MAPPING catch(const IceUtil::IllegalArgumentException&) #else catch(const Ice::TwowayOnlyException&) #endif { } } { try { p->ice_id(); test(false); } #ifdef ICE_CPP11_MAPPING catch(const IceUtil::IllegalArgumentException&) #else catch(const Ice::TwowayOnlyException&) #endif { } } { try { p->ice_ids(); test(false); } #ifdef ICE_CPP11_MAPPING catch(const IceUtil::IllegalArgumentException&) #else catch(const Ice::TwowayOnlyException&) #endif { } } { p->opVoid(); } { p->opIdempotent(); } { p->opNonmutating(); } { Ice::Byte b; try { p->opByte(Ice::Byte(0xff), Ice::Byte(0x0f), b); test(false); } #ifdef ICE_CPP11_MAPPING catch(const IceUtil::IllegalArgumentException&) #else catch(const Ice::TwowayOnlyException&) #endif { } } }
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::OutputStream out(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::InputStream in(communicator, out.getEncoding(), 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::InputStream in(communicator, out.getEncoding(), outEncaps); in.startEncapsulation(); string s; in.read(s); test(s == testString); in.read(s); test(s == testString); in.endEncapsulation(); } else { test(false); } } for(int i = 0; i < 2; ++i) { Ice::ByteSeq inEncaps, outEncaps; Ice::Context ctx; if(i == 1) { ctx["raise"] = ""; } if(cl->ice_invoke("opException", ICE_ENUM(OperationMode, Normal), inEncaps, outEncaps, ctx)) { test(false); } else { Ice::InputStream in(communicator, cl->ice_getEncodingVersion(), 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 { Ice::ByteSeq inEncaps; batchOneway->ice_invokeAsync("opOneway", ICE_ENUM(OperationMode, Normal), inEncaps, [](bool, const vector<Ice::Byte>) { test(false); }, [](exception_ptr) { test(false); }, [](bool) { test(false); }); batchOneway->ice_flushBatchRequests(); } // // repeat with the future API. // { Ice::ByteSeq inEncaps; test(batchOneway->ice_invokeAsync("opOneway", ICE_ENUM(OperationMode, Normal), inEncaps).get().returnValue); test(batchOneway->ice_invokeAsync("opOneway", ICE_ENUM(OperationMode, Normal), inEncaps).get().returnValue); test(batchOneway->ice_invokeAsync("opOneway", ICE_ENUM(OperationMode, Normal), inEncaps).get().returnValue); test(batchOneway->ice_invokeAsync("opOneway", ICE_ENUM(OperationMode, Normal), inEncaps).get().returnValue); batchOneway->ice_flushBatchRequests(); } { promise<bool> completed; Ice::ByteSeq inEncaps, outEncaps; oneway->ice_invokeAsync( "opOneway", OperationMode::Normal, inEncaps, nullptr, [&](exception_ptr ex) { completed.set_exception(ex); }, [&](bool) { completed.set_value(true); }); test(completed.get_future().get()); } // // repeat with the future API. // { Ice::ByteSeq inEncaps, outEncaps; auto completed = oneway->ice_invokeAsync("opOneway", OperationMode::Normal, inEncaps); test(completed.get().returnValue); } { promise<bool> completed; Ice::ByteSeq inEncaps, outEncaps; Ice::OutputStream out(communicator); out.startEncapsulation(); out.write(testString); out.endEncapsulation(); out.finished(inEncaps); cl->ice_invokeAsync("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::InputStream in(communicator, outEncaps); in.startEncapsulation(); string s; in.read(s); test(s == testString); in.read(s); test(s == testString); in.endEncapsulation(); } // // repeat with the future API. // { Ice::ByteSeq inEncaps, outEncaps; Ice::OutputStream out(communicator); out.startEncapsulation(); out.write(testString); out.endEncapsulation(); out.finished(inEncaps); auto result = cl->ice_invokeAsync("opString", OperationMode::Normal, inEncaps).get(); test(result.returnValue); Ice::InputStream in(communicator, result.outParams); 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::OutputStream out(communicator); out.startEncapsulation(); out.write(testString); out.endEncapsulation(); out.finished(inEncaps); auto inPair = make_pair(inEncaps.data(), inEncaps.data() + inEncaps.size()); cl->ice_invokeAsync("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::InputStream in(communicator, outEncaps); in.startEncapsulation(); string s; in.read(s); test(s == testString); in.read(s); test(s == testString); in.endEncapsulation(); } // // repeat with the future API. // { Ice::ByteSeq inEncaps, outEncaps; Ice::OutputStream out(communicator); out.startEncapsulation(); out.write(testString); out.endEncapsulation(); out.finished(inEncaps); auto inPair = make_pair(inEncaps.data(), inEncaps.data() + inEncaps.size()); auto result = cl->ice_invokeAsync("opString", OperationMode::Normal, inPair).get(); test(result.returnValue); Ice::InputStream in(communicator, result.outParams); 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_invokeAsync("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::InputStream in(communicator, outEncaps); in.startEncapsulation(); try { in.throwException(); test(false); } catch(const Test::MyException&) { } catch(...) { test(false); } } // // repeat with the future API. // { Ice::ByteSeq inEncaps; auto result = cl->ice_invokeAsync("opException", OperationMode::Normal, inEncaps).get(); test(!result.returnValue); Ice::InputStream in(communicator, result.outParams); 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; { Ice::ByteSeq inEncaps, outEncaps; test(batchOneway->end_ice_invoke(outEncaps, batchOneway->begin_ice_invoke("opOneway", ICE_ENUM(OperationMode, Normal), inEncaps))); test(batchOneway->end_ice_invoke(outEncaps, batchOneway->begin_ice_invoke("opOneway", ICE_ENUM(OperationMode, Normal), inEncaps))); test(batchOneway->end_ice_invoke(outEncaps, batchOneway->begin_ice_invoke("opOneway", ICE_ENUM(OperationMode, Normal), inEncaps))); test(batchOneway->end_ice_invoke(outEncaps, batchOneway->begin_ice_invoke("opOneway", ICE_ENUM(OperationMode, Normal), inEncaps))); batchOneway->ice_flushBatchRequests(); } { 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::OutputStream out(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::InputStream in(communicator, out.getEncoding(), 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::InputStream in(communicator, out.getEncoding(), 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::InputStream in(communicator, cl->ice_getEncodingVersion(), 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; }