def twoElementCycle(self, current=None):
b1 = Test.B()
b1.sb = "B1.sb"
b2 = Test.B()
b2.sb = "B2.sb"
b2.pb = b1
b1.pb = b2
return Ice.Future.completed(b1)
def twoElementCycle(self, current=None):
b1 = Test.B()
b1.sb = "B1.sb"
b2 = Test.B()
b2.sb = "B2.sb"
b2.pb = b1
b1.pb = b2
return b1
def twoElementCycle_async(self, cb, current=None):
b1 = Test.B()
b1.sb = "B1.sb"
b2 = Test.B()
b2.sb = "B2.sb"
b2.pb = b1
b1.pb = b2
cb.ice_response(b1)
def paramTest4_async(self, cb, current=None):
d4 = Test.D4()
d4.sb = "D4.sb (1)"
d4.pb = None
d4.p1 = Test.B()
d4.p1.sb = "B.sb (1)"
d4.p1.pb = None
d4.p2 = Test.B()
d4.p2.sb = "B.sb (2)"
d4.p2.pb = None
cb.ice_response(d4.p2, d4)
def paramTest4(self, current=None):
d4 = Test.D4()
d4.sb = "D4.sb (1)"
d4.pb = None
d4.p1 = Test.B()
d4.p1.sb = "B.sb (1)"
d4.p1.pb = None
d4.p2 = Test.B()
d4.p2.sb = "B.sb (2)"
d4.p2.pb = None
return Ice.Future.completed((d4.p2, d4))
def paramTest4(self, current=None):
d4 = Test.D4()
d4.sb = "D4.sb (1)"
d4.pb = None
d4.p1 = Test.B()
d4.p1.sb = "B.sb (1)"
d4.p1.pb = None
d4.p2 = Test.B()
d4.p2.sb = "B.sb (2)"
d4.p2.pb = None
return (d4.p2, d4)
def throwBaseAsBase_async(self, cb, current=None):
be = Test.BaseException()
be.sbe = "sbe"
be.pb = Test.B()
be.pb.sb = "sb"
be.pb.pb = be.pb
cb.ice_exception(be)
def throwBaseAsBase(self, current=None):
be = Test.BaseException()
be.sbe = "sbe"
be.pb = Test.B()
be.pb.sb = "sb"
be.pb.pb = be.pb
raise be
def throwBaseAsBase(self, current=None):
be = Test.BaseException()
be.sbe = "sbe"
be.pb = Test.B()
be.pb.sb = "sb"
be.pb.pb = be.pb
f = Ice.Future()
f.set_exception(be)
return f
def throwDerivedAsDerived(self, current=None):
de = Test.DerivedException()
de.sbe = "sbe"
de.pb = Test.B()
de.pb.sb = "sb1"
de.pb.pb = de.pb
de.sde = "sde1"
de.pd1 = Test.D1()
de.pd1.sb = "sb2"
de.pd1.pb = de.pd1
de.pd1.sd1 = "sd2"
de.pd1.pd1 = de.pd1
raise de
def throwDerivedAsDerived_async(self, cb, current=None):
de = Test.DerivedException()
de.sbe = "sbe"
de.pb = Test.B()
de.pb.sb = "sb1"
de.pb.pb = de.pb
de.sde = "sde1"
de.pd1 = Test.D1()
de.pd1.sb = "sb2"
de.pd1.pb = de.pd1
de.pd1.sd1 = "sd2"
de.pd1.pd1 = de.pd1
cb.ice_exception(de)
def throwDerivedAsDerived(self, current=None):
de = Test.DerivedException()
de.sbe = "sbe"
de.pb = Test.B()
de.pb.sb = "sb1"
de.pb.pb = de.pb
de.sde = "sde1"
de.pd1 = Test.D1()
de.pd1.sb = "sb2"
de.pd1.pb = de.pd1
de.pd1.sd1 = "sd2"
de.pd1.pd1 = de.pd1
f = Ice.Future()
f.set_exception(de)
return f
def throwBasB(self, a, b, current=None):
ex = Test.B()
ex.aMem = a
ex.bMem = b
raise ex
def allTests(communicator):
sys.stdout.write("testing stringToProxy... ")
sys.stdout.flush()
ref = "initial:default -p 12010"
base = communicator.stringToProxy(ref)
test(base)
print("ok")
sys.stdout.write("testing checked cast... ")
sys.stdout.flush()
initial = Test.InitialPrx.checkedCast(base)
test(initial)
test(initial == base)
print("ok")
sys.stdout.write("testing optional data members... ")
sys.stdout.flush()
oo1 = Test.OneOptional()
test(oo1.a == Ice.Unset)
oo1.a = 15
oo2 = Test.OneOptional(16)
test(oo2.a == 16)
mo1 = Test.MultiOptional()
test(mo1.a == Ice.Unset)
test(mo1.b == Ice.Unset)
test(mo1.c == Ice.Unset)
test(mo1.d == Ice.Unset)
test(mo1.e == Ice.Unset)
test(mo1.f == Ice.Unset)
test(mo1.g == Ice.Unset)
test(mo1.h == Ice.Unset)
test(mo1.i == Ice.Unset)
test(mo1.j == Ice.Unset)
test(mo1.k == Ice.Unset)
test(mo1.bs == Ice.Unset)
test(mo1.ss == Ice.Unset)
test(mo1.iid == Ice.Unset)
test(mo1.sid == Ice.Unset)
test(mo1.fs == Ice.Unset)
test(mo1.vs == Ice.Unset)
test(mo1.shs == Ice.Unset)
test(mo1.es == Ice.Unset)
test(mo1.fss == Ice.Unset)
test(mo1.vss == Ice.Unset)
test(mo1.oos == Ice.Unset)
test(mo1.oops == Ice.Unset)
test(mo1.ied == Ice.Unset)
test(mo1.ifsd == Ice.Unset)
test(mo1.ivsd == Ice.Unset)
test(mo1.iood == Ice.Unset)
test(mo1.ioopd == Ice.Unset)
test(mo1.bos == Ice.Unset)
fs = Test.FixedStruct(78)
vs = Test.VarStruct("hello")
mo1 = Test.MultiOptional(15, True, 19, 78, 99, 5.5, 1.0, "test", Test.MyEnum.MyEnumMember, \
Test.MultiOptionalPrx.uncheckedCast(communicator.stringToProxy("test")), \
None, [5], ["test", "test2"], {4:3}, {"test":10}, fs, vs, [1], \
[Test.MyEnum.MyEnumMember, Test.MyEnum.MyEnumMember], \
[ fs ], [ vs ], [ oo1 ], \
[ Test.OneOptionalPrx.uncheckedCast(communicator.stringToProxy("test")) ], \
{4:Test.MyEnum.MyEnumMember}, {4:fs}, {5:vs}, {5:Test.OneOptional(15)}, \
{5:Test.OneOptionalPrx.uncheckedCast(communicator.stringToProxy("test"))}, \
[False, True, False])
test(mo1.a == 15)
test(mo1.b == True)
test(mo1.c == 19)
test(mo1.d == 78)
test(mo1.e == 99)
test(mo1.f == 5.5)
test(mo1.g == 1.0)
test(mo1.h == "test")
test(mo1.i == Test.MyEnum.MyEnumMember)
test(mo1.j == Test.MultiOptionalPrx.uncheckedCast(communicator.stringToProxy("test")))
test(mo1.k == None)
test(mo1.bs == [5])
test(mo1.ss == ["test", "test2"])
test(mo1.iid[4] == 3)
test(mo1.sid["test"] == 10)
test(mo1.fs == Test.FixedStruct(78))
test(mo1.vs == Test.VarStruct("hello"))
test(mo1.shs[0] == 1)
test(mo1.es[0] == Test.MyEnum.MyEnumMember and mo1.es[1] == Test.MyEnum.MyEnumMember)
test(mo1.fss[0] == Test.FixedStruct(78))
test(mo1.vss[0] == Test.VarStruct("hello"))
test(mo1.oos[0] == oo1)
test(mo1.oops[0] == Test.OneOptionalPrx.uncheckedCast(communicator.stringToProxy("test")))
test(mo1.ied[4] == Test.MyEnum.MyEnumMember)
test(mo1.ifsd[4] == Test.FixedStruct(78))
test(mo1.ivsd[5] == Test.VarStruct("hello"))
test(mo1.iood[5].a == 15)
test(mo1.ioopd[5] == Test.OneOptionalPrx.uncheckedCast(communicator.stringToProxy("test")))
test(mo1.bos == [False, True, False])
print("ok")
sys.stdout.write("testing marshaling... ")
sys.stdout.flush()
oo4 = initial.pingPong(Test.OneOptional())
test(oo4.a == Ice.Unset)
oo5 = initial.pingPong(oo1)
test(oo1.a == oo5.a)
mo4 = initial.pingPong(Test.MultiOptional())
test(mo4.a == Ice.Unset)
test(mo4.b == Ice.Unset)
test(mo4.c == Ice.Unset)
test(mo4.d == Ice.Unset)
test(mo4.e == Ice.Unset)
test(mo4.f == Ice.Unset)
test(mo4.g == Ice.Unset)
test(mo4.h == Ice.Unset)
test(mo4.i == Ice.Unset)
test(mo4.j == Ice.Unset)
test(mo4.k == Ice.Unset)
test(mo4.bs == Ice.Unset)
test(mo4.ss == Ice.Unset)
test(mo4.iid == Ice.Unset)
test(mo4.sid == Ice.Unset)
test(mo4.fs == Ice.Unset)
test(mo4.vs == Ice.Unset)
test(mo4.shs == Ice.Unset)
test(mo4.es == Ice.Unset)
test(mo4.fss == Ice.Unset)
test(mo4.vss == Ice.Unset)
test(mo4.oos == Ice.Unset)
test(mo4.oops == Ice.Unset)
test(mo4.ied == Ice.Unset)
test(mo4.ifsd == Ice.Unset)
test(mo4.ivsd == Ice.Unset)
test(mo4.iood == Ice.Unset)
test(mo4.ioopd == Ice.Unset)
test(mo4.bos == Ice.Unset)
mo5 = initial.pingPong(mo1)
test(mo5.a == mo1.a)
test(mo5.b == mo1.b)
test(mo5.c == mo1.c)
test(mo5.d == mo1.d)
test(mo5.e == mo1.e)
test(mo5.f == mo1.f)
test(mo5.g == mo1.g)
test(mo5.h == mo1.h)
test(mo5.i == mo1.i)
test(mo5.j == mo1.j)
test(mo5.k == None)
if sys.version_info[0] == 2:
test(mo5.bs == "\x05")
else:
test(mo5.bs[0] == 5)
test(mo5.ss == mo1.ss)
test(mo5.iid[4] == 3)
test(mo5.sid["test"] == 10)
test(mo5.fs == mo1.fs)
test(mo5.vs == mo1.vs)
test(mo5.shs == mo1.shs)
test(mo5.es[0] == Test.MyEnum.MyEnumMember and mo1.es[1] == Test.MyEnum.MyEnumMember)
test(mo5.fss[0] == Test.FixedStruct(78))
test(mo5.vss[0] == Test.VarStruct("hello"))
test(mo5.oos[0].a == 15)
test(mo5.oops[0] == Test.OneOptionalPrx.uncheckedCast(communicator.stringToProxy("test")))
test(mo5.ied[4] == Test.MyEnum.MyEnumMember)
test(mo5.ifsd[4] == Test.FixedStruct(78))
test(mo5.ivsd[5] == Test.VarStruct("hello"))
test(mo5.iood[5].a == 15)
test(mo5.ioopd[5] == Test.OneOptionalPrx.uncheckedCast(communicator.stringToProxy("test")))
test(mo5.bos == mo1.bos)
# Clear the first half of the optional members
mo6 = Test.MultiOptional()
mo6.b = mo5.b
mo6.d = mo5.d
mo6.f = mo5.f
mo6.h = mo5.h
mo6.j = mo5.j
mo6.bs = mo5.bs
mo6.iid = mo5.iid
mo6.fs = mo5.fs
mo6.shs = mo5.shs
mo6.fss = mo5.fss
mo6.oos = mo5.oos
mo6.ifsd = mo5.ifsd
mo6.iood = mo5.iood
mo6.bos = mo5.bos
mo7 = initial.pingPong(mo6)
test(mo7.a == Ice.Unset)
test(mo7.b == mo1.b)
test(mo7.c == Ice.Unset)
test(mo7.d == mo1.d)
test(mo7.e == Ice.Unset)
test(mo7.f == mo1.f)
test(mo7.g == Ice.Unset)
test(mo7.h == mo1.h)
test(mo7.i == Ice.Unset)
test(mo7.j == mo1.j)
test(mo7.k == Ice.Unset)
if sys.version_info[0] == 2:
test(mo7.bs == "\x05")
else:
test(mo7.bs[0] == 5)
test(mo7.ss == Ice.Unset)
test(mo7.iid[4] == 3)
test(mo7.sid == Ice.Unset)
test(mo7.fs == mo1.fs)
test(mo7.vs == Ice.Unset)
test(mo7.shs == mo1.shs)
test(mo7.es == Ice.Unset)
test(mo7.fss[0] == Test.FixedStruct(78))
test(mo7.vss == Ice.Unset)
test(mo7.oos[0].a == 15)
test(mo7.oops == Ice.Unset)
test(mo7.ied == Ice.Unset)
test(mo7.ifsd[4] == Test.FixedStruct(78))
test(mo7.ivsd == Ice.Unset)
test(mo7.iood[5].a == 15)
test(mo7.ioopd == Ice.Unset)
test(mo7.bos == [False, True, False])
# Clear the second half of the optional members
mo8 = Test.MultiOptional()
mo8.a = mo5.a
mo8.c = mo5.c
mo8.e = mo5.e
mo8.g = mo5.g
mo8.i = mo5.i
mo8.k = mo8
mo8.ss = mo5.ss
mo8.sid = mo5.sid
mo8.vs = mo5.vs
mo8.es = mo5.es
mo8.vss = mo5.vss
mo8.oops = mo5.oops
mo8.ied = mo5.ied
mo8.ivsd = mo5.ivsd
mo8.ioopd = mo5.ioopd
mo9 = initial.pingPong(mo8)
test(mo9.a == mo1.a)
test(mo9.b == Ice.Unset)
test(mo9.c == mo1.c)
test(mo9.d == Ice.Unset)
test(mo9.e == mo1.e)
test(mo9.f == Ice.Unset)
test(mo9.g == mo1.g)
test(mo9.h == Ice.Unset)
test(mo9.i == mo1.i)
test(mo9.j == Ice.Unset)
test(mo9.k == mo9)
test(mo9.bs == Ice.Unset)
test(mo9.ss == mo1.ss)
test(mo9.iid == Ice.Unset)
test(mo9.sid["test"] == 10)
test(mo9.fs == Ice.Unset)
test(mo9.vs == mo1.vs)
test(mo9.shs == Ice.Unset)
test(mo9.es[0] == Test.MyEnum.MyEnumMember and mo1.es[1] == Test.MyEnum.MyEnumMember)
test(mo9.fss == Ice.Unset)
test(mo9.vss[0] == Test.VarStruct("hello"))
test(mo9.oos == Ice.Unset)
test(mo9.oops[0] == Test.OneOptionalPrx.uncheckedCast(communicator.stringToProxy("test")))
test(mo9.ied[4] == Test.MyEnum.MyEnumMember)
test(mo9.ifsd == Ice.Unset)
test(mo9.ivsd[5] == Test.VarStruct("hello"))
test(mo9.iood == Ice.Unset)
test(mo9.ioopd[5] == Test.OneOptionalPrx.uncheckedCast(communicator.stringToProxy("test")))
test(mo9.bos == Ice.Unset)
#
# Use the 1.0 encoding with operations whose only class parameters are optional.
#
initial.sendOptionalClass(True, Test.OneOptional(53))
initial.ice_encodingVersion(Ice.Encoding_1_0).sendOptionalClass(True, Test.OneOptional(53))
r = initial.returnOptionalClass(True)
test(r != Ice.Unset)
r = initial.ice_encodingVersion(Ice.Encoding_1_0).returnOptionalClass(True)
test(r == Ice.Unset)
print("ok")
sys.stdout.write("testing marshaling of large containers with fixed size elements... ")
sys.stdout.flush()
mc = Test.MultiOptional()
mc.bs = []
for i in range(1000):
mc.bs.append(0)
mc.shs = []
for i in range(300):
mc.shs.append(0)
mc.fss = []
for i in range(300):
mc.fss.append(Test.FixedStruct())
mc.ifsd = {}
for i in range(300):
mc.ifsd[i] = Test.FixedStruct()
mc = initial.pingPong(mc)
test(len(mc.bs) == 1000)
test(len(mc.shs) == 300)
test(len(mc.fss) == 300)
test(len(mc.ifsd) == 300)
print("ok")
sys.stdout.write("testing tag marshaling... ")
sys.stdout.flush()
b = Test.B()
b2 = initial.pingPong(b)
test(b2.ma == Ice.Unset)
test(b2.mb == Ice.Unset)
test(b2.mc == Ice.Unset)
b.ma = 10
b.mb = 11
b.mc = 12
b.md = 13
b2 = initial.pingPong(b)
test(b2.ma == 10)
test(b2.mb == 11)
test(b2.mc == 12)
test(b2.md == 13)
print("ok")
sys.stdout.write("testing marshalling of objects with optional objects...")
sys.stdout.flush()
f = Test.F()
f.af = Test.A()
f.ae = f.af
rf = initial.pingPong(f)
test(rf.ae == rf.af)
print("ok")
sys.stdout.write("testing optional with default values... ")
sys.stdout.flush()
wd = initial.pingPong(Test.WD())
test(wd.a == 5)
test(wd.s == "test")
wd.a = Ice.Unset
wd.s = Ice.Unset
wd = initial.pingPong(wd)
test(wd.a == Ice.Unset)
test(wd.s == Ice.Unset)
print("ok")
if communicator.getProperties().getPropertyAsInt("Ice.Default.SlicedFormat") > 0:
sys.stdout.write("testing marshaling with unknown class slices... ")
sys.stdout.flush()
c = Test.C()
c.ss = "test"
c.ms = "testms"
c = initial.pingPong(c)
test(c.ma == Ice.Unset)
test(c.mb == Ice.Unset)
test(c.mc == Ice.Unset)
test(c.md == Ice.Unset)
test(c.ss == "test")
test(c.ms == "testms")
print("ok")
sys.stdout.write("testing optionals with unknown classes... ")
sys.stdout.flush()
initial2 = Test.Initial2Prx.uncheckedCast(base)
d = Test.D()
d.ds = "test"
d.seq = ["test1", "test2", "test3", "test4"]
d.ao = Test.A(18)
d.requiredB = 14;
d.requiredA = 14;
initial2.opClassAndUnknownOptional(Test.A(), d)
print("ok")
sys.stdout.write("testing optional parameters... ")
sys.stdout.flush()
(p2, p3) = initial.opByte(Ice.Unset)
test(p2 == Ice.Unset and p3 == Ice.Unset)
(p2, p3) = initial.opByte(56)
test(p2 == 56 and p3 == 56)
r = initial.begin_opByte(56)
(p2, p3) = initial.end_opByte(r)
test(p2 == 56 and p3 == 56)
(p2, p3) = initial.opBool(Ice.Unset)
test(p2 == Ice.Unset and p3 == Ice.Unset)
(p2, p3) = initial.opBool(True)
test(p2 == True and p3 == True)
r = initial.begin_opBool(True)
(p2, p3) = initial.end_opBool(r)
test(p2 == True and p3 == True)
(p2, p3) = initial.opShort(Ice.Unset)
test(p2 == Ice.Unset and p3 == Ice.Unset)
(p2, p3) = initial.opShort(56)
test(p2 == 56 and p3 == 56)
r = initial.begin_opShort(56)
(p2, p3) = initial.end_opShort(r)
test(p2 == 56 and p3 == 56)
(p2, p3) = initial.opInt(Ice.Unset)
test(p2 == Ice.Unset and p3 == Ice.Unset)
(p2, p3) = initial.opInt(56)
test(p2 == 56 and p3 == 56)
r = initial.begin_opInt(56)
(p2, p3) = initial.end_opInt(r)
test(p2 == 56 and p3 == 56)
(p2, p3) = initial.opLong(Ice.Unset)
test(p2 == Ice.Unset and p3 == Ice.Unset)
(p2, p3) = initial.opLong(56)
test(p2 == 56 and p3 == 56)
r = initial.begin_opLong(56)
(p2, p3) = initial.end_opLong(r)
test(p2 == 56 and p3 == 56)
(p2, p3) = initial.opFloat(Ice.Unset)
test(p2 == Ice.Unset and p3 == Ice.Unset)
(p2, p3) = initial.opFloat(1.0)
test(p2 == 1.0 and p3 == 1.0)
r = initial.begin_opFloat(1.0)
(p2, p3) = initial.end_opFloat(r)
test(p2 == 1.0 and p3 == 1.0)
(p2, p3) = initial.opDouble(Ice.Unset)
test(p2 == Ice.Unset and p3 == Ice.Unset)
(p2, p3) = initial.opDouble(1.0)
test(p2 == 1.0 and p3 == 1.0)
r = initial.begin_opDouble(1.0)
(p2, p3) = initial.end_opDouble(r)
test(p2 == 1.0 and p3 == 1.0)
(p2, p3) = initial.opString(Ice.Unset)
test(p2 == Ice.Unset and p3 == Ice.Unset)
(p2, p3) = initial.opString("test")
test(p2 == "test" and p3 == "test")
r = initial.begin_opString("test")
(p2, p3) = initial.end_opString(r)
test(p2 == "test" and p3 == "test")
(p2, p3) = initial.opMyEnum(Ice.Unset)
test(p2 == Ice.Unset and p3 == Ice.Unset)
(p2, p3) = initial.opMyEnum(Test.MyEnum.MyEnumMember)
test(p2 == Test.MyEnum.MyEnumMember and p3 == Test.MyEnum.MyEnumMember)
r = initial.begin_opMyEnum(Test.MyEnum.MyEnumMember)
(p2, p3) = initial.end_opMyEnum(r)
test(p2 == Test.MyEnum.MyEnumMember and p3 == Test.MyEnum.MyEnumMember)
(p2, p3) = initial.opSmallStruct(Ice.Unset)
test(p2 == Ice.Unset and p3 == Ice.Unset)
p1 = Test.SmallStruct(56)
(p2, p3) = initial.opSmallStruct(p1)
test(p2 == p1 and p3 == p1)
r = initial.begin_opSmallStruct(p1)
(p2, p3) = initial.end_opSmallStruct(r)
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opFixedStruct(Ice.Unset)
test(p2 == Ice.Unset and p3 == Ice.Unset)
p1 = Test.FixedStruct(56)
(p2, p3) = initial.opFixedStruct(p1)
test(p2 == p1 and p3 == p1)
r = initial.begin_opFixedStruct(p1)
(p2, p3) = initial.end_opFixedStruct(r)
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opVarStruct(Ice.Unset)
test(p2 == Ice.Unset and p3 == Ice.Unset)
p1 = Test.VarStruct("test")
(p2, p3) = initial.opVarStruct(p1)
test(p2 == p1 and p3 == p1)
r = initial.begin_opVarStruct(p1)
(p2, p3) = initial.end_opVarStruct(r)
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opOneOptional(Ice.Unset)
test(p2 == Ice.Unset and p3 == Ice.Unset)
p1 = Test.OneOptional(58)
(p2, p3) = initial.opOneOptional(p1)
test(p2.a == p1.a and p3.a == p1.a)
r = initial.begin_opOneOptional(p1)
(p2, p3) = initial.end_opOneOptional(r)
test(p2.a == p1.a and p3.a == p1.a)
(p2, p3) = initial.opOneOptionalProxy(Ice.Unset)
test(p2 == Ice.Unset and p3 == Ice.Unset)
p1 = Test.OneOptionalPrx.uncheckedCast(communicator.stringToProxy("test"))
(p2, p3) = initial.opOneOptionalProxy(p1)
test(p2 == p1 and p3 == p1)
r = initial.begin_opOneOptionalProxy(p1)
(p2, p3) = initial.end_opOneOptionalProxy(r)
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opByteSeq(Ice.Unset)
test(p2 == Ice.Unset and p3 == Ice.Unset)
p1 = [56 for x in range(100)]
(p2, p3) = initial.opByteSeq(p1)
test(len(p2) == len(p1) and len(p3) == len(p1))
if sys.version_info[0] == 2:
test(p2[0] == '\x38')
test(p3[0] == '\x38')
else:
test(p2[0] == 0x38)
test(p3[0] == 0x38)
r = initial.begin_opByteSeq(p1)
(p2, p3) = initial.end_opByteSeq(r)
test(len(p2) == len(p1) and len(p3) == len(p1))
if sys.version_info[0] == 2:
test(p2[0] == '\x38')
test(p3[0] == '\x38')
else:
test(p2[0] == 0x38)
test(p3[0] == 0x38)
(p2, p3) = initial.opBoolSeq(Ice.Unset)
test(p2 == Ice.Unset and p3 == Ice.Unset)
p1 = [True for x in range(100)]
(p2, p3) = initial.opBoolSeq(p1)
test(p2 == p1 and p3 == p1)
r = initial.begin_opBoolSeq(p1)
(p2, p3) = initial.end_opBoolSeq(r)
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opShortSeq(Ice.Unset)
test(p2 == Ice.Unset and p3 == Ice.Unset)
p1 = [56 for x in range(100)]
(p2, p3) = initial.opShortSeq(p1)
test(p2 == p1 and p3 == p1)
r = initial.begin_opShortSeq(p1)
(p2, p3) = initial.end_opShortSeq(r)
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opIntSeq(Ice.Unset)
test(p2 == Ice.Unset and p3 == Ice.Unset)
p1 = [56 for x in range(100)]
(p2, p3) = initial.opIntSeq(p1)
test(p2 == p1 and p3 == p1)
r = initial.begin_opIntSeq(p1)
(p2, p3) = initial.end_opIntSeq(r)
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opLongSeq(Ice.Unset)
test(p2 == Ice.Unset and p3 == Ice.Unset)
p1 = [56 for x in range(100)]
(p2, p3) = initial.opLongSeq(p1)
test(p2 == p1 and p3 == p1)
r = initial.begin_opLongSeq(p1)
(p2, p3) = initial.end_opLongSeq(r)
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opFloatSeq(Ice.Unset)
test(p2 == Ice.Unset and p3 == Ice.Unset)
p1 = [1.0 for x in range(100)]
(p2, p3) = initial.opFloatSeq(p1)
test(p2 == p1 and p3 == p1)
r = initial.begin_opFloatSeq(p1)
(p2, p3) = initial.end_opFloatSeq(r)
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opDoubleSeq(Ice.Unset)
test(p2 == Ice.Unset and p3 == Ice.Unset)
p1 = [1.0 for x in range(100)]
(p2, p3) = initial.opDoubleSeq(p1)
test(p2 == p1 and p3 == p1)
r = initial.begin_opDoubleSeq(p1)
(p2, p3) = initial.end_opDoubleSeq(r)
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opStringSeq(Ice.Unset)
test(p2 == Ice.Unset and p3 == Ice.Unset)
p1 = ["test1" for x in range(100)]
(p2, p3) = initial.opStringSeq(p1)
test(p2 == p1 and p3 == p1)
r = initial.begin_opStringSeq(p1)
(p2, p3) = initial.end_opStringSeq(r)
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opSmallStructSeq(Ice.Unset)
test(p2 == Ice.Unset and p3 == Ice.Unset)
p1 = [Test.SmallStruct(1) for x in range(10)]
(p2, p3) = initial.opSmallStructSeq(p1)
test(p2 == p1 and p3 == p1)
r = initial.begin_opSmallStructSeq(p1)
(p2, p3) = initial.end_opSmallStructSeq(r)
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opSmallStructList(Ice.Unset)
test(p2 == Ice.Unset and p3 == Ice.Unset)
p1 = tuple([Test.SmallStruct(1) for x in range(10)])
(p2, p3) = initial.opSmallStructList(p1)
test(p2 == p1 and p3 == p1)
r = initial.begin_opSmallStructList(p1)
(p2, p3) = initial.end_opSmallStructList(r)
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opFixedStructSeq(Ice.Unset)
test(p2 == Ice.Unset and p3 == Ice.Unset)
p1 = [Test.FixedStruct(1) for x in range(10)]
(p2, p3) = initial.opFixedStructSeq(p1)
test(p2 == p1 and p3 == p1)
r = initial.begin_opFixedStructSeq(p1)
(p2, p3) = initial.end_opFixedStructSeq(r)
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opFixedStructList(Ice.Unset)
test(p2 == Ice.Unset and p3 == Ice.Unset)
p1 = tuple([Test.FixedStruct(1) for x in range(10)])
(p2, p3) = initial.opFixedStructList(p1)
test(p2 == p1 and p3 == p1)
r = initial.begin_opFixedStructList(p1)
(p2, p3) = initial.end_opFixedStructList(r)
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opVarStructSeq(Ice.Unset)
test(p2 == Ice.Unset and p3 == Ice.Unset)
p1 = [Test.VarStruct("test") for x in range(10)]
(p2, p3) = initial.opVarStructSeq(p1)
test(p2 == p1 and p3 == p1)
r = initial.begin_opVarStructSeq(p1)
(p2, p3) = initial.end_opVarStructSeq(r)
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opIntIntDict(Ice.Unset)
test(p2 == Ice.Unset and p3 == Ice.Unset)
p1 = {1:2, 2:3}
(p2, p3) = initial.opIntIntDict(p1)
test(p2 == p1 and p3 == p1)
r = initial.begin_opIntIntDict(p1)
(p2, p3) = initial.end_opIntIntDict(r)
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opStringIntDict(Ice.Unset)
test(p2 == Ice.Unset and p3 == Ice.Unset)
p1 = {"1":2, "2":3}
(p2, p3) = initial.opStringIntDict(p1)
test(p2 == p1 and p3 == p1)
r = initial.begin_opStringIntDict(p1)
(p2, p3) = initial.end_opStringIntDict(r)
test(p2 == p1 and p3 == p1)
print("ok")
sys.stdout.write("testing exception optionals... ")
sys.stdout.flush()
try:
initial.opOptionalException(Ice.Unset, Ice.Unset, Ice.Unset)
except Test.OptionalException as ex:
test(ex.a == Ice.Unset)
test(ex.b == Ice.Unset)
test(ex.o == Ice.Unset)
try:
initial.opOptionalException(30, "test", Test.OneOptional(53))
except Test.OptionalException as ex:
test(ex.a == 30)
test(ex.b == "test")
test(ex.o.a == 53)
try:
#
# Use the 1.0 encoding with an exception whose only class members are optional.
#
initial.ice_encodingVersion(Ice.Encoding_1_0).opOptionalException(30, "test", Test.OneOptional(53))
except Test.OptionalException as ex:
test(ex.a == Ice.Unset)
test(ex.b == Ice.Unset)
test(ex.o == Ice.Unset)
try:
initial.opDerivedException(Ice.Unset, Ice.Unset, Ice.Unset)
except Test.DerivedException as ex:
test(ex.a == Ice.Unset)
test(ex.b == Ice.Unset)
test(ex.o == Ice.Unset)
test(ex.ss == Ice.Unset)
test(ex.o2 == Ice.Unset)
try:
initial.opDerivedException(30, "test2", Test.OneOptional(53))
except Test.DerivedException as ex:
test(ex.a == 30)
test(ex.b == "test2")
test(ex.o.a == 53)
test(ex.ss == "test2")
test(ex.o2 == ex.o)
try:
initial.opRequiredException(Ice.Unset, Ice.Unset, Ice.Unset)
except Test.RequiredException as ex:
test(ex.a == Ice.Unset)
test(ex.b == Ice.Unset)
test(ex.o == Ice.Unset)
test(ex.ss == "test")
test(ex.o2 == None)
try:
initial.opRequiredException(30, "test2", Test.OneOptional(53))
except Test.RequiredException as ex:
test(ex.a == 30)
test(ex.b == "test2")
test(ex.o.a == 53)
test(ex.ss == "test2")
test(ex.o2 == ex.o)
print("ok")
return initial
def oneElementCycle_async(self, cb, current=None):
b = Test.B()
b.sb = "B1.sb"
b.pb = b
cb.ice_response(b)
def oneElementCycle(self, current=None):
b = Test.B()
b.sb = "B1.sb"
b.pb = b
return Ice.Future.completed(b)
def throwBasA_async(self, cb, a, b, current=None):
ex = Test.B()
ex.aMem = a
ex.bMem = b
raise ex
def oneElementCycle(self, current=None):
b = Test.B()
b.sb = "B1.sb"
b.pb = b
return b
def allTests(helper, communicator):
sys.stdout.write("testing stringToProxy... ")
sys.stdout.flush()
ref = "initial:{0}".format(helper.getTestEndpoint())
base = communicator.stringToProxy(ref)
test(base)
print("ok")
sys.stdout.write("testing checked cast... ")
sys.stdout.flush()
initial = Test.InitialPrx.checkedCast(base)
test(initial)
test(initial == base)
print("ok")
sys.stdout.write("testing optional data members... ")
sys.stdout.flush()
oo1 = Test.OneOptional()
test(oo1.a is Ice.Unset)
oo1.a = 15
oo2 = Test.OneOptional(16)
test(oo2.a == 16)
mo1 = Test.MultiOptional()
test(mo1.a is Ice.Unset)
test(mo1.b is Ice.Unset)
test(mo1.c is Ice.Unset)
test(mo1.d is Ice.Unset)
test(mo1.e is Ice.Unset)
test(mo1.f is Ice.Unset)
test(mo1.g is Ice.Unset)
test(mo1.h is Ice.Unset)
test(mo1.i is Ice.Unset)
test(mo1.j is Ice.Unset)
test(mo1.k is Ice.Unset)
test(mo1.bs is Ice.Unset)
test(mo1.ss is Ice.Unset)
test(mo1.iid is Ice.Unset)
test(mo1.sid is Ice.Unset)
test(mo1.fs is Ice.Unset)
test(mo1.vs is Ice.Unset)
test(mo1.shs is Ice.Unset)
test(mo1.es is Ice.Unset)
test(mo1.fss is Ice.Unset)
test(mo1.vss is Ice.Unset)
test(mo1.oos is Ice.Unset)
test(mo1.oops is Ice.Unset)
test(mo1.ied is Ice.Unset)
test(mo1.ifsd is Ice.Unset)
test(mo1.ivsd is Ice.Unset)
test(mo1.iood is Ice.Unset)
test(mo1.ioopd is Ice.Unset)
test(mo1.bos is Ice.Unset)
ss = Test.SmallStruct()
fs = Test.FixedStruct(78)
vs = Test.VarStruct("hello")
mo1 = Test.MultiOptional(15, True, 19, 78, 99, 5.5, 1.0, "test", Test.MyEnum.MyEnumMember, \
communicator.stringToProxy("test"), \
None, [5], ["test", "test2"], {4:3}, {"test":10}, fs, vs, [1], \
[Test.MyEnum.MyEnumMember, Test.MyEnum.MyEnumMember], \
[ fs ], [ vs ], [ oo1 ], \
[ communicator.stringToProxy("test") ], \
{4:Test.MyEnum.MyEnumMember}, {4:fs}, {5:vs}, {5:Test.OneOptional(15)}, \
{5:communicator.stringToProxy("test")}, \
[False, True, False])
test(mo1.a == 15)
test(mo1.b == True)
test(mo1.c == 19)
test(mo1.d == 78)
test(mo1.e == 99)
test(mo1.f == 5.5)
test(mo1.g == 1.0)
test(mo1.h == "test")
test(mo1.i == Test.MyEnum.MyEnumMember)
test(mo1.j == communicator.stringToProxy("test"))
test(mo1.k == None)
test(mo1.bs == [5])
test(mo1.ss == ["test", "test2"])
test(mo1.iid[4] == 3)
test(mo1.sid["test"] == 10)
test(mo1.fs == Test.FixedStruct(78))
test(mo1.vs == Test.VarStruct("hello"))
test(mo1.shs[0] == 1)
test(mo1.es[0] == Test.MyEnum.MyEnumMember and mo1.es[1] == Test.MyEnum.MyEnumMember)
test(mo1.fss[0] == Test.FixedStruct(78))
test(mo1.vss[0] == Test.VarStruct("hello"))
test(mo1.oos[0] == oo1)
test(mo1.oops[0] == communicator.stringToProxy("test"))
test(mo1.ied[4] == Test.MyEnum.MyEnumMember)
test(mo1.ifsd[4] == Test.FixedStruct(78))
test(mo1.ivsd[5] == Test.VarStruct("hello"))
test(mo1.iood[5].a == 15)
test(mo1.ioopd[5] == communicator.stringToProxy("test"))
test(mo1.bos == [False, True, False])
#
# Test generated struct and classes compare with Ice.Unset
#
test(ss != Ice.Unset)
test(fs != Ice.Unset)
test(vs != Ice.Unset)
test(mo1 != Ice.Unset)
print("ok")
sys.stdout.write("testing marshaling... ")
sys.stdout.flush()
oo4 = initial.pingPong(Test.OneOptional())
test(oo4.a is Ice.Unset)
oo5 = initial.pingPong(oo1)
test(oo1.a == oo5.a)
mo4 = initial.pingPong(Test.MultiOptional())
test(mo4.a is Ice.Unset)
test(mo4.b is Ice.Unset)
test(mo4.c is Ice.Unset)
test(mo4.d is Ice.Unset)
test(mo4.e is Ice.Unset)
test(mo4.f is Ice.Unset)
test(mo4.g is Ice.Unset)
test(mo4.h is Ice.Unset)
test(mo4.i is Ice.Unset)
test(mo4.j is Ice.Unset)
test(mo4.k is Ice.Unset)
test(mo4.bs is Ice.Unset)
test(mo4.ss is Ice.Unset)
test(mo4.iid is Ice.Unset)
test(mo4.sid is Ice.Unset)
test(mo4.fs is Ice.Unset)
test(mo4.vs is Ice.Unset)
test(mo4.shs is Ice.Unset)
test(mo4.es is Ice.Unset)
test(mo4.fss is Ice.Unset)
test(mo4.vss is Ice.Unset)
test(mo4.oos is Ice.Unset)
test(mo4.oops is Ice.Unset)
test(mo4.ied is Ice.Unset)
test(mo4.ifsd is Ice.Unset)
test(mo4.ivsd is Ice.Unset)
test(mo4.iood is Ice.Unset)
test(mo4.ioopd is Ice.Unset)
test(mo4.bos is Ice.Unset)
mo5 = initial.pingPong(mo1)
test(mo5.a == mo1.a)
test(mo5.b == mo1.b)
test(mo5.c == mo1.c)
test(mo5.d == mo1.d)
test(mo5.e == mo1.e)
test(mo5.f == mo1.f)
test(mo5.g == mo1.g)
test(mo5.h == mo1.h)
test(mo5.i == mo1.i)
test(mo5.j == mo1.j)
#
# With Swift mapping you cannot distinguish null from unset
# so we test for both here to support cross testing.
#
test(mo5.k is None or mo5.k is Ice.Unset)
if sys.version_info[0] == 2:
test(mo5.bs == "\x05")
else:
test(mo5.bs[0] == 5)
test(mo5.ss == mo1.ss)
test(mo5.iid[4] == 3)
test(mo5.sid["test"] == 10)
test(mo5.fs == mo1.fs)
test(mo5.vs == mo1.vs)
test(mo5.shs == mo1.shs)
test(mo5.es[0] == Test.MyEnum.MyEnumMember and mo1.es[1] == Test.MyEnum.MyEnumMember)
test(mo5.fss[0] == Test.FixedStruct(78))
test(mo5.vss[0] == Test.VarStruct("hello"))
test(mo5.oos[0].a == 15)
test(mo5.oops[0] == communicator.stringToProxy("test"))
test(mo5.ied[4] == Test.MyEnum.MyEnumMember)
test(mo5.ifsd[4] == Test.FixedStruct(78))
test(mo5.ivsd[5] == Test.VarStruct("hello"))
test(mo5.iood[5].a == 15)
test(mo5.ioopd[5] == communicator.stringToProxy("test"))
test(mo5.bos == mo1.bos)
# Clear the first half of the optional members
mo6 = Test.MultiOptional()
mo6.b = mo5.b
mo6.d = mo5.d
mo6.f = mo5.f
mo6.h = mo5.h
mo6.j = mo5.j
mo6.bs = mo5.bs
mo6.iid = mo5.iid
mo6.fs = mo5.fs
mo6.shs = mo5.shs
mo6.fss = mo5.fss
mo6.oos = mo5.oos
mo6.ifsd = mo5.ifsd
mo6.iood = mo5.iood
mo6.bos = mo5.bos
mo7 = initial.pingPong(mo6)
test(mo7.a is Ice.Unset)
test(mo7.b == mo1.b)
test(mo7.c is Ice.Unset)
test(mo7.d == mo1.d)
test(mo7.e is Ice.Unset)
test(mo7.f == mo1.f)
test(mo7.g is Ice.Unset)
test(mo7.h == mo1.h)
test(mo7.i is Ice.Unset)
test(mo7.j == mo1.j)
test(mo7.k is Ice.Unset)
if sys.version_info[0] == 2:
test(mo7.bs == "\x05")
else:
test(mo7.bs[0] == 5)
test(mo7.ss is Ice.Unset)
test(mo7.iid[4] == 3)
test(mo7.sid is Ice.Unset)
test(mo7.fs == mo1.fs)
test(mo7.vs is Ice.Unset)
test(mo7.shs == mo1.shs)
test(mo7.es is Ice.Unset)
test(mo7.fss[0] == Test.FixedStruct(78))
test(mo7.vss is Ice.Unset)
test(mo7.oos[0].a == 15)
test(mo7.oops is Ice.Unset)
test(mo7.ied is Ice.Unset)
test(mo7.ifsd[4] == Test.FixedStruct(78))
test(mo7.ivsd is Ice.Unset)
test(mo7.iood[5].a == 15)
test(mo7.ioopd is Ice.Unset)
test(mo7.bos == [False, True, False])
# Clear the second half of the optional members
mo8 = Test.MultiOptional()
mo8.a = mo5.a
mo8.c = mo5.c
mo8.e = mo5.e
mo8.g = mo5.g
mo8.i = mo5.i
mo8.k = mo8
mo8.ss = mo5.ss
mo8.sid = mo5.sid
mo8.vs = mo5.vs
mo8.es = mo5.es
mo8.vss = mo5.vss
mo8.oops = mo5.oops
mo8.ied = mo5.ied
mo8.ivsd = mo5.ivsd
mo8.ioopd = mo5.ioopd
mo9 = initial.pingPong(mo8)
test(mo9.a == mo1.a)
test(mo9.b is Ice.Unset)
test(mo9.c == mo1.c)
test(mo9.d is Ice.Unset)
test(mo9.e == mo1.e)
test(mo9.f is Ice.Unset)
test(mo9.g == mo1.g)
test(mo9.h is Ice.Unset)
test(mo9.i == mo1.i)
test(mo9.j is Ice.Unset)
test(mo9.k == mo9)
test(mo9.bs is Ice.Unset)
test(mo9.ss == mo1.ss)
test(mo9.iid is Ice.Unset)
test(mo9.sid["test"] == 10)
test(mo9.fs is Ice.Unset)
test(mo9.vs == mo1.vs)
test(mo9.shs is Ice.Unset)
test(mo9.es[0] == Test.MyEnum.MyEnumMember and mo1.es[1] == Test.MyEnum.MyEnumMember)
test(mo9.fss is Ice.Unset)
test(mo9.vss[0] == Test.VarStruct("hello"))
test(mo9.oos is Ice.Unset)
test(mo9.oops[0] == communicator.stringToProxy("test"))
test(mo9.ied[4] == Test.MyEnum.MyEnumMember)
test(mo9.ifsd is Ice.Unset)
test(mo9.ivsd[5] == Test.VarStruct("hello"))
test(mo9.iood is Ice.Unset)
test(mo9.ioopd[5] == communicator.stringToProxy("test"))
test(mo9.bos is Ice.Unset)
#
# Use the 1.0 encoding with operations whose only class parameters are optional.
#
initial.sendOptionalClass(True, Test.OneOptional(53))
initial.ice_encodingVersion(Ice.Encoding_1_0).sendOptionalClass(True, Test.OneOptional(53))
r = initial.returnOptionalClass(True)
test(r != Ice.Unset)
r = initial.ice_encodingVersion(Ice.Encoding_1_0).returnOptionalClass(True)
test(r is Ice.Unset)
recursive1 = [ Test.Recursive() ]
recursive2 = [ Test.Recursive() ]
recursive1[0].value = recursive2;
outer = Test.Recursive()
outer.value = recursive1
initial.pingPong(outer)
g = Test.G()
g.gg1Opt = Test.G1("gg1Opt")
g.gg2 = Test.G2(10)
g.gg2Opt = Test.G2(20)
g.gg1 = Test.G1("gg1")
r = initial.opG(g)
test(r.gg1Opt.a == "gg1Opt")
test(r.gg2.a == 10)
test(r.gg2Opt.a == 20)
test(r.gg1.a == "gg1")
initial2 = Test.Initial2Prx.uncheckedCast(base)
initial2.opVoid(15, "test")
print("ok")
sys.stdout.write("testing marshaling of large containers with fixed size elements... ")
sys.stdout.flush()
mc = Test.MultiOptional()
mc.bs = []
for i in range(1000):
mc.bs.append(0)
mc.shs = []
for i in range(300):
mc.shs.append(0)
mc.fss = []
for i in range(300):
mc.fss.append(Test.FixedStruct())
mc.ifsd = {}
for i in range(300):
mc.ifsd[i] = Test.FixedStruct()
mc = initial.pingPong(mc)
test(len(mc.bs) == 1000)
test(len(mc.shs) == 300)
test(len(mc.fss) == 300)
test(len(mc.ifsd) == 300)
print("ok")
sys.stdout.write("testing tag marshaling... ")
sys.stdout.flush()
b = Test.B()
b2 = initial.pingPong(b)
test(b2.ma is Ice.Unset)
test(b2.mb is Ice.Unset)
test(b2.mc is Ice.Unset)
b.ma = 10
b.mb = 11
b.mc = 12
b.md = 13
b2 = initial.pingPong(b)
test(b2.ma == 10)
test(b2.mb == 11)
test(b2.mc == 12)
test(b2.md == 13)
print("ok")
sys.stdout.write("testing marshalling of objects with optional objects...")
sys.stdout.flush()
f = Test.F()
f.af = Test.A()
f.ae = f.af
rf = initial.pingPong(f)
test(rf.ae == rf.af)
print("ok")
sys.stdout.write("testing optional with default values... ")
sys.stdout.flush()
wd = initial.pingPong(Test.WD())
test(wd.a == 5)
test(wd.s == "test")
wd.a = Ice.Unset
wd.s = Ice.Unset
wd = initial.pingPong(wd)
test(wd.a is Ice.Unset)
test(wd.s is Ice.Unset)
print("ok")
if communicator.getProperties().getPropertyAsInt("Ice.Default.SlicedFormat") > 0:
sys.stdout.write("testing marshaling with unknown class slices... ")
sys.stdout.flush()
c = Test.C()
c.ss = "test"
c.ms = "testms"
c = initial.pingPong(c)
test(c.ma is Ice.Unset)
test(c.mb is Ice.Unset)
test(c.mc is Ice.Unset)
test(c.md is Ice.Unset)
test(c.ss == "test")
test(c.ms == "testms")
print("ok")
sys.stdout.write("testing optionals with unknown classes... ")
sys.stdout.flush()
initial2 = Test.Initial2Prx.uncheckedCast(base)
d = Test.D()
d.ds = "test"
d.seq = ["test1", "test2", "test3", "test4"]
d.ao = Test.A(18)
d.requiredB = 14;
d.requiredA = 14;
initial2.opClassAndUnknownOptional(Test.A(), d)
print("ok")
sys.stdout.write("testing optional parameters... ")
sys.stdout.flush()
(p2, p3) = initial.opByte(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
(p2, p3) = initial.opByte(56)
test(p2 == 56 and p3 == 56)
f = initial.opByteAsync(56)
(p2, p3) = f.result()
test(p2 == 56 and p3 == 56)
(p2, p3) = initial.opBool(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
(p2, p3) = initial.opBool(True)
test(p2 == True and p3 == True)
f = initial.opBoolAsync(True)
(p2, p3) = f.result()
test(p2 == True and p3 == True)
(p2, p3) = initial.opShort(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
(p2, p3) = initial.opShort(56)
test(p2 == 56 and p3 == 56)
f = initial.opShortAsync(56)
(p2, p3) = f.result()
test(p2 == 56 and p3 == 56)
(p2, p3) = initial.opInt(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
(p2, p3) = initial.opInt(56)
test(p2 == 56 and p3 == 56)
f = initial.opIntAsync(56)
(p2, p3) = f.result()
test(p2 == 56 and p3 == 56)
(p2, p3) = initial.opLong(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
(p2, p3) = initial.opLong(56)
test(p2 == 56 and p3 == 56)
f = initial.opLongAsync(56)
(p2, p3) = f.result()
test(p2 == 56 and p3 == 56)
(p2, p3) = initial.opFloat(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
(p2, p3) = initial.opFloat(1.0)
test(p2 == 1.0 and p3 == 1.0)
f = initial.opFloatAsync(1.0)
(p2, p3) = f.result()
test(p2 == 1.0 and p3 == 1.0)
(p2, p3) = initial.opDouble(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
(p2, p3) = initial.opDouble(1.0)
test(p2 == 1.0 and p3 == 1.0)
f = initial.opDoubleAsync(1.0)
(p2, p3) = f.result()
test(p2 == 1.0 and p3 == 1.0)
(p2, p3) = initial.opString(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
(p2, p3) = initial.opString("test")
test(p2 == "test" and p3 == "test")
f = initial.opStringAsync("test")
(p2, p3) = f.result()
test(p2 == "test" and p3 == "test")
(p2, p3) = initial.opMyEnum(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
(p2, p3) = initial.opMyEnum(Test.MyEnum.MyEnumMember)
test(p2 == Test.MyEnum.MyEnumMember and p3 == Test.MyEnum.MyEnumMember)
f = initial.opMyEnumAsync(Test.MyEnum.MyEnumMember)
(p2, p3) = f.result()
test(p2 == Test.MyEnum.MyEnumMember and p3 == Test.MyEnum.MyEnumMember)
(p2, p3) = initial.opSmallStruct(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
p1 = Test.SmallStruct(56)
(p2, p3) = initial.opSmallStruct(p1)
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opSmallStruct(None) # Test null struct
test(p2.m == 0 and p3.m == 0)
f = initial.opSmallStructAsync(p1)
(p2, p3) = f.result()
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opFixedStruct(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
p1 = Test.FixedStruct(56)
(p2, p3) = initial.opFixedStruct(p1)
test(p2 == p1 and p3 == p1)
f = initial.opFixedStructAsync(p1)
(p2, p3) = f.result()
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opVarStruct(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
p1 = Test.VarStruct("test")
(p2, p3) = initial.opVarStruct(p1)
test(p2 == p1 and p3 == p1)
f = initial.opVarStructAsync(p1)
(p2, p3) = f.result()
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opOneOptional(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
if initial.supportsNullOptional():
(p2, p3) = initial.opOneOptional(None)
test(p2 is None and p3 is None)
p1 = Test.OneOptional(58)
(p2, p3) = initial.opOneOptional(p1)
test(p2.a == p1.a and p3.a == p1.a)
f = initial.opOneOptionalAsync(p1)
(p2, p3) = f.result()
test(p2.a == p1.a and p3.a == p1.a)
(p2, p3) = initial.opOneOptionalProxy(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
p1 = communicator.stringToProxy("test")
(p2, p3) = initial.opOneOptionalProxy(p1)
test(p2 == p1 and p3 == p1)
f = initial.opOneOptionalProxyAsync(p1)
(p2, p3) = f.result()
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opByteSeq(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
p1 = [56 for x in range(100)]
(p2, p3) = initial.opByteSeq(p1)
test(len(p2) == len(p1) and len(p3) == len(p1))
if sys.version_info[0] == 2:
test(p2[0] == '\x38')
test(p3[0] == '\x38')
else:
test(p2[0] == 0x38)
test(p3[0] == 0x38)
f = initial.opByteSeqAsync(p1)
(p2, p3) = f.result()
test(len(p2) == len(p1) and len(p3) == len(p1))
if sys.version_info[0] == 2:
test(p2[0] == '\x38')
test(p3[0] == '\x38')
else:
test(p2[0] == 0x38)
test(p3[0] == 0x38)
(p2, p3) = initial.opBoolSeq(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
p1 = [True for x in range(100)]
(p2, p3) = initial.opBoolSeq(p1)
test(p2 == p1 and p3 == p1)
f = initial.opBoolSeqAsync(p1)
(p2, p3) = f.result()
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opShortSeq(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
p1 = [56 for x in range(100)]
(p2, p3) = initial.opShortSeq(p1)
test(p2 == p1 and p3 == p1)
f = initial.opShortSeqAsync(p1)
(p2, p3) = f.result()
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opIntSeq(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
p1 = [56 for x in range(100)]
(p2, p3) = initial.opIntSeq(p1)
test(p2 == p1 and p3 == p1)
f = initial.opIntSeqAsync(p1)
(p2, p3) = f.result()
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opLongSeq(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
p1 = [56 for x in range(100)]
(p2, p3) = initial.opLongSeq(p1)
test(p2 == p1 and p3 == p1)
f = initial.opLongSeqAsync(p1)
(p2, p3) = f.result()
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opFloatSeq(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
p1 = [1.0 for x in range(100)]
(p2, p3) = initial.opFloatSeq(p1)
test(p2 == p1 and p3 == p1)
f = initial.opFloatSeqAsync(p1)
(p2, p3) = f.result()
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opDoubleSeq(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
p1 = [1.0 for x in range(100)]
(p2, p3) = initial.opDoubleSeq(p1)
test(p2 == p1 and p3 == p1)
f = initial.opDoubleSeqAsync(p1)
(p2, p3) = f.result()
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opStringSeq(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
p1 = ["test1" for x in range(100)]
(p2, p3) = initial.opStringSeq(p1)
test(p2 == p1 and p3 == p1)
f = initial.opStringSeqAsync(p1)
(p2, p3) = f.result()
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opSmallStructSeq(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
p1 = [Test.SmallStruct(1) for x in range(10)]
(p2, p3) = initial.opSmallStructSeq(p1)
test(p2 == p1 and p3 == p1)
f = initial.opSmallStructSeqAsync(p1)
(p2, p3) = f.result()
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opSmallStructList(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
p1 = tuple([Test.SmallStruct(1) for x in range(10)])
(p2, p3) = initial.opSmallStructList(p1)
test(p2 == p1 and p3 == p1)
f = initial.opSmallStructListAsync(p1)
(p2, p3) = f.result()
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opFixedStructSeq(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
p1 = [Test.FixedStruct(1) for x in range(10)]
(p2, p3) = initial.opFixedStructSeq(p1)
test(p2 == p1 and p3 == p1)
f = initial.opFixedStructSeqAsync(p1)
(p2, p3) = f.result()
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opFixedStructList(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
p1 = tuple([Test.FixedStruct(1) for x in range(10)])
(p2, p3) = initial.opFixedStructList(p1)
test(p2 == p1 and p3 == p1)
f = initial.opFixedStructListAsync(p1)
(p2, p3) = f.result()
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opVarStructSeq(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
p1 = [Test.VarStruct("test") for x in range(10)]
(p2, p3) = initial.opVarStructSeq(p1)
test(p2 == p1 and p3 == p1)
f = initial.opVarStructSeqAsync(p1)
(p2, p3) = f.result()
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opIntIntDict(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
p1 = {1:2, 2:3}
(p2, p3) = initial.opIntIntDict(p1)
test(p2 == p1 and p3 == p1)
f = initial.opIntIntDictAsync(p1)
(p2, p3) = f.result()
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opStringIntDict(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
p1 = {"1":2, "2":3}
(p2, p3) = initial.opStringIntDict(p1)
test(p2 == p1 and p3 == p1)
f = initial.opStringIntDictAsync(p1)
(p2, p3) = f.result()
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opIntOneOptionalDict(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
p1 = {1:Test.OneOptional(58), 2:Test.OneOptional(59)}
(p2, p3) = initial.opIntOneOptionalDict(p1)
test(p2[1].a == 58 and p3[1].a == 58);
f = initial.opIntOneOptionalDictAsync(p1)
(p2, p3) = f.result()
test(p2[1].a == 58 and p3[1].a == 58);
print("ok")
sys.stdout.write("testing exception optionals... ")
sys.stdout.flush()
try:
initial.opOptionalException(Ice.Unset, Ice.Unset, Ice.Unset)
except Test.OptionalException as ex:
test(ex.a is Ice.Unset)
test(ex.b is Ice.Unset)
test(ex.o is Ice.Unset)
try:
initial.opOptionalException(30, "test", Test.OneOptional(53))
except Test.OptionalException as ex:
test(ex.a == 30)
test(ex.b == "test")
test(ex.o.a == 53)
try:
#
# Use the 1.0 encoding with an exception whose only class members are optional.
#
initial.ice_encodingVersion(Ice.Encoding_1_0).opOptionalException(30, "test", Test.OneOptional(53))
except Test.OptionalException as ex:
test(ex.a is Ice.Unset)
test(ex.b is Ice.Unset)
test(ex.o is Ice.Unset)
try:
initial.opDerivedException(Ice.Unset, Ice.Unset, Ice.Unset)
except Test.DerivedException as ex:
test(ex.a is Ice.Unset)
test(ex.b is Ice.Unset)
test(ex.o is Ice.Unset)
test(ex.ss is Ice.Unset)
test(ex.o2 is Ice.Unset)
try:
initial.opDerivedException(30, "test2", Test.OneOptional(53))
except Test.DerivedException as ex:
test(ex.a == 30)
test(ex.b == "test2")
test(ex.o.a == 53)
test(ex.ss == "test2")
test(ex.o2 == ex.o)
try:
initial.opRequiredException(Ice.Unset, Ice.Unset, Ice.Unset)
except Test.RequiredException as ex:
test(ex.a is Ice.Unset)
test(ex.b is Ice.Unset)
test(ex.o is Ice.Unset)
test(ex.ss == "test")
test(ex.o2 == None)
try:
initial.opRequiredException(30, "test2", Test.OneOptional(53))
except Test.RequiredException as ex:
test(ex.a == 30)
test(ex.b == "test2")
test(ex.o.a == 53)
test(ex.ss == "test2")
test(ex.o2 == ex.o)
print("ok")
sys.stdout.write("testing optionals with marshaled results... ")
sys.stdout.flush()
test(initial.opMStruct1() != Ice.Unset);
test(initial.opMDict1() != Ice.Unset);
test(initial.opMSeq1() != Ice.Unset);
test(initial.opMG1() != Ice.Unset);
(p3, p2) = initial.opMStruct2(Ice.Unset);
test(p2 == Ice.Unset and p3 == Ice.Unset);
p1 = Test.SmallStruct();
(p3, p2) = initial.opMStruct2(p1)
test(p2 == p1 and p3 == p1)
(p3, p2) = initial.opMSeq2(Ice.Unset)
test(p2 == Ice.Unset and p3 == Ice.Unset)
p1 = ["hello"]
(p3, p2) = initial.opMSeq2(p1);
test(p2[0] == "hello" and p3[0] == "hello")
(p3, p2) = initial.opMDict2(Ice.Unset)
test(p2 == Ice.Unset and p3 == Ice.Unset)
p1 = {"test" : 54}
(p3, p2) = initial.opMDict2(p1)
test(p2["test"] == 54 and p3["test"] == 54)
(p3, p2) = initial.opMG2(Ice.Unset)
test(p2 == Ice.Unset and p3 == Ice.Unset)
p1 = Test.G();
(p3, p2) = initial.opMG2(p1);
test(p2 != Ice.Unset and p3 != Ice.Unset and p3 == p2);
print("ok")
return initial
def throwUndeclaredB(self, a, b, current=None):
ex = Test.B()
ex.aMem = a
ex.bMem = b
raise ex
def allTests(communicator):
obj = communicator.stringToProxy("Test:default -p 12010")
t = Test.TestIntfPrx.checkedCast(obj)
sys.stdout.write("base as Object... ")
sys.stdout.flush()
o = None
try:
o = t.SBaseAsObject()
test(o)
test(o.ice_id() == "::Test::SBase")
except Ice.Exception:
test(False)
sb = o
test(isinstance(sb, Test.SBase))
test(sb)
test(sb.sb == "SBase.sb")
print("ok")
sys.stdout.write("base as Object (AMI)... ")
sys.stdout.flush()
cb = Callback()
t.begin_SBaseAsObject(cb.response_SBaseAsObject, cb.exception)
cb.check()
print("ok")
sys.stdout.write("base as base... ")
sys.stdout.flush()
try:
sb = t.SBaseAsSBase()
test(sb.sb == "SBase.sb")
except Ice.Exception:
test(False)
print("ok")
sys.stdout.write("base as base (AMI)... ")
sys.stdout.flush()
cb = Callback()
t.begin_SBaseAsSBase(cb.response_SBaseAsSBase, cb.exception)
cb.check()
print("ok")
sys.stdout.write("base with known derived as base... ")
sys.stdout.flush()
try:
sb = t.SBSKnownDerivedAsSBase()
test(sb.sb == "SBSKnownDerived.sb")
except Ice.Exception:
test(False)
sbskd = sb
test(isinstance(sbskd, Test.SBSKnownDerived))
test(sbskd)
test(sbskd.sbskd == "SBSKnownDerived.sbskd")
print("ok")
sys.stdout.write("base with known derived as base (AMI)... ")
sys.stdout.flush()
cb = Callback()
t.begin_SBSKnownDerivedAsSBase(cb.response_SBSKnownDerivedAsSBase,
cb.exception)
cb.check()
print("ok")
sys.stdout.write("base with known derived as known derived... ")
sys.stdout.flush()
try:
sbskd = t.SBSKnownDerivedAsSBSKnownDerived()
test(sbskd.sbskd == "SBSKnownDerived.sbskd")
except Ice.Exception:
test(False)
print("ok")
sys.stdout.write("base with known derived as known derived (AMI)... ")
sys.stdout.flush()
cb = Callback()
t.begin_SBSKnownDerivedAsSBSKnownDerived(
cb.response_SBSKnownDerivedAsSBSKnownDerived, cb.exception)
cb.check()
print("ok")
sys.stdout.write("base with unknown derived as base... ")
sys.stdout.flush()
try:
sb = t.SBSUnknownDerivedAsSBase()
test(sb.sb == "SBSUnknownDerived.sb")
except Ice.Exception:
test(False)
if t.ice_getEncodingVersion() == Ice.Encoding_1_0:
try:
#
# This test succeeds for the 1.0 encoding.
#
sb = t.SBSUnknownDerivedAsSBaseCompact()
test(sb.sb == "SBSUnknownDerived.sb")
except Ice.OperationNotExistException:
pass
except:
test(False)
else:
try:
#
# This test fails when using the compact format because the instance cannot
# be sliced to a known type.
#
sb = t.SBSUnknownDerivedAsSBaseCompact()
test(False)
except Ice.OperationNotExistException:
pass
except Ice.NoObjectFactoryException:
# Expected.
pass
except:
test(False)
print("ok")
sys.stdout.write("base with unknown derived as base (AMI)... ")
sys.stdout.flush()
cb = Callback()
t.begin_SBSUnknownDerivedAsSBase(cb.response_SBSUnknownDerivedAsSBase,
cb.exception)
cb.check()
if t.ice_getEncodingVersion() == Ice.Encoding_1_0:
#
# This test succeeds for the 1.0 encoding.
#
cb = Callback()
t.begin_SBSUnknownDerivedAsSBaseCompact(
cb.response_SBSUnknownDerivedAsSBase, cb.exception)
cb.check()
else:
#
# This test fails when using the compact format because the instance cannot
# be sliced to a known type.
#
cb = Callback()
t.begin_SBSUnknownDerivedAsSBaseCompact(
cb.response_SBSUnknownDerivedAsSBaseCompact,
cb.exception_SBSUnknownDerivedAsSBaseCompact)
cb.check()
print("ok")
sys.stdout.write("unknown with Object as Object... ")
sys.stdout.flush()
try:
o = t.SUnknownAsObject()
test(t.ice_getEncodingVersion() != Ice.Encoding_1_0)
test(isinstance(o, Ice.UnknownSlicedObject))
test(o.unknownTypeId == "::Test::SUnknown")
t.checkSUnknown(o)
except Ice.NoObjectFactoryException:
test(t.ice_getEncodingVersion() == Ice.Encoding_1_0)
except Ice.Exception:
test(False)
print("ok")
sys.stdout.write("unknown with Object as Object (AMI)... ")
sys.stdout.flush()
try:
cb = Callback()
if t.ice_getEncodingVersion() == Ice.Encoding_1_0:
t.begin_SUnknownAsObject(cb.response_SUnknownAsObject10,
cb.exception_SUnknownAsObject10)
else:
t.begin_SUnknownAsObject(cb.response_SUnknownAsObject11,
cb.exception_SUnknownAsObject11)
cb.check()
except Ice.Exception:
test(False)
print("ok")
sys.stdout.write("one-element cycle... ")
sys.stdout.flush()
try:
b = t.oneElementCycle()
test(b)
test(b.ice_id() == "::Test::B")
test(b.sb == "B1.sb")
test(b.pb == b)
except Ice.Exception:
test(False)
print("ok")
sys.stdout.write("one-element cycle (AMI)... ")
sys.stdout.flush()
cb = Callback()
t.begin_oneElementCycle(cb.response_oneElementCycle, cb.exception)
cb.check()
print("ok")
sys.stdout.write("two-element cycle... ")
sys.stdout.flush()
try:
b1 = t.twoElementCycle()
test(b1)
test(b1.ice_id() == "::Test::B")
test(b1.sb == "B1.sb")
b2 = b1.pb
test(b2)
test(b2.ice_id() == "::Test::B")
test(b2.sb == "B2.sb")
test(b2.pb == b1)
except Ice.Exception:
test(False)
print("ok")
sys.stdout.write("two-element cycle (AMI)... ")
sys.stdout.flush()
cb = Callback()
t.begin_twoElementCycle(cb.response_twoElementCycle, cb.exception)
cb.check()
print("ok")
sys.stdout.write("known derived pointer slicing as base... ")
sys.stdout.flush()
try:
b1 = t.D1AsB()
test(b1)
test(b1.ice_id() == "::Test::D1")
test(b1.sb == "D1.sb")
test(b1.pb)
test(b1.pb != b1)
d1 = b1
test(isinstance(d1, Test.D1))
test(d1.sd1 == "D1.sd1")
test(d1.pd1)
test(d1.pd1 != b1)
test(b1.pb == d1.pd1)
b2 = b1.pb
test(b2)
test(b2.pb == b1)
test(b2.sb == "D2.sb")
test(b2.ice_id() == "::Test::B")
except Ice.Exception:
test(False)
print("ok")
sys.stdout.write("known derived pointer slicing as base (AMI)... ")
sys.stdout.flush()
cb = Callback()
t.begin_D1AsB(cb.response_D1AsB, cb.exception)
cb.check()
print("ok")
sys.stdout.write("known derived pointer slicing as derived... ")
sys.stdout.flush()
try:
d1 = t.D1AsD1()
test(d1)
test(d1.ice_id() == "::Test::D1")
test(d1.sb == "D1.sb")
test(d1.pb)
test(d1.pb != d1)
b2 = d1.pb
test(b2)
test(b2.ice_id() == "::Test::B")
test(b2.sb == "D2.sb")
test(b2.pb == d1)
except Ice.Exception:
test(False)
print("ok")
sys.stdout.write("known derived pointer slicing as derived (AMI)... ")
sys.stdout.flush()
cb = Callback()
t.begin_D1AsD1(cb.response_D1AsD1, cb.exception)
cb.check()
print("ok")
sys.stdout.write("unknown derived pointer slicing as base... ")
sys.stdout.flush()
try:
b2 = t.D2AsB()
test(b2)
test(b2.ice_id() == "::Test::B")
test(b2.sb == "D2.sb")
test(b2.pb)
test(b2.pb != b2)
b1 = b2.pb
test(b1)
test(b1.ice_id() == "::Test::D1")
test(b1.sb == "D1.sb")
test(b1.pb == b2)
d1 = b1
test(isinstance(d1, Test.D1))
test(d1.sd1 == "D1.sd1")
test(d1.pd1 == b2)
except Ice.Exception:
test(False)
print("ok")
sys.stdout.write("unknown derived pointer slicing as base (AMI)... ")
sys.stdout.flush()
cb = Callback()
t.begin_D2AsB(cb.response_D2AsB, cb.exception)
cb.check()
print("ok")
sys.stdout.write("param ptr slicing with known first... ")
sys.stdout.flush()
try:
b1, b2 = t.paramTest1()
test(b1)
test(b1.ice_id() == "::Test::D1")
test(b1.sb == "D1.sb")
test(b1.pb == b2)
d1 = b1
test(isinstance(d1, Test.D1))
test(d1.sd1 == "D1.sd1")
test(d1.pd1 == b2)
test(b2)
test(b2.ice_id() == "::Test::B") # No factory, must be sliced
test(b2.sb == "D2.sb")
test(b2.pb == b1)
except Ice.Exception:
test(False)
print("ok")
sys.stdout.write("param ptr slicing with known first (AMI)... ")
sys.stdout.flush()
cb = Callback()
t.begin_paramTest1(cb.response_paramTest1, cb.exception)
cb.check()
print("ok")
sys.stdout.write("param ptr slicing with unknown first... ")
sys.stdout.flush()
try:
b2, b1 = t.paramTest2()
test(b1)
test(b1.ice_id() == "::Test::D1")
test(b1.sb == "D1.sb")
test(b1.pb == b2)
d1 = b1
test(isinstance(d1, Test.D1))
test(d1.sd1 == "D1.sd1")
test(d1.pd1 == b2)
test(b2)
test(b2.ice_id() == "::Test::B") # No factory, must be sliced
test(b2.sb == "D2.sb")
test(b2.pb == b1)
except Ice.Exception:
test(False)
print("ok")
sys.stdout.write("return value identity with known first... ")
sys.stdout.flush()
try:
r, p1, p2 = t.returnTest1()
test(r == p1)
except Ice.Exception:
test(False)
print("ok")
sys.stdout.write("return value identity with known first (AMI)... ")
sys.stdout.flush()
cb = Callback()
t.begin_returnTest1(cb.response_returnTest1, cb.exception)
cb.check()
print("ok")
sys.stdout.write("return value identity with unknown first... ")
sys.stdout.flush()
try:
r, p1, p2 = t.returnTest2()
test(r == p1)
except Ice.Exception:
test(False)
print("ok")
sys.stdout.write("return value identity with unknown first (AMI)... ")
sys.stdout.flush()
cb = Callback()
t.begin_returnTest2(cb.response_returnTest2, cb.exception)
cb.check()
print("ok")
sys.stdout.write("return value identity for input params known first... ")
sys.stdout.flush()
try:
d1 = Test.D1()
d1.sb = "D1.sb"
d1.sd1 = "D1.sd1"
d3 = Test.D3()
d3.pb = d1
d3.sb = "D3.sb"
d3.sd3 = "D3.sd3"
d3.pd3 = d1
d1.pb = d3
d1.pd1 = d3
b1 = t.returnTest3(d1, d3)
test(b1)
test(b1.sb == "D1.sb")
test(b1.ice_id() == "::Test::D1")
p1 = b1
test(isinstance(p1, Test.D1))
test(p1.sd1 == "D1.sd1")
test(p1.pd1 == b1.pb)
b2 = b1.pb
test(b2)
test(b2.sb == "D3.sb")
test(b2.ice_id() == "::Test::B") # Sliced by server
test(b2.pb == b1)
p3 = b2
test(not isinstance(p3, Test.D3))
test(b1 != d1)
test(b1 != d3)
test(b2 != d1)
test(b2 != d3)
except Ice.Exception:
test(False)
print("ok")
sys.stdout.write(
"return value identity for input params known first (AMI)... ")
sys.stdout.flush()
try:
d1 = Test.D1()
d1.sb = "D1.sb"
d1.sd1 = "D1.sd1"
d3 = Test.D3()
d3.pb = d1
d3.sb = "D3.sb"
d3.sd3 = "D3.sd3"
d3.pd3 = d1
d1.pb = d3
d1.pd1 = d3
cb = Callback()
t.begin_returnTest3(d1, d3, cb.response_returnTest3, cb.exception)
cb.check()
b1 = cb.r
test(b1)
test(b1.sb == "D1.sb")
test(b1.ice_id() == "::Test::D1")
p1 = b1
test(isinstance(p1, Test.D1))
test(p1.sd1 == "D1.sd1")
test(p1.pd1 == b1.pb)
b2 = b1.pb
test(b2)
test(b2.sb == "D3.sb")
test(b2.ice_id() == "::Test::B") # Sliced by server
test(b2.pb == b1)
p3 = b2
test(not isinstance(p3, Test.D3))
test(b1 != d1)
test(b1 != d3)
test(b2 != d1)
test(b2 != d3)
except Ice.Exception:
test(False)
print("ok")
sys.stdout.write(
"return value identity for input params unknown first... ")
sys.stdout.flush()
try:
d1 = Test.D1()
d1.sb = "D1.sb"
d1.sd1 = "D1.sd1"
d3 = Test.D3()
d3.pb = d1
d3.sb = "D3.sb"
d3.sd3 = "D3.sd3"
d3.pd3 = d1
d1.pb = d3
d1.pd1 = d3
b1 = t.returnTest3(d3, d1)
test(b1)
test(b1.sb == "D3.sb")
test(b1.ice_id() == "::Test::B") # Sliced by server
p1 = b1
test(not isinstance(p1, Test.D3))
b2 = b1.pb
test(b2)
test(b2.sb == "D1.sb")
test(b2.ice_id() == "::Test::D1")
test(b2.pb == b1)
p3 = b2
test(isinstance(p3, Test.D1))
test(p3.sd1 == "D1.sd1")
test(p3.pd1 == b1)
test(b1 != d1)
test(b1 != d3)
test(b2 != d1)
test(b2 != d3)
except Ice.Exception:
test(False)
print("ok")
sys.stdout.write(
"return value identity for input params unknown first (AMI)... ")
sys.stdout.flush()
try:
d1 = Test.D1()
d1.sb = "D1.sb"
d1.sd1 = "D1.sd1"
d3 = Test.D3()
d3.pb = d1
d3.sb = "D3.sb"
d3.sd3 = "D3.sd3"
d3.pd3 = d1
d1.pb = d3
d1.pd1 = d3
cb = Callback()
t.begin_returnTest3(d3, d1, cb.response_returnTest3, cb.exception)
cb.check()
b1 = cb.r
test(b1)
test(b1.sb == "D3.sb")
test(b1.ice_id() == "::Test::B") # Sliced by server
p1 = b1
test(not isinstance(p1, Test.D3))
b2 = b1.pb
test(b2)
test(b2.sb == "D1.sb")
test(b2.ice_id() == "::Test::D1")
test(b2.pb == b1)
p3 = b2
test(isinstance(p3, Test.D1))
test(p3.sd1 == "D1.sd1")
test(p3.pd1 == b1)
test(b1 != d1)
test(b1 != d3)
test(b2 != d1)
test(b2 != d3)
except Ice.Exception:
test(False)
print("ok")
sys.stdout.write("remainder unmarshaling (3 instances)... ")
sys.stdout.flush()
try:
ret, p1, p2 = t.paramTest3()
test(p1)
test(p1.sb == "D2.sb (p1 1)")
test(p1.pb == None)
test(p1.ice_id() == "::Test::B")
test(p2)
test(p2.sb == "D2.sb (p2 1)")
test(p2.pb == None)
test(p2.ice_id() == "::Test::B")
test(ret)
test(ret.sb == "D1.sb (p2 2)")
test(ret.pb == None)
test(ret.ice_id() == "::Test::D1")
except Ice.Exception:
test(False)
print("ok")
sys.stdout.write("remainder unmarshaling (3 instances) (AMI)... ")
sys.stdout.flush()
cb = Callback()
t.begin_paramTest3(cb.response_paramTest3, cb.exception)
cb.check()
print("ok")
sys.stdout.write("remainder unmarshaling (4 instances)... ")
sys.stdout.flush()
try:
ret, b = t.paramTest4()
test(b)
test(b.sb == "D4.sb (1)")
test(b.pb == None)
test(b.ice_id() == "::Test::B")
test(ret)
test(ret.sb == "B.sb (2)")
test(ret.pb == None)
test(ret.ice_id() == "::Test::B")
except Ice.Exception:
test(False)
print("ok")
sys.stdout.write("remainder unmarshaling (4 instances) (AMI)... ")
sys.stdout.flush()
cb = Callback()
t.begin_paramTest4(cb.response_paramTest4, cb.exception)
cb.check()
print("ok")
sys.stdout.write(
"param ptr slicing, instance marshaled in unknown derived as base... ")
sys.stdout.flush()
try:
b1 = Test.B()
b1.sb = "B.sb(1)"
b1.pb = b1
d3 = Test.D3()
d3.sb = "D3.sb"
d3.pb = d3
d3.sd3 = "D3.sd3"
d3.pd3 = b1
b2 = Test.B()
b2.sb = "B.sb(2)"
b2.pb = b1
r = t.returnTest3(d3, b2)
test(r)
test(r.ice_id() == "::Test::B")
test(r.sb == "D3.sb")
test(r.pb == r)
except Ice.Exception:
test(False)
print("ok")
sys.stdout.write(
"param ptr slicing, instance marshaled in unknown derived as base (AMI)... "
)
sys.stdout.flush()
try:
b1 = Test.B()
b1.sb = "B.sb(1)"
b1.pb = b1
d3 = Test.D3()
d3.sb = "D3.sb"
d3.pb = d3
d3.sd3 = "D3.sd3"
d3.pd3 = b1
b2 = Test.B()
b2.sb = "B.sb(2)"
b2.pb = b1
cb = Callback()
t.begin_returnTest3(d3, b2, cb.response_returnTest3, cb.exception)
cb.check()
r = cb.r
test(r)
test(r.ice_id() == "::Test::B")
test(r.sb == "D3.sb")
test(r.pb == r)
except Ice.Exception:
test(False)
print("ok")
sys.stdout.write(
"param ptr slicing, instance marshaled in unknown derived as derived... "
)
sys.stdout.flush()
try:
d11 = Test.D1()
d11.sb = "D1.sb(1)"
d11.pb = d11
d11.sd1 = "D1.sd1(1)"
d11.pd1 = None
d3 = Test.D3()
d3.sb = "D3.sb"
d3.pb = d3
d3.sd3 = "D3.sd3"
d3.pd3 = d11
d12 = Test.D1()
d12.sb = "D1.sb(2)"
d12.pb = d12
d12.sd1 = "D1.sd1(2)"
d12.pd1 = d11
r = t.returnTest3(d3, d12)
test(r)
test(r.ice_id() == "::Test::B")
test(r.sb == "D3.sb")
test(r.pb == r)
except Ice.Exception:
test(False)
print("ok")
sys.stdout.write(
"param ptr slicing, instance marshaled in unknown derived as derived (AMI)... "
)
sys.stdout.flush()
try:
d11 = Test.D1()
d11.sb = "D1.sb(1)"
d11.pb = d11
d11.sd1 = "D1.sd1(1)"
d11.pd1 = None
d3 = Test.D3()
d3.sb = "D3.sb"
d3.pb = d3
d3.sd3 = "D3.sd3"
d3.pd3 = d11
d12 = Test.D1()
d12.sb = "D1.sb(2)"
d12.pb = d12
d12.sd1 = "D1.sd1(2)"
d12.pd1 = d11
cb = Callback()
t.begin_returnTest3(d3, d12, cb.response_returnTest3, cb.exception)
cb.check()
r = cb.r
test(r)
test(r.ice_id() == "::Test::B")
test(r.sb == "D3.sb")
test(r.pb == r)
except Ice.Exception:
test(False)
print("ok")
sys.stdout.write("sequence slicing... ")
sys.stdout.flush()
try:
ss = Test.SS3()
ss1b = Test.B()
ss1b.sb = "B.sb"
ss1b.pb = ss1b
ss1d1 = Test.D1()
ss1d1.sb = "D1.sb"
ss1d1.sd1 = "D1.sd1"
ss1d1.pb = ss1b
ss1d3 = Test.D3()
ss1d3.sb = "D3.sb"
ss1d3.sd3 = "D3.sd3"
ss1d3.pb = ss1b
ss2b = Test.B()
ss2b.sb = "B.sb"
ss2b.pb = ss1b
ss2d1 = Test.D1()
ss2d1.sb = "D1.sb"
ss2d1.sd1 = "D1.sd1"
ss2d1.pb = ss2b
ss2d3 = Test.D3()
ss2d3.sb = "D3.sb"
ss2d3.sd3 = "D3.sd3"
ss2d3.pb = ss2b
ss1d1.pd1 = ss2b
ss1d3.pd3 = ss2d1
ss2d1.pd1 = ss1d3
ss2d3.pd3 = ss1d1
ss1 = Test.SS1()
ss1.s = (ss1b, ss1d1, ss1d3)
ss2 = Test.SS2()
ss2.s = (ss2b, ss2d1, ss2d3)
ss = t.sequenceTest(ss1, ss2)
test(ss.c1)
ss1b = ss.c1.s[0]
ss1d1 = ss.c1.s[1]
test(ss.c2)
ss1d3 = ss.c1.s[2]
test(ss.c2)
ss2b = ss.c2.s[0]
ss2d1 = ss.c2.s[1]
ss2d3 = ss.c2.s[2]
test(ss1b.pb == ss1b)
test(ss1d1.pb == ss1b)
test(ss1d3.pb == ss1b)
test(ss2b.pb == ss1b)
test(ss2d1.pb == ss2b)
test(ss2d3.pb == ss2b)
test(ss1b.ice_id() == "::Test::B")
test(ss1d1.ice_id() == "::Test::D1")
test(ss1d3.ice_id() == "::Test::B")
test(ss2b.ice_id() == "::Test::B")
test(ss2d1.ice_id() == "::Test::D1")
test(ss2d3.ice_id() == "::Test::B")
except Ice.Exception:
test(False)
print("ok")
sys.stdout.write("sequence slicing (AMI)... ")
sys.stdout.flush()
try:
ss = Test.SS3()
ss1b = Test.B()
ss1b.sb = "B.sb"
ss1b.pb = ss1b
ss1d1 = Test.D1()
ss1d1.sb = "D1.sb"
ss1d1.sd1 = "D1.sd1"
ss1d1.pb = ss1b
ss1d3 = Test.D3()
ss1d3.sb = "D3.sb"
ss1d3.sd3 = "D3.sd3"
ss1d3.pb = ss1b
ss2b = Test.B()
ss2b.sb = "B.sb"
ss2b.pb = ss1b
ss2d1 = Test.D1()
ss2d1.sb = "D1.sb"
ss2d1.sd1 = "D1.sd1"
ss2d1.pb = ss2b
ss2d3 = Test.D3()
ss2d3.sb = "D3.sb"
ss2d3.sd3 = "D3.sd3"
ss2d3.pb = ss2b
ss1d1.pd1 = ss2b
ss1d3.pd3 = ss2d1
ss2d1.pd1 = ss1d3
ss2d3.pd3 = ss1d1
ss1 = Test.SS1()
ss1.s = (ss1b, ss1d1, ss1d3)
ss2 = Test.SS2()
ss2.s = (ss2b, ss2d1, ss2d3)
cb = Callback()
t.begin_sequenceTest(ss1, ss2, cb.response_sequenceTest, cb.exception)
cb.check()
ss = cb.r
test(ss.c1)
ss1b = ss.c1.s[0]
ss1d1 = ss.c1.s[1]
test(ss.c2)
ss1d3 = ss.c1.s[2]
test(ss.c2)
ss2b = ss.c2.s[0]
ss2d1 = ss.c2.s[1]
ss2d3 = ss.c2.s[2]
test(ss1b.pb == ss1b)
test(ss1d1.pb == ss1b)
test(ss1d3.pb == ss1b)
test(ss2b.pb == ss1b)
test(ss2d1.pb == ss2b)
test(ss2d3.pb == ss2b)
test(ss1b.ice_id() == "::Test::B")
test(ss1d1.ice_id() == "::Test::D1")
test(ss1d3.ice_id() == "::Test::B")
test(ss2b.ice_id() == "::Test::B")
test(ss2d1.ice_id() == "::Test::D1")
test(ss2d3.ice_id() == "::Test::B")
except Ice.Exception:
test(False)
print("ok")
sys.stdout.write("dictionary slicing... ")
sys.stdout.flush()
try:
bin = {}
for i in range(0, 10):
d1 = Test.D1()
s = "D1." + str(i)
d1.sb = s
d1.pb = d1
d1.sd1 = s
d1.pd1 = None
bin[i] = d1
r, bout = t.dictionaryTest(bin)
test(len(bout) == 10)
for i in range(0, 10):
b = bout[i * 10]
test(b)
s = "D1." + str(i)
test(b.sb == s)
test(b.pb)
test(b.pb != b)
test(b.pb.sb == s)
test(b.pb.pb == b.pb)
test(len(r) == 10)
for i in range(0, 10):
b = r[i * 20]
test(b)
s = "D1." + str(i * 20)
test(b.sb == s)
if i == 0:
test(b.pb == None)
else:
test(b.pb == r[(i - 1) * 20])
d1 = b
test(isinstance(d1, Test.D1))
test(d1.sd1 == s)
test(d1.pd1 == d1)
except Ice.Exception:
test(False)
print("ok")
sys.stdout.write("dictionary slicing (AMI)... ")
sys.stdout.flush()
try:
bin = {}
for i in range(0, 10):
d1 = Test.D1()
s = "D1." + str(i)
d1.sb = s
d1.pb = d1
d1.sd1 = s
d1.pd1 = None
bin[i] = d1
cb = Callback()
t.begin_dictionaryTest(bin, cb.response_dictionaryTest, cb.exception)
cb.check()
bout = cb.bout
r = cb.r
test(len(bout) == 10)
for i in range(0, 10):
b = bout[i * 10]
test(b)
s = "D1." + str(i)
test(b.sb == s)
test(b.pb)
test(b.pb != b)
test(b.pb.sb == s)
test(b.pb.pb == b.pb)
test(len(r) == 10)
for i in range(0, 10):
b = r[i * 20]
test(b)
s = "D1." + str(i * 20)
test(b.sb == s)
if i == 0:
test(b.pb == None)
else:
test(b.pb == r[(i - 1) * 20])
d1 = b
test(isinstance(d1, Test.D1))
test(d1.sd1 == s)
test(d1.pd1 == d1)
except Ice.Exception:
test(False)
print("ok")
sys.stdout.write("base exception thrown as base exception... ")
sys.stdout.flush()
try:
t.throwBaseAsBase()
test(False)
except Test.BaseException as e:
test(e.ice_name() == "Test::BaseException")
test(e.sbe == "sbe")
test(e.pb)
test(e.pb.sb == "sb")
test(e.pb.pb == e.pb)
except Ice.Exception:
test(False)
print("ok")
sys.stdout.write("base exception thrown as base exception (AMI)... ")
sys.stdout.flush()
cb = Callback()
t.begin_throwBaseAsBase(cb.response, cb.exception_throwBaseAsBase)
cb.check()
print("ok")
sys.stdout.write("derived exception thrown as base exception... ")
sys.stdout.flush()
try:
t.throwDerivedAsBase()
test(False)
except Test.DerivedException as e:
test(e.ice_name() == "Test::DerivedException")
test(e.sbe == "sbe")
test(e.pb)
test(e.pb.sb == "sb1")
test(e.pb.pb == e.pb)
test(e.sde == "sde1")
test(e.pd1)
test(e.pd1.sb == "sb2")
test(e.pd1.pb == e.pd1)
test(e.pd1.sd1 == "sd2")
test(e.pd1.pd1 == e.pd1)
except Ice.Exception:
test(False)
print("ok")
sys.stdout.write("derived exception thrown as base exception (AMI)... ")
sys.stdout.flush()
cb = Callback()
t.begin_throwDerivedAsBase(cb.response, cb.exception_throwDerivedAsBase)
cb.check()
print("ok")
sys.stdout.write("derived exception thrown as derived exception... ")
sys.stdout.flush()
try:
t.throwDerivedAsDerived()
test(False)
except Test.DerivedException as e:
test(e.ice_name() == "Test::DerivedException")
test(e.sbe == "sbe")
test(e.pb)
test(e.pb.sb == "sb1")
test(e.pb.pb == e.pb)
test(e.sde == "sde1")
test(e.pd1)
test(e.pd1.sb == "sb2")
test(e.pd1.pb == e.pd1)
test(e.pd1.sd1 == "sd2")
test(e.pd1.pd1 == e.pd1)
except Ice.Exception:
test(False)
print("ok")
sys.stdout.write("derived exception thrown as derived exception (AMI)... ")
sys.stdout.flush()
cb = Callback()
t.begin_throwDerivedAsDerived(cb.response,
cb.exception_throwDerivedAsDerived)
cb.check()
print("ok")
sys.stdout.write("unknown derived exception thrown as base exception... ")
sys.stdout.flush()
try:
t.throwUnknownDerivedAsBase()
test(False)
except Test.BaseException as e:
test(e.ice_name() == "Test::BaseException")
test(e.sbe == "sbe")
test(e.pb)
test(e.pb.sb == "sb d2")
test(e.pb.pb == e.pb)
except Ice.Exception:
test(False)
print("ok")
sys.stdout.write(
"unknown derived exception thrown as base exception (AMI)... ")
sys.stdout.flush()
cb = Callback()
t.begin_throwUnknownDerivedAsBase(cb.response,
cb.exception_throwUnknownDerivedAsBase)
cb.check()
print("ok")
sys.stdout.write("forward-declared class... ")
sys.stdout.flush()
try:
f = t.useForward()
test(f)
except Ice.Exception:
test(False)
print("ok")
sys.stdout.write("forward-declared class (AMI)... ")
sys.stdout.flush()
cb = Callback()
t.begin_useForward(cb.response_useForward, cb.exception)
cb.check()
print("ok")
sys.stdout.write("preserved classes... ")
sys.stdout.flush()
try:
#
# Server knows the most-derived class PDerived.
#
pd = Test.PDerived()
pd.pi = 3
pd.ps = "preserved"
pd.pb = pd
r = t.exchangePBase(pd)
test(isinstance(r, Test.PDerived))
test(r.pi == 3)
test(r.ps == "preserved")
test(r.pb == r)
#
# Server only knows the base (non-preserved) type, so the object is sliced.
#
pu = Test.PCUnknown()
pu.pi = 3
pu.pu = "preserved"
r = t.exchangePBase(pu)
test(not isinstance(r, Test.PCUnknown))
test(r.pi == 3)
#
# Server only knows the intermediate type Preserved. The object will be sliced to
# Preserved for the 1.0 encoding; otherwise it should be returned intact.
#
pcd = Test.PCDerived()
pcd.pi = 3
pcd.pbs = [pcd]
r = t.exchangePBase(pcd)
if t.ice_getEncodingVersion() == Ice.Encoding_1_0:
test(not isinstance(r, Test.PCDerived))
test(r.pi == 3)
else:
test(isinstance(r, Test.PCDerived))
test(r.pi == 3)
test(r.pbs[0] == r)
#
# Server only knows the intermediate type CompactPDerived. The object will be sliced to
# CompactPDerived for the 1.0 encoding; otherwise it should be returned intact.
#
pcd = Test.CompactPCDerived()
pcd.pi = 3
pcd.pbs = [pcd]
r = t.exchangePBase(pcd)
if t.ice_getEncodingVersion() == Ice.Encoding_1_0:
test(not isinstance(r, Test.CompactPCDerived))
test(r.pi == 3)
else:
test(isinstance(r, Test.CompactPCDerived))
test(r.pi == 3)
test(r.pbs[0] == r)
#
# Send an object that will have multiple preserved slices in the server.
# The object will be sliced to Preserved for the 1.0 encoding.
#
pcd = Test.PCDerived3()
pcd.pi = 3
#
# Sending more than 254 objects exercises the encoding for object ids.
#
pcd.pbs = []
for i in range(0, 300):
p2 = Test.PCDerived2()
p2.pi = i
p2.pbs = [
None
] # Nil reference. This slice should not have an indirection table.
p2.pcd2 = i
pcd.pbs.append(p2)
pcd.pcd2 = pcd.pi
pcd.pcd3 = pcd.pbs[10]
r = t.exchangePBase(pcd)
if t.ice_getEncodingVersion() == Ice.Encoding_1_0:
test(not isinstance(r, Test.PCDerived3))
test(isinstance(r, Test.Preserved))
test(r.pi == 3)
else:
test(isinstance(r, Test.PCDerived3))
test(r.pi == 3)
for i in range(0, 300):
p2 = r.pbs[i]
test(isinstance(p2, Test.PCDerived2))
test(p2.pi == i)
test(len(p2.pbs) == 1)
test(not p2.pbs[0])
test(p2.pcd2 == i)
test(r.pcd2 == r.pi)
test(r.pcd3 == r.pbs[10])
#
# Obtain an object with preserved slices and send it back to the server.
# The preserved slices should be excluded for the 1.0 encoding, otherwise
# they should be included.
#
p = t.PBSUnknownAsPreserved()
t.checkPBSUnknown(p)
if t.ice_getEncodingVersion() != Ice.Encoding_1_0:
t.ice_encodingVersion(Ice.Encoding_1_0).checkPBSUnknown(p)
except Ice.OperationNotExistException:
pass
print("ok")
sys.stdout.write("preserved classes (AMI)... ")
sys.stdout.flush()
#
# Server knows the most-derived class PDerived.
#
pd = Test.PDerived()
pd.pi = 3
pd.ps = "preserved"
pd.pb = pd
cb = Callback()
t.begin_exchangePBase(pd, cb.response_preserved1, cb.exception)
cb.check()
#
# Server only knows the base (non-preserved) type, so the object is sliced.
#
pu = Test.PCUnknown()
pu.pi = 3
pu.pu = "preserved"
cb = Callback()
t.begin_exchangePBase(pu, cb.response_preserved2, cb.exception)
cb.check()
#
# Server only knows the intermediate type Preserved. The object will be sliced to
# Preserved for the 1.0 encoding; otherwise it should be returned intact.
#
pcd = Test.PCDerived()
pcd.pi = 3
pcd.pbs = [pcd]
cb = Callback()
if t.ice_getEncodingVersion() == Ice.Encoding_1_0:
t.begin_exchangePBase(pcd, cb.response_preserved3, cb.exception)
else:
t.begin_exchangePBase(pcd, cb.response_preserved4, cb.exception)
cb.check()
#
# Server only knows the intermediate type CompactPDerived. The object will be sliced to
# CompactPDerived for the 1.0 encoding; otherwise it should be returned intact.
#
pcd = Test.CompactPCDerived()
pcd.pi = 3
pcd.pbs = [pcd]
cb = Callback()
if t.ice_getEncodingVersion() == Ice.Encoding_1_0:
t.begin_exchangePBase(pcd, cb.response_compactPreserved1, cb.exception)
else:
t.begin_exchangePBase(pcd, cb.response_compactPreserved2, cb.exception)
cb.check()
#
# Send an object that will have multiple preserved slices in the server.
# The object will be sliced to Preserved for the 1.0 encoding.
#
pcd = Test.PCDerived3()
pcd.pi = 3
#
# Sending more than 254 objects exercises the encoding for object ids.
#
pcd.pbs = []
for i in range(0, 300):
p2 = Test.PCDerived2()
p2.pi = i
p2.pbs = [
None
] # Nil reference. This slice should not have an indirection table.
p2.pcd2 = i
pcd.pbs.append(p2)
pcd.pcd2 = pcd.pi
pcd.pcd3 = pcd.pbs[10]
cb = Callback()
if t.ice_getEncodingVersion() == Ice.Encoding_1_0:
t.begin_exchangePBase(pcd, cb.response_preserved3, cb.exception)
else:
t.begin_exchangePBase(pcd, cb.response_preserved5, cb.exception)
cb.check()
print("ok")
sys.stdout.write("garbage collection of preserved classes... ")
sys.stdout.flush()
try:
#
# Register a factory in order to substitute our own subclass of
# UCNode. This provides an easy way to determine how many
# unmarshaled instances currently exist.
#
communicator.addObjectFactory(NodeFactoryI(),
Test.PNode.ice_staticId())
#
# Relay a graph through the server. This test uses a preserved class
# with a class member.
#
c = Test.PNode()
c.next = Test.PNode()
c.next.next = Test.PNode()
c.next.next.next = c # Create a cyclic graph.
test(PNodeI.counter == 0)
n = t.exchangePNode(c)
test(PNodeI.counter == 3)
test(n.next != None)
test(n.next != n.next.next)
test(n.next.next != n.next.next.next)
test(n.next.next.next == n)
n = None # Release reference.
if sys.version_info[0] == 3 and sys.version_info[1] >= 4:
#
# In Python 3.4, objects with a __del__ method can still be collected.
#
gc.collect()
test(PNodeI.counter == 0)
else:
#
# The PNodeI class declares a __del__ method, which means the Python
# garbage collector will NOT collect a cycle of PNodeI objects.
#
gc.collect() # No effect.
test(PNodeI.counter == 3)
#
# The uncollectable objects are stored in gc.garbage. We have to
# manually break the cycle and then remove the objects from the
# gc.garbage list.
#
test(len(gc.garbage) > 0)
for o in gc.garbage:
if isinstance(o, PNodeI):
o.next = None
o = None # Remove last reference.
del gc.garbage[:]
test(PNodeI.counter == 0)
#
# Obtain a preserved object from the server where the most-derived
# type is unknown. The preserved slice refers to a graph of PNode
# objects.
#
test(PNodeI.counter == 0)
p = t.PBSUnknownAsPreservedWithGraph()
test(p)
test(PNodeI.counter == 3)
t.checkPBSUnknownWithGraph(p)
p = None # Release reference.
if sys.version_info[0] == 3 and sys.version_info[1] >= 4:
#
# In Python 3.4, objects with a __del__ method can still be collected.
#
gc.collect()
test(PNodeI.counter == 0)
else:
#
# The PNodeI class declares a __del__ method, which means the Python
# garbage collector will NOT collect a cycle of PNodeI objects.
#
gc.collect() # No effect.
test(PNodeI.counter == 3)
#
# The uncollectable objects are stored in gc.garbage. We have to
# manually break the cycle and then remove the objects from the
# gc.garbage list.
#
test(len(gc.garbage) > 0)
for o in gc.garbage:
if isinstance(o, PNodeI):
o.next = None
o = None # Remove last reference.
del gc.garbage[:]
test(PNodeI.counter == 0)
#
# Register a factory in order to substitute our own subclass of
# Preserved. This provides an easy way to determine how many
# unmarshaled instances currently exist.
#
communicator.addObjectFactory(PreservedFactoryI(),
Test.Preserved.ice_staticId())
#
# Obtain a preserved object from the server where the most-derived
# type is unknown. A data member in the preserved slice refers to the
# outer object, so the chain of references looks like this:
#
# outer->slicedData->outer
#
test(PreservedI.counter == 0)
p = t.PBSUnknown2AsPreservedWithGraph()
test(p != None)
test(PreservedI.counter == 1)
t.checkPBSUnknown2WithGraph(p)
p._ice_slicedData = None # Break the cycle.
p = None # Release reference.
test(PreservedI.counter == 0)
#
# Throw a preserved exception where the most-derived type is unknown.
# The preserved exception slice contains a class data member. This
# object is also preserved, and its most-derived type is also unknown.
# The preserved slice of the object contains a class data member that
# refers to itself.
#
# The chain of references looks like this:
#
# ex->slicedData->obj->slicedData->obj
#
try:
test(PreservedI.counter == 0)
try:
t.throwPreservedException()
except Test.PreservedException as ex:
#
# The class instance is only retained when the encoding is > 1.0.
#
if t.ice_getEncodingVersion() != Ice.Encoding_1_0:
test(PreservedI.counter == 1)
gc.collect() # No effect.
test(PreservedI.counter == 1)
ex._ice_slicedData = None # Break the cycle.
#
# Exception has gone out of scope.
#
if t.ice_getEncodingVersion() != Ice.Encoding_1_0:
gc.collect()
if sys.version_info[0] == 3 and sys.version_info[1] >= 4:
#
# In Python 3.4, objects with a __del__ method can still be collected.
#
test(len(gc.garbage) == 0)
else:
test(len(gc.garbage) > 0)
for o in gc.garbage:
if isinstance(o, PreservedI):
o._ice_slicedData = None
o = None # Remove last reference.
del gc.garbage[:]
test(PreservedI.counter == 0)
except Ice.Exception:
test(False)
except Ice.OperationNotExistException:
pass
print("ok")
return t
def allTests(helper, communicator):
sys.stdout.write("testing stringToProxy... ")
sys.stdout.flush()
ref = "initial:{0}".format(helper.getTestEndpoint())
base = communicator.stringToProxy(ref)
test(base)
print("ok")
sys.stdout.write("testing checked cast... ")
sys.stdout.flush()
initial = Test.InitialPrx.checkedCast(base)
test(initial)
test(initial == base)
print("ok")
sys.stdout.write("testing optional data members... ")
sys.stdout.flush()
oo1 = Test.OneOptional()
test(oo1.a is Ice.Unset)
oo1.a = 15
oo2 = Test.OneOptional(16)
test(oo2.a == 16)
mo1 = Test.MultiOptional()
test(mo1.a is Ice.Unset)
test(mo1.b is Ice.Unset)
test(mo1.c is Ice.Unset)
test(mo1.d is Ice.Unset)
test(mo1.e is Ice.Unset)
test(mo1.f is Ice.Unset)
test(mo1.g is Ice.Unset)
test(mo1.h is Ice.Unset)
test(mo1.i is Ice.Unset)
test(mo1.bs is Ice.Unset)
test(mo1.ss is Ice.Unset)
test(mo1.iid is Ice.Unset)
test(mo1.sid is Ice.Unset)
test(mo1.fs is Ice.Unset)
test(mo1.vs is Ice.Unset)
test(mo1.shs is Ice.Unset)
test(mo1.es is Ice.Unset)
test(mo1.fss is Ice.Unset)
test(mo1.vss is Ice.Unset)
test(mo1.oops is Ice.Unset)
test(mo1.ied is Ice.Unset)
test(mo1.ifsd is Ice.Unset)
test(mo1.ivsd is Ice.Unset)
test(mo1.bos is Ice.Unset)
ss = Test.SmallStruct()
fs = Test.FixedStruct(78)
vs = Test.VarStruct("hello")
mo1 = Test.MultiOptional(15, True, 19, 78, 99, 5.5, 1.0, "test", Test.MyEnum.MyEnumMember, \
[5], ["test", "test2"], {4:3}, {"test":10}, fs, vs, [1], \
[Test.MyEnum.MyEnumMember, Test.MyEnum.MyEnumMember], \
[ fs ], [ vs ], \
{4:Test.MyEnum.MyEnumMember}, {4:fs}, {5:vs}, \
[False, True, False])
test(mo1.a == 15)
test(mo1.b == True)
test(mo1.c == 19)
test(mo1.d == 78)
test(mo1.e == 99)
test(mo1.f == 5.5)
test(mo1.g == 1.0)
test(mo1.h == "test")
test(mo1.i == Test.MyEnum.MyEnumMember)
test(mo1.bs == [5])
test(mo1.ss == ["test", "test2"])
test(mo1.iid[4] == 3)
test(mo1.sid["test"] == 10)
test(mo1.fs == Test.FixedStruct(78))
test(mo1.vs == Test.VarStruct("hello"))
test(mo1.shs[0] == 1)
test(mo1.es[0] == Test.MyEnum.MyEnumMember
and mo1.es[1] == Test.MyEnum.MyEnumMember)
test(mo1.fss[0] == Test.FixedStruct(78))
test(mo1.vss[0] == Test.VarStruct("hello"))
test(mo1.ied[4] == Test.MyEnum.MyEnumMember)
test(mo1.ifsd[4] == Test.FixedStruct(78))
test(mo1.ivsd[5] == Test.VarStruct("hello"))
test(mo1.bos == [False, True, False])
#
# Test generated struct and classes compare with Ice.Unset
#
test(ss != Ice.Unset)
test(fs != Ice.Unset)
test(vs != Ice.Unset)
test(mo1 != Ice.Unset)
print("ok")
sys.stdout.write("testing marshaling... ")
sys.stdout.flush()
oo4 = initial.pingPong(Test.OneOptional())
test(oo4.a is Ice.Unset)
oo5 = initial.pingPong(oo1)
test(oo1.a == oo5.a)
mo4 = initial.pingPong(Test.MultiOptional())
test(mo4.a is Ice.Unset)
test(mo4.b is Ice.Unset)
test(mo4.c is Ice.Unset)
test(mo4.d is Ice.Unset)
test(mo4.e is Ice.Unset)
test(mo4.f is Ice.Unset)
test(mo4.g is Ice.Unset)
test(mo4.h is Ice.Unset)
test(mo4.i is Ice.Unset)
test(mo4.bs is Ice.Unset)
test(mo4.ss is Ice.Unset)
test(mo4.iid is Ice.Unset)
test(mo4.sid is Ice.Unset)
test(mo4.fs is Ice.Unset)
test(mo4.vs is Ice.Unset)
test(mo4.shs is Ice.Unset)
test(mo4.es is Ice.Unset)
test(mo4.fss is Ice.Unset)
test(mo4.vss is Ice.Unset)
test(mo4.ied is Ice.Unset)
test(mo4.ifsd is Ice.Unset)
test(mo4.ivsd is Ice.Unset)
test(mo4.bos is Ice.Unset)
mo5 = initial.pingPong(mo1)
test(mo5.a == mo1.a)
test(mo5.b == mo1.b)
test(mo5.c == mo1.c)
test(mo5.d == mo1.d)
test(mo5.e == mo1.e)
test(mo5.f == mo1.f)
test(mo5.g == mo1.g)
test(mo5.h == mo1.h)
test(mo5.i == mo1.i)
if sys.version_info[0] == 2:
test(mo5.bs == "\x05")
else:
test(mo5.bs[0] == 5)
test(mo5.ss == mo1.ss)
test(mo5.iid[4] == 3)
test(mo5.sid["test"] == 10)
test(mo5.fs == mo1.fs)
test(mo5.vs == mo1.vs)
test(mo5.shs == mo1.shs)
test(mo5.es[0] == Test.MyEnum.MyEnumMember
and mo1.es[1] == Test.MyEnum.MyEnumMember)
test(mo5.fss[0] == Test.FixedStruct(78))
test(mo5.vss[0] == Test.VarStruct("hello"))
test(mo5.ied[4] == Test.MyEnum.MyEnumMember)
test(mo5.ifsd[4] == Test.FixedStruct(78))
test(mo5.ivsd[5] == Test.VarStruct("hello"))
test(mo5.bos == mo1.bos)
# Clear the first half of the optional members
mo6 = Test.MultiOptional()
mo6.b = mo5.b
mo6.d = mo5.d
mo6.f = mo5.f
mo6.h = mo5.h
mo6.bs = mo5.bs
mo6.iid = mo5.iid
mo6.fs = mo5.fs
mo6.shs = mo5.shs
mo6.fss = mo5.fss
mo6.ifsd = mo5.ifsd
mo6.bos = mo5.bos
mo7 = initial.pingPong(mo6)
test(mo7.a is Ice.Unset)
test(mo7.b == mo1.b)
test(mo7.c is Ice.Unset)
test(mo7.d == mo1.d)
test(mo7.e is Ice.Unset)
test(mo7.f == mo1.f)
test(mo7.g is Ice.Unset)
test(mo7.h == mo1.h)
test(mo7.i is Ice.Unset)
if sys.version_info[0] == 2:
test(mo7.bs == "\x05")
else:
test(mo7.bs[0] == 5)
test(mo7.ss is Ice.Unset)
test(mo7.iid[4] == 3)
test(mo7.sid is Ice.Unset)
test(mo7.fs == mo1.fs)
test(mo7.vs is Ice.Unset)
test(mo7.shs == mo1.shs)
test(mo7.es is Ice.Unset)
test(mo7.fss[0] == Test.FixedStruct(78))
test(mo7.vss is Ice.Unset)
test(mo7.ied is Ice.Unset)
test(mo7.ifsd[4] == Test.FixedStruct(78))
test(mo7.ivsd is Ice.Unset)
test(mo7.bos == [False, True, False])
# Clear the second half of the optional members
mo8 = Test.MultiOptional()
mo8.a = mo5.a
mo8.c = mo5.c
mo8.e = mo5.e
mo8.g = mo5.g
mo8.i = mo5.i
mo8.ss = mo5.ss
mo8.sid = mo5.sid
mo8.vs = mo5.vs
mo8.es = mo5.es
mo8.vss = mo5.vss
mo8.ied = mo5.ied
mo8.ivsd = mo5.ivsd
mo9 = initial.pingPong(mo8)
test(mo9.a == mo1.a)
test(mo9.b is Ice.Unset)
test(mo9.c == mo1.c)
test(mo9.d is Ice.Unset)
test(mo9.e == mo1.e)
test(mo9.f is Ice.Unset)
test(mo9.g == mo1.g)
test(mo9.h is Ice.Unset)
test(mo9.i == mo1.i)
test(mo9.bs is Ice.Unset)
test(mo9.ss == mo1.ss)
test(mo9.iid is Ice.Unset)
test(mo9.sid["test"] == 10)
test(mo9.fs is Ice.Unset)
test(mo9.vs == mo1.vs)
test(mo9.shs is Ice.Unset)
test(mo9.es[0] == Test.MyEnum.MyEnumMember
and mo1.es[1] == Test.MyEnum.MyEnumMember)
test(mo9.fss is Ice.Unset)
test(mo9.vss[0] == Test.VarStruct("hello"))
test(mo9.ied[4] == Test.MyEnum.MyEnumMember)
test(mo9.ifsd is Ice.Unset)
test(mo9.ivsd[5] == Test.VarStruct("hello"))
test(mo9.bos is Ice.Unset)
initial2 = Test.Initial2Prx.uncheckedCast(base)
initial2.opVoid(15, "test")
print("ok")
sys.stdout.write(
"testing marshaling of large containers with fixed size elements... ")
sys.stdout.flush()
mc = Test.MultiOptional()
mc.bs = []
for i in range(1000):
mc.bs.append(0)
mc.shs = []
for i in range(300):
mc.shs.append(0)
mc.fss = []
for i in range(300):
mc.fss.append(Test.FixedStruct())
mc.ifsd = {}
for i in range(300):
mc.ifsd[i] = Test.FixedStruct()
mc = initial.pingPong(mc)
test(len(mc.bs) == 1000)
test(len(mc.shs) == 300)
test(len(mc.fss) == 300)
test(len(mc.ifsd) == 300)
print("ok")
sys.stdout.write("testing tag marshaling... ")
sys.stdout.flush()
b = Test.B()
b2 = initial.pingPong(b)
test(b2.ma is Ice.Unset)
test(b2.mb is Ice.Unset)
test(b2.mc is Ice.Unset)
b.ma = 10
b.mb = 11
b.mc = 12
b.md = 13
b2 = initial.pingPong(b)
test(b2.ma == 10)
test(b2.mb == 11)
test(b2.mc == 12)
test(b2.md == 13)
print("ok")
sys.stdout.write("testing optional with default values... ")
sys.stdout.flush()
wd = initial.pingPong(Test.WD())
test(wd.a == 5)
test(wd.s == "test")
wd.a = Ice.Unset
wd.s = Ice.Unset
wd = initial.pingPong(wd)
test(wd.a is Ice.Unset)
test(wd.s is Ice.Unset)
print("ok")
if communicator.getProperties().getPropertyAsInt(
"Ice.Default.SlicedFormat") > 0:
sys.stdout.write("testing marshaling with unknown class slices... ")
sys.stdout.flush()
c = Test.C()
c.ss = "test"
c.ms = "testms"
c = initial.pingPong(c)
test(c.ma is Ice.Unset)
test(c.mb is Ice.Unset)
test(c.mc is Ice.Unset)
test(c.md is Ice.Unset)
test(c.ss == "test")
test(c.ms == "testms")
print("ok")
sys.stdout.write("testing optionals with unknown classes... ")
sys.stdout.flush()
initial2 = Test.Initial2Prx.uncheckedCast(base)
initial2.opClassAndUnknownOptional(Test.A())
print("ok")
sys.stdout.write("testing optional parameters... ")
sys.stdout.flush()
(p2, p3) = initial.opByte(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
(p2, p3) = initial.opByte(56)
test(p2 == 56 and p3 == 56)
f = initial.opByteAsync(56)
(p2, p3) = f.result()
test(p2 == 56 and p3 == 56)
(p2, p3) = initial.opBool(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
(p2, p3) = initial.opBool(True)
test(p2 == True and p3 == True)
f = initial.opBoolAsync(True)
(p2, p3) = f.result()
test(p2 == True and p3 == True)
(p2, p3) = initial.opShort(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
(p2, p3) = initial.opShort(56)
test(p2 == 56 and p3 == 56)
f = initial.opShortAsync(56)
(p2, p3) = f.result()
test(p2 == 56 and p3 == 56)
(p2, p3) = initial.opInt(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
(p2, p3) = initial.opInt(56)
test(p2 == 56 and p3 == 56)
f = initial.opIntAsync(56)
(p2, p3) = f.result()
test(p2 == 56 and p3 == 56)
(p2, p3) = initial.opLong(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
(p2, p3) = initial.opLong(56)
test(p2 == 56 and p3 == 56)
f = initial.opLongAsync(56)
(p2, p3) = f.result()
test(p2 == 56 and p3 == 56)
(p2, p3) = initial.opFloat(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
(p2, p3) = initial.opFloat(1.0)
test(p2 == 1.0 and p3 == 1.0)
f = initial.opFloatAsync(1.0)
(p2, p3) = f.result()
test(p2 == 1.0 and p3 == 1.0)
(p2, p3) = initial.opDouble(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
(p2, p3) = initial.opDouble(1.0)
test(p2 == 1.0 and p3 == 1.0)
f = initial.opDoubleAsync(1.0)
(p2, p3) = f.result()
test(p2 == 1.0 and p3 == 1.0)
(p2, p3) = initial.opString(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
(p2, p3) = initial.opString("test")
test(p2 == "test" and p3 == "test")
f = initial.opStringAsync("test")
(p2, p3) = f.result()
test(p2 == "test" and p3 == "test")
(p2, p3) = initial.opMyEnum(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
(p2, p3) = initial.opMyEnum(Test.MyEnum.MyEnumMember)
test(p2 == Test.MyEnum.MyEnumMember and p3 == Test.MyEnum.MyEnumMember)
f = initial.opMyEnumAsync(Test.MyEnum.MyEnumMember)
(p2, p3) = f.result()
test(p2 == Test.MyEnum.MyEnumMember and p3 == Test.MyEnum.MyEnumMember)
(p2, p3) = initial.opSmallStruct(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
p1 = Test.SmallStruct(56)
(p2, p3) = initial.opSmallStruct(p1)
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opSmallStruct(None) # Test null struct
test(p2.m == 0 and p3.m == 0)
f = initial.opSmallStructAsync(p1)
(p2, p3) = f.result()
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opFixedStruct(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
p1 = Test.FixedStruct(56)
(p2, p3) = initial.opFixedStruct(p1)
test(p2 == p1 and p3 == p1)
f = initial.opFixedStructAsync(p1)
(p2, p3) = f.result()
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opVarStruct(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
p1 = Test.VarStruct("test")
(p2, p3) = initial.opVarStruct(p1)
test(p2 == p1 and p3 == p1)
f = initial.opVarStructAsync(p1)
(p2, p3) = f.result()
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opByteSeq(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
p1 = [56 for x in range(100)]
(p2, p3) = initial.opByteSeq(p1)
test(len(p2) == len(p1) and len(p3) == len(p1))
if sys.version_info[0] == 2:
test(p2[0] == '\x38')
test(p3[0] == '\x38')
else:
test(p2[0] == 0x38)
test(p3[0] == 0x38)
f = initial.opByteSeqAsync(p1)
(p2, p3) = f.result()
test(len(p2) == len(p1) and len(p3) == len(p1))
if sys.version_info[0] == 2:
test(p2[0] == '\x38')
test(p3[0] == '\x38')
else:
test(p2[0] == 0x38)
test(p3[0] == 0x38)
(p2, p3) = initial.opBoolSeq(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
p1 = [True for x in range(100)]
(p2, p3) = initial.opBoolSeq(p1)
test(p2 == p1 and p3 == p1)
f = initial.opBoolSeqAsync(p1)
(p2, p3) = f.result()
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opShortSeq(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
p1 = [56 for x in range(100)]
(p2, p3) = initial.opShortSeq(p1)
test(p2 == p1 and p3 == p1)
f = initial.opShortSeqAsync(p1)
(p2, p3) = f.result()
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opIntSeq(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
p1 = [56 for x in range(100)]
(p2, p3) = initial.opIntSeq(p1)
test(p2 == p1 and p3 == p1)
f = initial.opIntSeqAsync(p1)
(p2, p3) = f.result()
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opLongSeq(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
p1 = [56 for x in range(100)]
(p2, p3) = initial.opLongSeq(p1)
test(p2 == p1 and p3 == p1)
f = initial.opLongSeqAsync(p1)
(p2, p3) = f.result()
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opFloatSeq(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
p1 = [1.0 for x in range(100)]
(p2, p3) = initial.opFloatSeq(p1)
test(p2 == p1 and p3 == p1)
f = initial.opFloatSeqAsync(p1)
(p2, p3) = f.result()
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opDoubleSeq(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
p1 = [1.0 for x in range(100)]
(p2, p3) = initial.opDoubleSeq(p1)
test(p2 == p1 and p3 == p1)
f = initial.opDoubleSeqAsync(p1)
(p2, p3) = f.result()
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opStringSeq(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
p1 = ["test1" for x in range(100)]
(p2, p3) = initial.opStringSeq(p1)
test(p2 == p1 and p3 == p1)
f = initial.opStringSeqAsync(p1)
(p2, p3) = f.result()
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opSmallStructSeq(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
p1 = [Test.SmallStruct(1) for x in range(10)]
(p2, p3) = initial.opSmallStructSeq(p1)
test(p2 == p1 and p3 == p1)
f = initial.opSmallStructSeqAsync(p1)
(p2, p3) = f.result()
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opSmallStructList(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
p1 = tuple([Test.SmallStruct(1) for x in range(10)])
(p2, p3) = initial.opSmallStructList(p1)
test(p2 == p1 and p3 == p1)
f = initial.opSmallStructListAsync(p1)
(p2, p3) = f.result()
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opFixedStructSeq(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
p1 = [Test.FixedStruct(1) for x in range(10)]
(p2, p3) = initial.opFixedStructSeq(p1)
test(p2 == p1 and p3 == p1)
f = initial.opFixedStructSeqAsync(p1)
(p2, p3) = f.result()
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opFixedStructList(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
p1 = tuple([Test.FixedStruct(1) for x in range(10)])
(p2, p3) = initial.opFixedStructList(p1)
test(p2 == p1 and p3 == p1)
f = initial.opFixedStructListAsync(p1)
(p2, p3) = f.result()
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opVarStructSeq(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
p1 = [Test.VarStruct("test") for x in range(10)]
(p2, p3) = initial.opVarStructSeq(p1)
test(p2 == p1 and p3 == p1)
f = initial.opVarStructSeqAsync(p1)
(p2, p3) = f.result()
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opIntIntDict(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
p1 = {1: 2, 2: 3}
(p2, p3) = initial.opIntIntDict(p1)
test(p2 == p1 and p3 == p1)
f = initial.opIntIntDictAsync(p1)
(p2, p3) = f.result()
test(p2 == p1 and p3 == p1)
(p2, p3) = initial.opStringIntDict(Ice.Unset)
test(p2 is Ice.Unset and p3 is Ice.Unset)
p1 = {"1": 2, "2": 3}
(p2, p3) = initial.opStringIntDict(p1)
test(p2 == p1 and p3 == p1)
f = initial.opStringIntDictAsync(p1)
(p2, p3) = f.result()
test(p2 == p1 and p3 == p1)
print("ok")
sys.stdout.write("testing exception optionals... ")
sys.stdout.flush()
try:
initial.opOptionalException(Ice.Unset, Ice.Unset, Ice.Unset)
except Test.OptionalException as ex:
test(ex.a is Ice.Unset)
test(ex.b is Ice.Unset)
test(ex.vs is Ice.Unset)
try:
initial.opOptionalException(30, "test", Test.VarStruct("hello"))
except Test.OptionalException as ex:
test(ex.a == 30)
test(ex.b == "test")
test(ex.vs.m == "hello")
try:
#
# Use the 1.0 encoding with an exception whose only class members are optional.
#
initial.ice_encodingVersion(Ice.Encoding_1_0).opOptionalException(
30, "test", Test.VarStruct("hello"))
except Test.OptionalException as ex:
test(ex.a is Ice.Unset)
test(ex.b is Ice.Unset)
test(ex.vs is Ice.Unset)
try:
initial.opDerivedException(Ice.Unset, Ice.Unset, Ice.Unset)
except Test.DerivedException as ex:
test(ex.a is Ice.Unset)
test(ex.b is Ice.Unset)
test(ex.vs is Ice.Unset)
test(ex.ss is Ice.Unset)
test(ex.vs2 is Ice.Unset)
try:
initial.opDerivedException(30, "test2", Test.VarStruct("hello2"))
except Test.DerivedException as ex:
test(ex.a == 30)
test(ex.b == "test2")
test(ex.vs.m == "hello2")
test(ex.ss == "test2")
test(ex.vs2 == ex.vs)
try:
initial.opRequiredException(Ice.Unset, Ice.Unset, Ice.Unset)
except Test.RequiredException as ex:
test(ex.a is Ice.Unset)
test(ex.b is Ice.Unset)
test(ex.vs is Ice.Unset)
test(ex.ss == "test")
test(ex.vs2 == None)
try:
initial.opRequiredException(30, "test2", Test.VarStruct("hello2"))
except Test.RequiredException as ex:
test(ex.a == 30)
test(ex.b == "test2")
test(ex.vs.m == "hello2")
test(ex.ss == "test2")
test(ex.vs2 == ex.vs)
print("ok")
sys.stdout.write("testing optionals with marshaled results... ")
sys.stdout.flush()
test(initial.opMStruct1() != Ice.Unset)
test(initial.opMDict1() != Ice.Unset)
test(initial.opMSeq1() != Ice.Unset)
(p3, p2) = initial.opMStruct2(Ice.Unset)
test(p2 == Ice.Unset and p3 == Ice.Unset)
p1 = Test.SmallStruct()
(p3, p2) = initial.opMStruct2(p1)
test(p2 == p1 and p3 == p1)
(p3, p2) = initial.opMSeq2(Ice.Unset)
test(p2 == Ice.Unset and p3 == Ice.Unset)
p1 = ["hello"]
(p3, p2) = initial.opMSeq2(p1)
test(p2[0] == "hello" and p3[0] == "hello")
(p3, p2) = initial.opMDict2(Ice.Unset)
test(p2 == Ice.Unset and p3 == Ice.Unset)
p1 = {"test": 54}
(p3, p2) = initial.opMDict2(p1)
test(p2["test"] == 54 and p3["test"] == 54)
print("ok")
return initial
