int run(int, char**, const Ice::CommunicatorPtr& communicator) { Test::MyClassPrxPtr allTests(const Ice::CommunicatorPtr&); Test::MyClassPrxPtr myClass = allTests(communicator); myClass->shutdown(); return EXIT_SUCCESS; }
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 { } } }
void twoways(const Ice::CommunicatorPtr& communicator, const Test::MyClassPrxPtr& p) { { p->ice_ping(); } { #ifdef ICE_CPP11_MAPPING test(Test::MyClassPrx::ice_staticId() == Test::MyClassDisp::ice_staticId()); #else test(Test::MyClassPrx::ice_staticId() == Test::MyClass::ice_staticId()); #endif test(Ice::ObjectPrx::ice_staticId() == Ice::Object::ice_staticId()); } { test(p->ice_isA(Test::MyClass::ice_staticId())); } { test(p->ice_id() == Test::MyDerivedClass::ice_staticId()); } { Ice::StringSeq ids = p->ice_ids(); test(ids.size() == 3); test(ids[0] == "::Ice::Object"); test(ids[1] == "::Test::MyClass"); test(ids[2] == "::Test::MyDerivedClass"); } { p->opVoid(); } { Ice::Byte b; Ice::Byte r; r = p->opByte(Ice::Byte(0xff), Ice::Byte(0x0f), b); test(b == Ice::Byte(0xf0)); test(r == Ice::Byte(0xff)); } { bool b; bool r; r = p->opBool(true, false, b); test(b); test(!r); } { Ice::Short s; Ice::Int i; Ice::Long l; Ice::Long r; r = p->opShortIntLong(10, 11, 12, s, i, l); test(s == 10); test(i == 11); test(l == 12); test(r == 12); r = p->opShortIntLong(numeric_limits<Ice::Short>::min(), numeric_limits<Ice::Int>::min(), numeric_limits<Ice::Long>::min(), s, i, l); test(s == numeric_limits<Ice::Short>::min()); test(i == numeric_limits<Ice::Int>::min()); test(l == numeric_limits<Ice::Long>::min()); test(r == numeric_limits<Ice::Long>::min()); r = p->opShortIntLong(numeric_limits<Ice::Short>::max(), numeric_limits<Ice::Int>::max(), numeric_limits<Ice::Long>::max(), s, i, l); test(s == numeric_limits<Ice::Short>::max()); test(i == numeric_limits<Ice::Int>::max()); test(l == numeric_limits<Ice::Long>::max()); test(r == numeric_limits<Ice::Long>::max()); } { Ice::Float f; Ice::Double d; Ice::Double r; r = p->opFloatDouble(Ice::Float(3.14), Ice::Double(1.1E10), f, d); test(f == Ice::Float(3.14)); test(d == Ice::Double(1.1E10)); test(r == Ice::Double(1.1E10)); r = p->opFloatDouble(numeric_limits<Ice::Float>::min(), numeric_limits<Ice::Double>::min(), f, d); test(f == numeric_limits<Ice::Float>::min()); test(d == numeric_limits<Ice::Double>::min()); test(r == numeric_limits<Ice::Double>::min()); r = p->opFloatDouble(numeric_limits<Ice::Float>::max(), numeric_limits<Ice::Double>::max(), f, d); test(f == numeric_limits<Ice::Float>::max()); test(d == numeric_limits<Ice::Double>::max()); test(r == numeric_limits<Ice::Double>::max()); } { string s; string r; r = p->opString("hello", "world", s); test(s == "world hello"); test(r == "hello world"); } { Test::MyEnum e; Test::MyEnum r; r = p->opMyEnum(ICE_ENUM(MyEnum, enum2), e); test(e == ICE_ENUM(MyEnum, enum2)); test(r == ICE_ENUM(MyEnum, enum3)); } { Test::MyClassPrxPtr c1; Test::MyClassPrxPtr c2; Test::MyClassPrxPtr r; r = p->opMyClass(p, c1, c2); test(Ice::proxyIdentityAndFacetEqual(c1, p)); test(!Ice::proxyIdentityAndFacetEqual(c2, p)); test(Ice::proxyIdentityAndFacetEqual(r, p)); test(c1->ice_getIdentity() == communicator->stringToIdentity("test")); test(c2->ice_getIdentity() == communicator->stringToIdentity("noSuchIdentity")); test(r->ice_getIdentity() == communicator->stringToIdentity("test")); r->opVoid(); c1->opVoid(); try { c2->opVoid(); test(false); } catch(const Ice::ObjectNotExistException&) { } r = p->opMyClass(0, c1, c2); test(c1 == 0); test(c2 != 0); test(Ice::proxyIdentityAndFacetEqual(r, p)); r->opVoid(); } { Test::Structure si1; si1.p = p; si1.e = ICE_ENUM(MyEnum, enum3); si1.s.s = "abc"; Test::Structure si2; si2.p = 0; si2.e = ICE_ENUM(MyEnum, enum2); si2.s.s = "def"; Test::Structure so; Test::Structure rso = p->opStruct(si1, si2, so); test(rso.p == 0); test(rso.e == ICE_ENUM(MyEnum, enum2)); test(rso.s.s == "def"); #ifdef ICE_CPP11_MAPPING test(Ice::targetEquals(so.p, p)); #else test(so.p == p); #endif test(so.e == ICE_ENUM(MyEnum, enum3)); test(so.s.s == "a new string"); so.p->opVoid(); } { Test::ByteS bsi1; Test::ByteS bsi2; bsi1.push_back(Ice::Byte(0x01)); bsi1.push_back(Ice::Byte(0x11)); bsi1.push_back(Ice::Byte(0x12)); bsi1.push_back(Ice::Byte(0x22)); bsi2.push_back(Ice::Byte(0xf1)); bsi2.push_back(Ice::Byte(0xf2)); bsi2.push_back(Ice::Byte(0xf3)); bsi2.push_back(Ice::Byte(0xf4)); Test::ByteS bso; Test::ByteS rso; rso = p->opByteS(bsi1, bsi2, bso); test(bso.size() == 4); test(bso[0] == Ice::Byte(0x22)); test(bso[1] == Ice::Byte(0x12)); test(bso[2] == Ice::Byte(0x11)); test(bso[3] == Ice::Byte(0x01)); test(rso.size() == 8); test(rso[0] == Ice::Byte(0x01)); test(rso[1] == Ice::Byte(0x11)); test(rso[2] == Ice::Byte(0x12)); test(rso[3] == Ice::Byte(0x22)); test(rso[4] == Ice::Byte(0xf1)); test(rso[5] == Ice::Byte(0xf2)); test(rso[6] == Ice::Byte(0xf3)); test(rso[7] == Ice::Byte(0xf4)); } { Test::BoolS bsi1; Test::BoolS bsi2; bsi1.push_back(true); bsi1.push_back(true); bsi1.push_back(false); bsi2.push_back(false); Test::BoolS bso; Test::BoolS rso; rso = p->opBoolS(bsi1, bsi2, bso); test(bso.size() == 4); test(bso[0]); test(bso[1]); test(!bso[2]); test(!bso[3]); test(rso.size() == 3); test(!rso[0]); test(rso[1]); test(rso[2]); } { Test::ShortS ssi; Test::IntS isi; Test::LongS lsi; ssi.push_back(1); ssi.push_back(2); ssi.push_back(3); isi.push_back(5); isi.push_back(6); isi.push_back(7); isi.push_back(8); lsi.push_back(10); lsi.push_back(30); lsi.push_back(20); Test::ShortS sso; Test::IntS iso; Test::LongS lso; Test::LongS rso; rso = p->opShortIntLongS(ssi, isi, lsi, sso, iso, lso); test(sso.size() == 3); test(sso[0] == 1); test(sso[1] == 2); test(sso[2] == 3); test(iso.size() == 4); test(iso[0] == 8); test(iso[1] == 7); test(iso[2] == 6); test(iso[3] == 5); test(lso.size() == 6); test(lso[0] == 10); test(lso[1] == 30); test(lso[2] == 20); test(lso[3] == 10); test(lso[4] == 30); test(lso[5] == 20); test(rso.size() == 3); test(rso[0] == 10); test(rso[1] == 30); test(rso[2] == 20); } { Test::FloatS fsi; Test::DoubleS dsi; fsi.push_back(Ice::Float(3.14)); fsi.push_back(Ice::Float(1.11)); dsi.push_back(Ice::Double(1.1E10)); dsi.push_back(Ice::Double(1.2E10)); dsi.push_back(Ice::Double(1.3E10)); Test::FloatS fso; Test::DoubleS dso; Test::DoubleS rso; rso = p->opFloatDoubleS(fsi, dsi, fso, dso); test(fso.size() == 2); test(fso[0] == ::Ice::Float(3.14)); test(fso[1] == ::Ice::Float(1.11)); test(dso.size() == 3); test(dso[0] == ::Ice::Double(1.3E10)); test(dso[1] == ::Ice::Double(1.2E10)); test(dso[2] == ::Ice::Double(1.1E10)); test(rso.size() == 5); test(rso[0] == ::Ice::Double(1.1E10)); test(rso[1] == ::Ice::Double(1.2E10)); test(rso[2] == ::Ice::Double(1.3E10)); test(::Ice::Float(rso[3]) == ::Ice::Float(3.14)); test(::Ice::Float(rso[4]) == ::Ice::Float(1.11)); } { Test::StringS ssi1; Test::StringS ssi2; ssi1.push_back("abc"); ssi1.push_back("de"); ssi1.push_back("fghi"); ssi2.push_back("xyz"); Test::StringS sso; Test::StringS rso; rso = p->opStringS(ssi1, ssi2, sso); test(sso.size() == 4); test(sso[0] == "abc"); test(sso[1] == "de"); test(sso[2] == "fghi"); test(sso[3] == "xyz"); test(rso.size() == 3); test(rso[0] == "fghi"); test(rso[1] == "de"); test(rso[2] == "abc"); } { Test::ByteSS bsi1; bsi1.resize(2); Test::ByteSS bsi2; bsi2.resize(2); bsi1[0].push_back(Ice::Byte(0x01)); bsi1[0].push_back(Ice::Byte(0x11)); bsi1[0].push_back(Ice::Byte(0x12)); bsi1[1].push_back(Ice::Byte(0xff)); bsi2[0].push_back(Ice::Byte(0x0e)); bsi2[1].push_back(Ice::Byte(0xf2)); bsi2[1].push_back(Ice::Byte(0xf1)); Test::ByteSS bso; Test::ByteSS rso; rso = p->opByteSS(bsi1, bsi2, bso); test(bso.size() == 2); test(bso[0].size() == 1); test(bso[0][0] == Ice::Byte(0xff)); test(bso[1].size() == 3); test(bso[1][0] == Ice::Byte(0x01)); test(bso[1][1] == Ice::Byte(0x11)); test(bso[1][2] == Ice::Byte(0x12)); test(rso.size() == 4); test(rso[0].size() == 3); test(rso[0][0] == Ice::Byte(0x01)); test(rso[0][1] == Ice::Byte(0x11)); test(rso[0][2] == Ice::Byte(0x12)); test(rso[1].size() == 1); test(rso[1][0] == Ice::Byte(0xff)); test(rso[2].size() == 1); test(rso[2][0] == Ice::Byte(0x0e)); test(rso[3].size() == 2); test(rso[3][0] == Ice::Byte(0xf2)); test(rso[3][1] == Ice::Byte(0xf1)); } { Test::BoolSS bsi1; bsi1.resize(3); Test::BoolSS bsi2; bsi2.resize(1); bsi1[0].push_back(true); bsi1[1].push_back(false); bsi1[2].push_back(true); bsi1[2].push_back(true); bsi2[0].push_back(false); bsi2[0].push_back(false); bsi2[0].push_back(true); Test::BoolSS bso; Test::BoolSS rso; rso = p->opBoolSS(bsi1, bsi2, bso); test(bso.size() == 4); test(bso[0].size() == 1); test(bso[0][0]); test(bso[1].size() == 1); test(!bso[1][0]); test(bso[2].size() == 2); test(bso[2][0]); test(bso[2][1]); test(bso[3].size() == 3); test(!bso[3][0]); test(!bso[3][1]); test(bso[3][2]); test(rso.size() == 3); test(rso[0].size() == 2); test(rso[0][0]); test(rso[0][1]); test(rso[1].size() == 1); test(!rso[1][0]); test(rso[2].size() == 1); test(rso[2][0]); } { Test::ShortSS ssi; ssi.resize(3); Test::IntSS isi; isi.resize(2); Test::LongSS lsi; lsi.resize(1); ssi[0].push_back(1); ssi[0].push_back(2); ssi[0].push_back(5); ssi[1].push_back(13); isi[0].push_back(24); isi[0].push_back(98); isi[1].push_back(42); lsi[0].push_back(496); lsi[0].push_back(1729); Test::LongSS rso; Test::ShortSS sso; Test::IntSS iso; Test::LongSS lso; rso = p->opShortIntLongSS(ssi, isi, lsi, sso, iso, lso); test(rso.size() == 1); test(rso[0].size() == 2); test(rso[0][0] == 496); test(rso[0][1] == 1729); test(sso.size() == 3); test(sso[0].size() == 3); test(sso[0][0] == 1); test(sso[0][1] == 2); test(sso[0][2] == 5); test(sso[1].size() == 1); test(sso[1][0] == 13); test(sso[2].size() == 0); test(iso.size() == 2); test(iso[0].size() == 1); test(iso[0][0] == 42); test(iso[1].size() == 2); test(iso[1][0] == 24); test(iso[1][1] == 98); test(lso.size() == 2); test(lso[0].size() == 2); test(lso[0][0] == 496); test(lso[0][1] == 1729); test(lso[1].size() == 2); test(lso[1][0] == 496); test(lso[1][1] == 1729); } { Test::FloatSS fsi; fsi.resize(3); Test::DoubleSS dsi; dsi.resize(1); fsi[0].push_back(Ice::Float(3.14)); fsi[1].push_back(Ice::Float(1.11)); dsi[0].push_back(Ice::Double(1.1E10)); dsi[0].push_back(Ice::Double(1.2E10)); dsi[0].push_back(Ice::Double(1.3E10)); Test::FloatSS fso; Test::DoubleSS dso; Test::DoubleSS rso; rso = p->opFloatDoubleSS(fsi, dsi, fso, dso); test(fso.size() == 3); test(fso[0].size() == 1); test(fso[0][0] == ::Ice::Float(3.14)); test(fso[1].size() == 1); test(fso[1][0] == ::Ice::Float(1.11)); test(fso[2].size() == 0); test(dso.size() == 1); test(dso[0].size() == 3); test(dso[0][0] == ::Ice::Double(1.1E10)); test(dso[0][1] == ::Ice::Double(1.2E10)); test(dso[0][2] == ::Ice::Double(1.3E10)); test(rso.size() == 2); test(rso[0].size() == 3); test(rso[0][0] == ::Ice::Double(1.1E10)); test(rso[0][1] == ::Ice::Double(1.2E10)); test(rso[0][2] == ::Ice::Double(1.3E10)); test(rso[1].size() == 3); test(rso[1][0] == ::Ice::Double(1.1E10)); test(rso[1][1] == ::Ice::Double(1.2E10)); test(rso[1][2] == ::Ice::Double(1.3E10)); } { Test::StringSS ssi1; ssi1.resize(2); Test::StringSS ssi2; ssi2.resize(3); ssi1[0].push_back("abc"); ssi1[1].push_back("de"); ssi1[1].push_back("fghi"); ssi2[2].push_back("xyz"); Test::StringSS sso; Test::StringSS rso; rso = p->opStringSS(ssi1, ssi2, sso); test(sso.size() == 5); test(sso[0].size() == 1); test(sso[0][0] == "abc"); test(sso[1].size() == 2); test(sso[1][0] == "de"); test(sso[1][1] == "fghi"); test(sso[2].size() == 0); test(sso[3].size() == 0); test(sso[4].size() == 1); test(sso[4][0] == "xyz"); test(rso.size() == 3); test(rso[0].size() == 1); test(rso[0][0] == "xyz"); test(rso[1].size() == 0); test(rso[2].size() == 0); } { Test::StringSSS sssi1; sssi1.resize(2); sssi1[0].resize(2); sssi1[0][0].push_back("abc"); sssi1[0][0].push_back("de"); sssi1[0][1].push_back("xyz"); sssi1[1].resize(1); sssi1[1][0].push_back("hello"); Test::StringSSS sssi2; sssi2.resize(3); sssi2[0].resize(2); sssi2[0][0].push_back(""); sssi2[0][0].push_back(""); sssi2[0][1].push_back("abcd"); sssi2[1].resize(1); sssi2[1][0].push_back(""); Test::StringSSS ssso; Test::StringSSS rsso; rsso = p->opStringSSS(sssi1, sssi2, ssso); test(ssso.size() == 5); test(ssso[0].size() == 2); test(ssso[0][0].size() == 2); test(ssso[0][1].size() == 1); test(ssso[1].size() == 1); test(ssso[1][0].size() == 1); test(ssso[2].size() == 2); test(ssso[2][0].size() == 2); test(ssso[2][1].size() == 1); test(ssso[3].size() == 1); test(ssso[3][0].size() == 1); test(ssso[4].size() == 0); test(ssso[0][0][0] == "abc"); test(ssso[0][0][1] == "de"); test(ssso[0][1][0] == "xyz"); test(ssso[1][0][0] == "hello"); test(ssso[2][0][0] == ""); test(ssso[2][0][1] == ""); test(ssso[2][1][0] == "abcd"); test(ssso[3][0][0] == ""); test(rsso.size() == 3); test(rsso[0].size() == 0); test(rsso[1].size() == 1); test(rsso[1][0].size() == 1); test(rsso[2].size() == 2); test(rsso[2][0].size() == 2); test(rsso[2][1].size() == 1); test(rsso[1][0][0] == ""); test(rsso[2][0][0] == ""); test(rsso[2][0][1] == ""); test(rsso[2][1][0] == "abcd"); } { Test::ByteBoolD di1; di1[10] = true; di1[100] = false; Test::ByteBoolD di2; di2[10] = true; di2[11] = false; di2[101] = true; Test::ByteBoolD _do; Test::ByteBoolD ro = p->opByteBoolD(di1, di2, _do); test(_do == di1); test(ro.size() == 4); test(ro[10] == true); test(ro[11] == false); test(ro[100] == false); test(ro[101] == true); } { Test::ShortIntD di1; di1[110] = -1; di1[1100] = 123123; Test::ShortIntD di2; di2[110] = -1; di2[111] = -100; di2[1101] = 0; Test::ShortIntD _do; Test::ShortIntD ro = p->opShortIntD(di1, di2, _do); test(_do == di1); test(ro.size() == 4); test(ro[110] == -1); test(ro[111] == -100); test(ro[1100] == 123123); test(ro[1101] == 0); } { Test::LongFloatD di1; di1[999999110] = Ice::Float(-1.1); di1[999999111] = Ice::Float(123123.2); Test::LongFloatD di2; di2[999999110] = Ice::Float(-1.1); di2[999999120] = Ice::Float(-100.4); di2[999999130] = Ice::Float(0.5); Test::LongFloatD _do; Test::LongFloatD ro = p->opLongFloatD(di1, di2, _do); test(_do == di1); test(ro.size() == 4); test(ro[999999110] == Ice::Float(-1.1)); test(ro[999999120] == Ice::Float(-100.4)); test(ro[999999111] == Ice::Float(123123.2)); test(ro[999999130] == Ice::Float(0.5)); } { Test::StringStringD di1; di1["foo"] = "abc -1.1"; di1["bar"] = "abc 123123.2"; Test::StringStringD di2; di2["foo"] = "abc -1.1"; di2["FOO"] = "abc -100.4"; di2["BAR"] = "abc 0.5"; Test::StringStringD _do; Test::StringStringD ro = p->opStringStringD(di1, di2, _do); test(_do == di1); test(ro.size() == 4); test(ro["foo"] == "abc -1.1"); test(ro["FOO"] == "abc -100.4"); test(ro["bar"] == "abc 123123.2"); test(ro["BAR"] == "abc 0.5"); } { Test::StringMyEnumD di1; di1["abc"] = ICE_ENUM(MyEnum, enum1); di1[""] = ICE_ENUM(MyEnum, enum2); Test::StringMyEnumD di2; di2["abc"] = ICE_ENUM(MyEnum, enum1); di2["qwerty"] = ICE_ENUM(MyEnum, enum3); di2["Hello!!"] = ICE_ENUM(MyEnum, enum2); Test::StringMyEnumD _do; Test::StringMyEnumD ro = p->opStringMyEnumD(di1, di2, _do); test(_do == di1); test(ro.size() == 4); test(ro["abc"] == ICE_ENUM(MyEnum, enum1)); test(ro["qwerty"] == ICE_ENUM(MyEnum, enum3)); test(ro[""] == ICE_ENUM(MyEnum, enum2)); test(ro["Hello!!"] == ICE_ENUM(MyEnum, enum2)); } { Test::MyEnumStringD di1; di1[ICE_ENUM(MyEnum, enum1)] = "abc"; Test::MyEnumStringD di2; di2[ICE_ENUM(MyEnum, enum2)] = "Hello!!"; di2[ICE_ENUM(MyEnum, enum3)] = "qwerty"; Test::MyEnumStringD _do; Test::MyEnumStringD ro = p->opMyEnumStringD(di1, di2, _do); test(_do == di1); test(ro.size() == 3); test(ro[ICE_ENUM(MyEnum, enum1)] == "abc"); test(ro[ICE_ENUM(MyEnum, enum2)] == "Hello!!"); test(ro[ICE_ENUM(MyEnum, enum3)] == "qwerty"); } { Test::MyStruct s11 = { 1, 1 }; Test::MyStruct s12 = { 1, 2 }; Test::MyStructMyEnumD di1; di1[s11] = ICE_ENUM(MyEnum, enum1); di1[s12] = ICE_ENUM(MyEnum, enum2); Test::MyStruct s22 = { 2, 2 }; Test::MyStruct s23 = { 2, 3 }; Test::MyStructMyEnumD di2; di2[s11] = ICE_ENUM(MyEnum, enum1); di2[s22] = ICE_ENUM(MyEnum, enum3); di2[s23] = ICE_ENUM(MyEnum, enum2); Test::MyStructMyEnumD _do; Test::MyStructMyEnumD ro = p->opMyStructMyEnumD(di1, di2, _do); test(_do == di1); test(ro.size() == 4); test(ro[s11] == ICE_ENUM(MyEnum, enum1)); test(ro[s12] == ICE_ENUM(MyEnum, enum2)); test(ro[s22] == ICE_ENUM(MyEnum, enum3)); test(ro[s23] == ICE_ENUM(MyEnum, enum2)); } { Test::ByteBoolDS dsi1; dsi1.resize(2); Test::ByteBoolDS dsi2; dsi2.resize(1); Test::ByteBoolD di1; di1[10] = true; di1[100] = false; Test::ByteBoolD di2; di2[10] = true; di2[11] = false; di2[101] = true; Test::ByteBoolD di3; di3[100] = false; di3[101] = false; dsi1[0] = di1; dsi1[1] = di2; dsi2[0] = di3; try { Test::ByteBoolDS _do; Test::ByteBoolDS ro = p->opByteBoolDS(dsi1, dsi2, _do); test(ro.size() == 2); test(ro[0].size() == 3); test(ro[0][10] == true); test(ro[0][11] == false); test(ro[0][101] == true); test(ro[1].size() == 2); test(ro[1][10] == true); test(ro[1][100] == false); test(_do.size() == 3); test(_do[0].size() == 2); test(_do[0][100] == false); test(_do[0][101] == false); test(_do[1].size() == 2); test(_do[1][10] == true); test(_do[1][100] == false); test(_do[2].size() == 3); test(_do[2][10] == true); test(_do[2][11] == false); test(_do[2][101] == true); } catch(const Ice::OperationNotExistException&) { } } { Test::ShortIntDS dsi1; dsi1.resize(2); Test::ShortIntDS dsi2; dsi2.resize(1); Test::ShortIntD di1; di1[110] = -1; di1[1100] = 123123; Test::ShortIntD di2; di2[110] = -1; di2[111] = -100; di2[1101] = 0; Test::ShortIntD di3; di3[100] = -1001; dsi1[0] = di1; dsi1[1] = di2; dsi2[0] = di3; try { Test::ShortIntDS _do; Test::ShortIntDS ro = p->opShortIntDS(dsi1, dsi2, _do); test(ro.size() == 2); test(ro[0].size() == 3); test(ro[0][110] == -1); test(ro[0][111] == -100); test(ro[0][1101] == 0); test(ro[1].size() == 2); test(ro[1][110] == -1); test(ro[1][1100] == 123123); test(_do.size() == 3); test(_do[0].size() == 1); test(_do[0][100] == -1001); test(_do[1].size() == 2); test(_do[1][110] == -1); test(_do[1][1100] == 123123); test(_do[2].size() == 3); test(_do[2][110] == -1); test(_do[2][111] == -100); test(_do[2][1101] == 0); } catch(const Ice::OperationNotExistException&) { } } { Test::LongFloatDS dsi1; dsi1.resize(2); Test::LongFloatDS dsi2; dsi2.resize(1); Test::LongFloatD di1; di1[999999110] = Ice::Float(-1.1); di1[999999111] = Ice::Float(123123.2); Test::LongFloatD di2; di2[999999110] = Ice::Float(-1.1); di2[999999120] = Ice::Float(-100.4); di2[999999130] = Ice::Float(0.5); Test::LongFloatD di3; di3[999999140] = Ice::Float(3.14); dsi1[0] = di1; dsi1[1] = di2; dsi2[0] = di3; try { Test::LongFloatDS _do; Test::LongFloatDS ro = p->opLongFloatDS(dsi1, dsi2, _do); test(ro.size() == 2); test(ro[0].size() == 3); test(ro[0][999999110] == Ice::Float(-1.1)); test(ro[0][999999120] == Ice::Float(-100.4)); test(ro[0][999999130] == Ice::Float(0.5)); test(ro[1].size() == 2); test(ro[1][999999110] == Ice::Float(-1.1)); test(ro[1][999999111] == Ice::Float(123123.2)); test(_do.size() == 3); test(_do[0].size() == 1); test(_do[0][999999140] == Ice::Float(3.14)); test(_do[1].size() == 2); test(_do[1][999999110] == Ice::Float(-1.1)); test(_do[1][999999111] == Ice::Float(123123.2)); test(_do[2].size() == 3); test(_do[2][999999110] == Ice::Float(-1.1)); test(_do[2][999999120] == Ice::Float(-100.4)); test(_do[2][999999130] == Ice::Float(0.5)); } catch(const Ice::OperationNotExistException&) { } } { Test::StringStringDS dsi1; dsi1.resize(2); Test::StringStringDS dsi2; dsi2.resize(1); Test::StringStringD di1; di1["foo"] = "abc -1.1"; di1["bar"] = "abc 123123.2"; Test::StringStringD di2; di2["foo"] = "abc -1.1"; di2["FOO"] = "abc -100.4"; di2["BAR"] = "abc 0.5"; Test::StringStringD di3; di3["f00"] = "ABC -3.14"; dsi1[0] = di1; dsi1[1] = di2; dsi2[0] = di3; try { Test::StringStringDS _do; Test::StringStringDS ro = p->opStringStringDS(dsi1, dsi2, _do); test(ro.size() == 2); test(ro[0].size() == 3); test(ro[0]["foo"] == "abc -1.1"); test(ro[0]["FOO"] == "abc -100.4"); test(ro[0]["BAR"] == "abc 0.5"); test(ro[1].size() == 2); test(ro[1]["foo"] == "abc -1.1"); test(ro[1]["bar"] == "abc 123123.2"); test(_do.size() == 3); test(_do[0].size() == 1); test(_do[0]["f00"] == "ABC -3.14"); test(_do[1].size() == 2); test(_do[1]["foo"] == "abc -1.1"); test(_do[1]["bar"] == "abc 123123.2"); test(_do[2].size() == 3); test(_do[2]["foo"] == "abc -1.1"); test(_do[2]["FOO"] == "abc -100.4"); test(_do[2]["BAR"] == "abc 0.5"); } catch(const Ice::OperationNotExistException&) { } } { Test::StringMyEnumDS dsi1; dsi1.resize(2); Test::StringMyEnumDS dsi2; dsi2.resize(1); Test::StringMyEnumD di1; di1["abc"] = ICE_ENUM(MyEnum, enum1); di1[""] = ICE_ENUM(MyEnum, enum2); Test::StringMyEnumD di2; di2["abc"] = ICE_ENUM(MyEnum, enum1); di2["qwerty"] = ICE_ENUM(MyEnum, enum3); di2["Hello!!"] = ICE_ENUM(MyEnum, enum2); Test::StringMyEnumD di3; di3["Goodbye"] = ICE_ENUM(MyEnum, enum1); dsi1[0] = di1; dsi1[1] = di2; dsi2[0] = di3; try { Test::StringMyEnumDS _do; Test::StringMyEnumDS ro = p->opStringMyEnumDS(dsi1, dsi2, _do); test(ro.size() == 2); test(ro[0].size() == 3); test(ro[0]["abc"] == ICE_ENUM(MyEnum, enum1)); test(ro[0]["qwerty"] == ICE_ENUM(MyEnum, enum3)); test(ro[0]["Hello!!"] == ICE_ENUM(MyEnum, enum2)); test(ro[1].size() == 2); test(ro[1]["abc"] == ICE_ENUM(MyEnum, enum1)); test(ro[1][""] == ICE_ENUM(MyEnum, enum2)); test(_do.size() == 3); test(_do[0].size() == 1); test(_do[0]["Goodbye"] == ICE_ENUM(MyEnum, enum1)); test(_do[1].size() == 2); test(_do[1]["abc"] == ICE_ENUM(MyEnum, enum1)); test(_do[1][""] == ICE_ENUM(MyEnum, enum2)); test(_do[2].size() == 3); test(_do[2]["abc"] == ICE_ENUM(MyEnum, enum1)); test(_do[2]["qwerty"] == ICE_ENUM(MyEnum, enum3)); test(_do[2]["Hello!!"] == ICE_ENUM(MyEnum, enum2)); } catch(const Ice::OperationNotExistException&) { } } { Test::MyEnumStringDS dsi1; dsi1.resize(2); Test::MyEnumStringDS dsi2; dsi2.resize(1); Test::MyEnumStringD di1; di1[ICE_ENUM(MyEnum, enum1)] = "abc"; Test::MyEnumStringD di2; di2[ICE_ENUM(MyEnum, enum2)] = "Hello!!"; di2[ICE_ENUM(MyEnum, enum3)] = "qwerty"; Test::MyEnumStringD di3; di3[ICE_ENUM(MyEnum, enum1)] = "Goodbye"; dsi1[0] = di1; dsi1[1] = di2; dsi2[0] = di3; try { Test::MyEnumStringDS _do; Test::MyEnumStringDS ro = p->opMyEnumStringDS(dsi1, dsi2, _do); test(ro.size() == 2); test(ro[0].size() == 2); test(ro[0][ICE_ENUM(MyEnum, enum2)] == "Hello!!"); test(ro[0][ICE_ENUM(MyEnum, enum3)] == "qwerty"); test(ro[1].size() == 1); test(ro[1][ICE_ENUM(MyEnum, enum1)] == "abc"); test(_do.size() == 3); test(_do[0].size() == 1); test(_do[0][ICE_ENUM(MyEnum, enum1)] == "Goodbye"); test(_do[1].size() == 1); test(_do[1][ICE_ENUM(MyEnum, enum1)] == "abc"); test(_do[2].size() == 2); test(_do[2][ICE_ENUM(MyEnum, enum2)] == "Hello!!"); test(_do[2][ICE_ENUM(MyEnum, enum3)] == "qwerty"); } catch(const Ice::OperationNotExistException&) { } } { Test::MyStructMyEnumDS dsi1; dsi1.resize(2); Test::MyStructMyEnumDS dsi2; dsi2.resize(1); Test::MyStruct s11 = { 1, 1 }; Test::MyStruct s12 = { 1, 2 }; Test::MyStructMyEnumD di1; di1[s11] = ICE_ENUM(MyEnum, enum1); di1[s12] = ICE_ENUM(MyEnum, enum2); Test::MyStruct s22 = { 2, 2 }; Test::MyStruct s23 = { 2, 3 }; Test::MyStructMyEnumD di2; di2[s11] = ICE_ENUM(MyEnum, enum1); di2[s22] = ICE_ENUM(MyEnum, enum3); di2[s23] = ICE_ENUM(MyEnum, enum2); Test::MyStructMyEnumD di3; di3[s23] = ICE_ENUM(MyEnum, enum3); dsi1[0] = di1; dsi1[1] = di2; dsi2[0] = di3; try { Test::MyStructMyEnumDS _do; Test::MyStructMyEnumDS ro = p->opMyStructMyEnumDS(dsi1, dsi2, _do); test(ro.size() == 2); test(ro[0].size() == 3); test(ro[0][s11] == ICE_ENUM(MyEnum, enum1)); test(ro[0][s22] == ICE_ENUM(MyEnum, enum3)); test(ro[0][s23] == ICE_ENUM(MyEnum, enum2)); test(ro[1].size() == 2); test(ro[1][s11] == ICE_ENUM(MyEnum, enum1)); test(ro[1][s12] == ICE_ENUM(MyEnum, enum2)); test(_do.size() == 3); test(_do[0].size() == 1); test(_do[0][s23] == ICE_ENUM(MyEnum, enum3)); test(_do[1].size() == 2); test(_do[1][s11] == ICE_ENUM(MyEnum, enum1)); test(_do[1][s12] == ICE_ENUM(MyEnum, enum2)); test(_do[2].size() == 3); test(_do[2][s11] == ICE_ENUM(MyEnum, enum1)); test(_do[2][s22] == ICE_ENUM(MyEnum, enum3)); test(_do[2][s23] == ICE_ENUM(MyEnum, enum2)); } catch(const Ice::OperationNotExistException&) { } } { Test::ByteByteSD sdi1; Test::ByteByteSD sdi2; Test::ByteS si1; Test::ByteS si2; Test::ByteS si3; si1.push_back(Ice::Byte(0x01)); si1.push_back(Ice::Byte(0x11)); si2.push_back(Ice::Byte(0x12)); si3.push_back(Ice::Byte(0xf2)); si3.push_back(Ice::Byte(0xf3)); sdi1[Ice::Byte(0x01)] = si1; sdi1[Ice::Byte(0x22)] = si2; sdi2[Ice::Byte(0xf1)] = si3; try { Test::ByteByteSD _do; Test::ByteByteSD ro = p->opByteByteSD(sdi1, sdi2, _do); test(_do == sdi2); test(ro.size() == 3); test(ro[Ice::Byte(0x01)].size() == 2); test(ro[Ice::Byte(0x01)][0] == Ice::Byte(0x01)); test(ro[Ice::Byte(0x01)][1] == Ice::Byte(0x11)); test(ro[Ice::Byte(0x22)].size() == 1); test(ro[Ice::Byte(0x22)][0] == Ice::Byte(0x12)); test(ro[Ice::Byte(0xf1)].size() == 2); test(ro[Ice::Byte(0xf1)][0] == Ice::Byte(0xf2)); test(ro[Ice::Byte(0xf1)][1] == Ice::Byte(0xf3)); } catch(const Ice::OperationNotExistException&) { } } { Test::BoolBoolSD sdi1; Test::BoolBoolSD sdi2; Test::BoolS si1; Test::BoolS si2; si1.push_back(true); si1.push_back(false); si2.push_back(false); si2.push_back(true); si2.push_back(true); sdi1[false] = si1; sdi1[true] = si2; sdi2[false] = si1; try { Test::BoolBoolSD _do; Test::BoolBoolSD ro = p->opBoolBoolSD(sdi1, sdi2, _do); test(_do == sdi2); test(ro.size() == 2); test(ro[false].size() == 2); test(ro[false][0] == true); test(ro[false][1] == false); test(ro[true].size() == 3); test(ro[true][0] == false); test(ro[true][1] == true); test(ro[true][2] == true); } catch(const Ice::OperationNotExistException&) { } } { Test::ShortShortSD sdi1; Test::ShortShortSD sdi2; Test::ShortS si1; Test::ShortS si2; Test::ShortS si3; si1.push_back(1); si1.push_back(2); si1.push_back(3); si2.push_back(4); si2.push_back(5); si3.push_back(6); si3.push_back(7); sdi1[1] = si1; sdi1[2] = si2; sdi2[4] = si3; try { Test::ShortShortSD _do; Test::ShortShortSD ro = p->opShortShortSD(sdi1, sdi2, _do); test(_do == sdi2); test(ro.size() == 3); test(ro[1].size() == 3); test(ro[1][0] == 1); test(ro[1][1] == 2); test(ro[1][2] == 3); test(ro[2].size() == 2); test(ro[2][0] == 4); test(ro[2][1] == 5); test(ro[4].size() == 2); test(ro[4][0] == 6); test(ro[4][1] == 7); } catch(const Ice::OperationNotExistException&) { } } { Test::IntIntSD sdi1; Test::IntIntSD sdi2; Test::IntS si1; Test::IntS si2; Test::IntS si3; si1.push_back(100); si1.push_back(200); si1.push_back(300); si2.push_back(400); si2.push_back(500); si3.push_back(600); si3.push_back(700); sdi1[100] = si1; sdi1[200] = si2; sdi2[400] = si3; try { Test::IntIntSD _do; Test::IntIntSD ro = p->opIntIntSD(sdi1, sdi2, _do); test(_do == sdi2); test(ro.size() == 3); test(ro[100].size() == 3); test(ro[100][0] == 100); test(ro[100][1] == 200); test(ro[100][2] == 300); test(ro[200].size() == 2); test(ro[200][0] == 400); test(ro[200][1] == 500); test(ro[400].size() == 2); test(ro[400][0] == 600); test(ro[400][1] == 700); } catch(const Ice::OperationNotExistException&) { } } { Test::LongLongSD sdi1; Test::LongLongSD sdi2; Test::LongS si1; Test::LongS si2; Test::LongS si3; si1.push_back(999999110); si1.push_back(999999111); si1.push_back(999999110); si2.push_back(999999120); si2.push_back(999999130); si3.push_back(999999110); si3.push_back(999999120); sdi1[999999990] = si1; sdi1[999999991] = si2; sdi2[999999992] = si3; try { Test::LongLongSD _do; Test::LongLongSD ro = p->opLongLongSD(sdi1, sdi2, _do); test(_do == sdi2); test(ro.size() == 3); test(ro[999999990].size() == 3); test(ro[999999990][0] == 999999110); test(ro[999999990][1] == 999999111); test(ro[999999990][2] == 999999110); test(ro[999999991].size() == 2); test(ro[999999991][0] == 999999120); test(ro[999999991][1] == 999999130); test(ro[999999992].size() == 2); test(ro[999999992][0] == 999999110); test(ro[999999992][1] == 999999120); } catch(const Ice::OperationNotExistException&) { } } { Test::StringFloatSD sdi1; Test::StringFloatSD sdi2; Test::FloatS si1; Test::FloatS si2; Test::FloatS si3; si1.push_back(Ice::Float(-1.1)); si1.push_back(Ice::Float(123123.2)); si1.push_back(Ice::Float(100.0)); si2.push_back(Ice::Float(42.24)); si2.push_back(Ice::Float(-1.61)); si3.push_back(Ice::Float(-3.14)); si3.push_back(Ice::Float(3.14)); sdi1["abc"] = si1; sdi1["ABC"] = si2; sdi2["aBc"] = si3; try { Test::StringFloatSD _do; Test::StringFloatSD ro = p->opStringFloatSD(sdi1, sdi2, _do); test(_do == sdi2); test(ro.size() == 3); test(ro["abc"].size() == 3); test(ro["abc"][0] == Ice::Float(-1.1)); test(ro["abc"][1] == Ice::Float(123123.2)); test(ro["abc"][2] == Ice::Float(100.0)); test(ro["ABC"].size() == 2); test(ro["ABC"][0] == Ice::Float(42.24)); test(ro["ABC"][1] == Ice::Float(-1.61)); test(ro["aBc"].size() == 2); test(ro["aBc"][0] == Ice::Float(-3.14)); test(ro["aBc"][1] == Ice::Float(3.14)); } catch(const Ice::OperationNotExistException&) { } } { Test::StringDoubleSD sdi1; Test::StringDoubleSD sdi2; Test::DoubleS si1; Test::DoubleS si2; Test::DoubleS si3; si1.push_back(Ice::Double(1.1E10)); si1.push_back(Ice::Double(1.2E10)); si1.push_back(Ice::Double(1.3E10)); si2.push_back(Ice::Double(1.4E10)); si2.push_back(Ice::Double(1.5E10)); si3.push_back(Ice::Double(1.6E10)); si3.push_back(Ice::Double(1.7E10)); sdi1["Hello!!"] = si1; sdi1["Goodbye"] = si2; sdi2[""] = si3; try { Test::StringDoubleSD _do; Test::StringDoubleSD ro = p->opStringDoubleSD(sdi1, sdi2, _do); test(_do == sdi2); test(ro.size() == 3); test(ro["Hello!!"].size() == 3); test(ro["Hello!!"][0] == Ice::Double(1.1E10)); test(ro["Hello!!"][1] == Ice::Double(1.2E10)); test(ro["Hello!!"][2] == Ice::Double(1.3E10)); test(ro["Goodbye"].size() == 2); test(ro["Goodbye"][0] == Ice::Double(1.4E10)); test(ro["Goodbye"][1] == Ice::Double(1.5E10)); test(ro[""].size() == 2); test(ro[""][0] == Ice::Double(1.6E10)); test(ro[""][1] == Ice::Double(1.7E10)); } catch(const Ice::OperationNotExistException&) { } } { Test::StringStringSD sdi1; Test::StringStringSD sdi2; Test::StringS si1; Test::StringS si2; Test::StringS si3; si1.push_back("abc"); si1.push_back("de"); si1.push_back("fghi"); si2.push_back("xyz"); si2.push_back("or"); si3.push_back("and"); si3.push_back("xor"); sdi1["abc"] = si1; sdi1["def"] = si2; sdi2["ghi"] = si3; try { Test::StringStringSD _do; Test::StringStringSD ro = p->opStringStringSD(sdi1, sdi2, _do); test(_do == sdi2); test(ro.size() == 3); test(ro["abc"].size() == 3); test(ro["abc"][0] == "abc"); test(ro["abc"][1] == "de"); test(ro["abc"][2] == "fghi"); test(ro["def"].size() == 2); test(ro["def"][0] == "xyz"); test(ro["def"][1] == "or"); test(ro["ghi"].size() == 2); test(ro["ghi"][0] == "and"); test(ro["ghi"][1] == "xor"); } catch(const Ice::OperationNotExistException&) { } } { Test::MyEnumMyEnumSD sdi1; Test::MyEnumMyEnumSD sdi2; Test::MyEnumS si1; Test::MyEnumS si2; Test::MyEnumS si3; si1.push_back(ICE_ENUM(MyEnum, enum1)); si1.push_back(ICE_ENUM(MyEnum, enum1)); si1.push_back(ICE_ENUM(MyEnum, enum2)); si2.push_back(ICE_ENUM(MyEnum, enum1)); si2.push_back(ICE_ENUM(MyEnum, enum2)); si3.push_back(ICE_ENUM(MyEnum, enum3)); si3.push_back(ICE_ENUM(MyEnum, enum3)); sdi1[ICE_ENUM(MyEnum, enum3)] = si1; sdi1[ICE_ENUM(MyEnum, enum2)] = si2; sdi2[ICE_ENUM(MyEnum, enum1)] = si3; try { Test::MyEnumMyEnumSD _do; Test::MyEnumMyEnumSD ro = p->opMyEnumMyEnumSD(sdi1, sdi2, _do); test(_do == sdi2); test(ro.size() == 3); test(ro[ICE_ENUM(MyEnum, enum3)].size() == 3); test(ro[ICE_ENUM(MyEnum, enum3)][0] == ICE_ENUM(MyEnum, enum1)); test(ro[ICE_ENUM(MyEnum, enum3)][1] == ICE_ENUM(MyEnum, enum1)); test(ro[ICE_ENUM(MyEnum, enum3)][2] == ICE_ENUM(MyEnum, enum2)); test(ro[ICE_ENUM(MyEnum, enum2)].size() == 2); test(ro[ICE_ENUM(MyEnum, enum2)][0] == ICE_ENUM(MyEnum, enum1)); test(ro[ICE_ENUM(MyEnum, enum2)][1] == ICE_ENUM(MyEnum, enum2)); test(ro[ICE_ENUM(MyEnum, enum1)].size() == 2); test(ro[ICE_ENUM(MyEnum, enum1)][0] == ICE_ENUM(MyEnum, enum3)); test(ro[ICE_ENUM(MyEnum, enum1)][1] == ICE_ENUM(MyEnum, enum3)); } catch(const Ice::OperationNotExistException&) { } } { const int lengths[] = { 0, 1, 2, 126, 127, 128, 129, 253, 254, 255, 256, 257, 1000 }; for(unsigned int l = 0; l != sizeof(lengths) / sizeof(*lengths); ++l) { Test::IntS s; for(int i = 0; i < lengths[l]; ++i) { s.push_back(i); } Test::IntS r = p->opIntS(s); test(r.size() == static_cast<size_t>(lengths[l])); for(int j = 0; j < static_cast<int>(r.size()); ++j) { test(r[j] == -j); } } } { Ice::Context ctx; ctx["one"] = "ONE"; ctx["two"] = "TWO"; ctx["three"] = "THREE"; { Test::StringStringD r = p->opContext(); test(p->ice_getContext().empty()); test(r != ctx); } { Test::StringStringD r = p->opContext(ctx); test(p->ice_getContext().empty()); test(r == ctx); } { Test::MyClassPrxPtr p2 = ICE_CHECKED_CAST(Test::MyClassPrx, p->ice_context(ctx)); test(p2->ice_getContext() == ctx); Test::StringStringD r = p2->opContext(); test(r == ctx); r = p2->opContext(ctx); test(r == ctx); } #ifndef ICE_OS_WINRT if(p->ice_getConnection() && communicator->getProperties()->getProperty("Ice.Default.Protocol") != "bt") { // // Test implicit context propagation // string impls[] = {"Shared", "PerThread"}; for(int i = 0; i < 2; i++) { Ice::InitializationData initData; initData.properties = communicator->getProperties()->clone(); initData.properties->setProperty("Ice.ImplicitContext", impls[i]); Ice::CommunicatorPtr ic = Ice::initialize(initData); Ice::Context ctx; ctx["one"] = "ONE"; ctx["two"] = "TWO"; ctx["three"] = "THREE"; Test::MyClassPrxPtr p = ICE_UNCHECKED_CAST(Test::MyClassPrx, ic->stringToProxy("test:" + getTestEndpoint(ic, 0))); ic->getImplicitContext()->setContext(ctx); test(ic->getImplicitContext()->getContext() == ctx); test(p->opContext() == ctx); test(ic->getImplicitContext()->containsKey("zero") == false); string r = ic->getImplicitContext()->put("zero", "ZERO"); test(r == ""); test(ic->getImplicitContext()->containsKey("zero") == true); test(ic->getImplicitContext()->get("zero") == "ZERO"); ctx = ic->getImplicitContext()->getContext(); test(p->opContext() == ctx); Ice::Context prxContext; prxContext["one"] = "UN"; prxContext["four"] = "QUATRE"; Ice::Context combined = prxContext; combined.insert(ctx.begin(), ctx.end()); test(combined["one"] == "UN"); p = ICE_UNCHECKED_CAST(Test::MyClassPrx, p->ice_context(prxContext)); ic->getImplicitContext()->setContext(Ice::Context()); test(p->opContext() == prxContext); ic->getImplicitContext()->setContext(ctx); test(p->opContext() == combined); test(ic->getImplicitContext()->remove("one") == "ONE"); if(impls[i] == "PerThread") { IceUtil::ThreadPtr thread = new PerThreadContextInvokeThread(p->ice_context(Ice::Context())); thread->start(); thread->getThreadControl().join(); } ic->getImplicitContext()->setContext(Ice::Context()); // Clear the context to avoid leak report. ic->destroy(); } } #endif } { Ice::Double d = 1278312346.0 / 13.0; Test::DoubleS ds(5, d); p->opDoubleMarshaling(d, ds); } p->opIdempotent(); p->opNonmutating(); test(p->opByte1(0xFF) == 0xFF); test(p->opShort1(0x7FFF) == 0x7FFF); test(p->opInt1(0x7FFFFFFF) == 0x7FFFFFFF); test(p->opLong1(0x7FFFFFFFFFFFFFFFLL) == 0x7FFFFFFFFFFFFFFFLL); test(p->opFloat1(1.0) == 1.0); test(p->opDouble1(1.0) == 1.0); test(p->opString1("opString1") == "opString1"); Test::MyDerivedClassPrxPtr d = ICE_UNCHECKED_CAST(Test::MyDerivedClassPrx, p); Test::MyStruct1 s; s.tesT = "Test::MyStruct1::s"; s.myClass = 0; s.myStruct1 = "Test::MyStruct1::myStruct1"; s = d->opMyStruct1(s); test(s.tesT == "Test::MyStruct1::s"); test(s.myClass == 0); test(s.myStruct1 == "Test::MyStruct1::myStruct1"); Test::MyClass1Ptr c = ICE_MAKE_SHARED(Test::MyClass1); c->tesT = "Test::MyClass1::testT"; c->myClass = 0; c->myClass1 = "Test::MyClass1::myClass1"; c = d->opMyClass1(c); test(c->tesT == "Test::MyClass1::testT"); test(c->myClass == 0); test(c->myClass1 == "Test::MyClass1::myClass1"); Test::StringS seq; p->opStringS1(seq); Test::ByteBoolD dict; p->opByteBoolD1(dict); }
void batchOneways(const Test::MyClassPrxPtr& p) { const Test::ByteS bs1(10 * 1024); Test::MyClassPrxPtr batch = ICE_UNCHECKED_CAST(Test::MyClassPrx, p->ice_batchOneway()); batch->ice_flushBatchRequests(); // Empty flush if(batch->ice_getConnection()) { batch->ice_getConnection()->flushBatchRequests(Ice::ICE_SCOPED_ENUM(CompressBatch, BasedOnProxy)); } batch->ice_getCommunicator()->flushBatchRequests(Ice::ICE_SCOPED_ENUM(CompressBatch, BasedOnProxy)); int i; p->opByteSOnewayCallCount(); // Reset the call count for(i = 0 ; i < 30 ; ++i) { try { batch->opByteSOneway(bs1); } catch(const Ice::LocalException& ex) { cerr << ex << endl; test(false); } } int count = 0; while(count < 27) // 3 * 9 requests auto-flushed. { count += p->opByteSOnewayCallCount(); IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(10)); } if(batch->ice_getConnection() && p->ice_getCommunicator()->getProperties()->getProperty("Ice.Default.Protocol") != "bt") { Test::MyClassPrxPtr batch1 = ICE_UNCHECKED_CAST(Test::MyClassPrx, p->ice_batchOneway()); Test::MyClassPrxPtr batch2 = ICE_UNCHECKED_CAST(Test::MyClassPrx, p->ice_batchOneway()); batch1->ice_ping(); batch2->ice_ping(); batch1->ice_flushBatchRequests(); batch1->ice_getConnection()->close(Ice::ICE_SCOPED_ENUM(ConnectionClose, GracefullyWithWait)); batch1->ice_ping(); batch2->ice_ping(); batch1->ice_getConnection(); batch2->ice_getConnection(); batch1->ice_ping(); batch1->ice_getConnection()->close(Ice::ICE_SCOPED_ENUM(ConnectionClose, GracefullyWithWait)); batch1->ice_ping(); batch2->ice_ping(); } Ice::Identity identity; identity.name = "invalid"; Ice::ObjectPrxPtr 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() && p->ice_getCommunicator()->getProperties()->getProperty("Ice.Default.Protocol") != "bt") { Ice::InitializationData initData; initData.properties = p->ice_getCommunicator()->getProperties()->clone(); BatchRequestInterceptorIPtr interceptor = ICE_MAKE_SHARED(BatchRequestInterceptorI); #if defined(ICE_CPP11_MAPPING) initData.batchRequestInterceptor = [=](const Ice::BatchRequest& request, int count, int size) { interceptor->enqueue(request, count, size); }; #else initData.batchRequestInterceptor = interceptor; #endif Ice::CommunicatorPtr ic = Ice::initialize(initData); Test::MyClassPrxPtr batch = ICE_UNCHECKED_CAST(Test::MyClassPrx, ic->stringToProxy(p->ice_toString()))->ice_batchOneway(); test(interceptor->count() == 0); batch->ice_ping(); batch->ice_ping(); batch->ice_ping(); test(interceptor->count() == 0); interceptor->enqueue(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(); } bool supportsCompress = true; try { supportsCompress = p->supportsCompress(); } catch(const Ice::OperationNotExistException&) { } if(supportsCompress && batch->ice_getConnection() && p->ice_getCommunicator()->getProperties()->getProperty("Ice.Override.Compress") == "") { Ice::ObjectPrxPtr prx = batch->ice_getConnection()->createProxy(batch->ice_getIdentity())->ice_batchOneway(); Test::MyClassPrxPtr batch1 = ICE_UNCHECKED_CAST(Test::MyClassPrx, prx->ice_compress(false)); Test::MyClassPrxPtr batch2 = ICE_UNCHECKED_CAST(Test::MyClassPrx, prx->ice_compress(true)); Test::MyClassPrxPtr batch3 = ICE_UNCHECKED_CAST(Test::MyClassPrx, prx->ice_identity(identity)); batch1->opByteSOneway(bs1); batch1->opByteSOneway(bs1); batch1->opByteSOneway(bs1); batch1->ice_getConnection()->flushBatchRequests(Ice::ICE_SCOPED_ENUM(CompressBatch, Yes)); batch2->opByteSOneway(bs1); batch2->opByteSOneway(bs1); batch2->opByteSOneway(bs1); batch1->ice_getConnection()->flushBatchRequests(Ice::ICE_SCOPED_ENUM(CompressBatch, No)); batch1->opByteSOneway(bs1); batch1->opByteSOneway(bs1); batch1->opByteSOneway(bs1); batch1->ice_getConnection()->flushBatchRequests(Ice::ICE_SCOPED_ENUM(CompressBatch, BasedOnProxy)); batch1->opByteSOneway(bs1); batch2->opByteSOneway(bs1); batch1->opByteSOneway(bs1); batch1->ice_getConnection()->flushBatchRequests(Ice::ICE_SCOPED_ENUM(CompressBatch, BasedOnProxy)); batch1->opByteSOneway(bs1); batch3->opByteSOneway(bs1); batch1->opByteSOneway(bs1); batch1->ice_getConnection()->flushBatchRequests(Ice::ICE_SCOPED_ENUM(CompressBatch, BasedOnProxy)); } }
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; }
void batchOnewaysAMI(const Test::MyClassPrxPtr& p) { const Test::ByteS bs1(10 * 1024); Test::MyClassPrxPtr batch = ICE_UNCHECKED_CAST(Test::MyClassPrx, p->ice_batchOneway()); #ifdef ICE_CPP11_MAPPING promise<void> prom; batch->ice_flushBatchRequestsAsync(nullptr, [&](bool sentSynchronously) { test(sentSynchronously); prom.set_value(); }); // Empty flush prom.get_future().get(); for(int i = 0; i < 30; ++i) { batch->opByteSOnewayAsync(bs1, nullptr, [](exception_ptr){ test(false); }); } int count = 0; while(count < 27) // 3 * 9 requests auto-flushed. { count += p->opByteSOnewayCallCount(); IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(10)); } if(batch->ice_getConnection() && p->ice_getCommunicator()->getProperties()->getProperty("Ice.Default.Protocol") != "bt") { shared_ptr<Test::MyClassPrx> batch1 = Ice::uncheckedCast<Test::MyClassPrx>(p->ice_batchOneway()); shared_ptr<Test::MyClassPrx> batch2 = Ice::uncheckedCast<Test::MyClassPrx>(p->ice_batchOneway()); batch1->ice_pingAsync().get(); batch2->ice_pingAsync().get(); batch1->ice_flushBatchRequestsAsync().get(); batch1->ice_getConnection()->close(false); batch1->ice_pingAsync().get(); batch2->ice_pingAsync().get(); batch1->ice_getConnection(); batch2->ice_getConnection(); batch1->ice_pingAsync().get(); batch1->ice_getConnection()->close(false); batch1->ice_pingAsync().get(); batch2->ice_pingAsync().get(); } Ice::Identity identity; identity.name = "invalid"; auto batch3 = batch->ice_identity(identity); batch3->ice_pingAsync(); batch3->ice_flushBatchRequestsAsync().get(); // Make sure that a bogus batch request doesn't cause troubles to other ones. batch3->ice_pingAsync(); batch->ice_pingAsync(); batch->ice_flushBatchRequestsAsync().get(); batch->ice_pingAsync(); #else batch->end_ice_flushBatchRequests(batch->begin_ice_flushBatchRequests()); // Empty flush test(batch->begin_ice_flushBatchRequests()->isSent()); // Empty flush test(batch->begin_ice_flushBatchRequests()->isCompleted()); // Empty flush test(batch->begin_ice_flushBatchRequests()->sentSynchronously()); // Empty flush for(int i = 0; i < 30; ++i) { batch->begin_opByteSOneway(bs1, Test::newCallback_MyClass_opByteSOneway(new Callback_ByteSOneway(), &Callback_ByteSOneway::response, &Callback_ByteSOneway::exception)); } int count = 0; while(count < 27) // 3 * 9 requests auto-flushed. { count += p->opByteSOnewayCallCount(); IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(10)); } if(batch->ice_getConnection() && p->ice_getCommunicator()->getProperties()->getProperty("Ice.Default.Protocol") != "bt") { Test::MyClassPrx batch1 = Test::MyClassPrx::uncheckedCast(p->ice_batchOneway()); Test::MyClassPrx batch2 = Test::MyClassPrx::uncheckedCast(p->ice_batchOneway()); batch1->end_ice_ping(batch1->begin_ice_ping()); batch2->end_ice_ping(batch2->begin_ice_ping()); batch1->end_ice_flushBatchRequests(batch1->begin_ice_flushBatchRequests()); batch1->ice_getConnection()->close(false); batch1->end_ice_ping(batch1->begin_ice_ping()); batch2->end_ice_ping(batch2->begin_ice_ping()); batch1->ice_getConnection(); batch2->ice_getConnection(); batch1->end_ice_ping(batch1->begin_ice_ping()); batch1->ice_getConnection()->close(false); batch1->end_ice_ping(batch1->begin_ice_ping()); batch2->end_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(); #endif }