def __init__(self,num_s,num_q):
students = self.gen_students(num_s)
print ("\n\n\n Standard Test \n\n")
newTest = Test(num_q, students)
newTest.start()
newTest.printResult()
print ("\n\n\n Optimized Test \n\n")
optTest = Test(num_q, students)
optTest.start_opt()
optTest.printResult()
def execute(*args):
"""Test all derived functions for proper operation
"""
import Vector
reload(Vector)
Vector.test()
import Add
reload(Add)
Add.test()
import Multiply
reload(Multiply)
Multiply.test()
import Divide
reload(Divide)
Divide.test()
import Difference
reload(Difference)
Difference.test()
import Poly
reload(Poly)
Poly.test()
import Average
reload(Average)
Average.test()
import LinTrans
reload(LinTrans)
LinTrans.test()
import Test
reload(Test)
Test.test()
import Rotate
reload(Rotate)
Rotate.test()
import Magnitude
reload(Magnitude)
Magnitude.test()
import Cape
reload(Cape)
Cape.test()
print "-"*60
print "Function Test Complete"
def post(self):
if 'Save' in flask.request.form:
template_id = request.form['template_id']
modified_template_body = request.form['template_body']
print "\najjsj\n"
Test.test_session_variable()
print modified_template_body
print template_id
g.db.execute('update list_templates SET template_body=\"'+modified_template_body+'\" where id='+template_id)
g.db.commit()
flask.flash('New entry was successfully saved')
return flask.redirect(flask.url_for('show_templates'))
def go( i ):
j1 = Test.test_function_1(5660 + i, 5454+ i+1)
j2 = Test.test_function_2(43543 + i, 54534 + i * 2 )
j3 = Test.test_function_3(435433 + i )
def __cb(b):
b.foo()
b.min(1,2)
Test.test_function_5(b)
pass
j4 = Test.test_function_4(__cb)
pass
def _vectorExpr(instanceMethod):
w = Test.currentWidget()
name = '::' + str(w)
if instanceMethod:
w.expr(name + '+ 0.5')
else:
return Pmw.Blt.vector_expr(name + '* 2')
def get_similar():
"""API endpoint to search for similar houses to a given location
:param lat,lon: Point on the map to search from of the search query
:return: GeoJSON encoded collection of locations near the query Point
"""
try:
lat = float(request.args.get('lat', ''))
lon = float(request.args.get('lon', ''))
except:
print "error"
house = Test.generate_datum()
house['lat'] = lat
house['lon'] = lon
house['dwelling_type'] = 'single-family'
houses = house.get_similar(10)
geo_houses = []
for i in range(0,10):
house = houses.iloc[i]
feature = Feature(geometry=Point((house['lon'],house['lat'])))
feature['dwelling_type'] = house['dwelling_type']
feature['pool'] = house['pool']
feature['list_price'] = house['list_price']
geo_houses.append(feature)
return Response(str(FeatureCollection(geo_houses)), mimetype="application/json")
def _vectorExpr(instanceMethod):
w = Test.currentWidget()
name = "::" + str(w)
if instanceMethod:
w.expr(name + "+ 0.5")
else:
return Pmw.Blt.vector_expr(name + "* 2")
def test_move(self):
self.assertEqual(Test.getObject(marv.x-1,marv.y),None)
self.assertGreater(marv.movementLeft,0)
res = marv.move(marv.x-1,marv.y)
print (res)
self.assertEqual([marv.x,marv.y],[1,3])
self.assertEqual(marv.currentHealth,80-Test.healthPerMove)
def destroyManagedDomains():
if len(_managedDomains) > 0:
for m in _managedDomains:
Test.traceCommand("xm destroy %s" % m)
Test.traceCommand("xm delete %s" % m)
if len(_VMuuids) > 0:
for uuid in _VMuuids:
Test.traceCommand("xm destroy %s" % uuid)
Test.traceCommand("xm delete %s" % uuid)
def _addComponent():
w = Test.currentWidget()
label2 = w.createcomponent('label2',
(), 'Mygroup',
tkinter.Label, (w.interior(),),
text = 'Temporary', background = 'yellow')
label2.pack(fill = 'x')
return label2.cget('text')
def _penNamesSorted(pattern = None):
w = Test.currentWidget()
if pattern is None:
names = list(w.pen_names())
else:
names = list(w.pen_names(pattern))
names.sort()
return tuple(names)
def _vectorNames():
name = '::' + str(Test.currentWidget())
names = Pmw.Blt.vector_names()
if name not in names:
return names
name2 = Pmw.Blt.vector_names(name)
if name2 != (name,):
return name2
return None
def main():
host = '127.0.0.1'
port = 4000
backlog = 10
bufsize = 4096
while true do:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
with closing(sock):
sock.bind((host, port))
sock.listen(backlog)
while True:
conn, address = sock.accept()
with closing(conn):
msg = conn.recv(bufsize)
insert_news.main(msg)
conn.send(msg)
return
def test_move(self):
self.marv = Test.Creature(35,2,3,1,120,40,20,4,2,2,2,7,31)
Test.grid[2][3].append(self.marv)
self.assertEqual(Test.getObject(self.marv.x-1,self.marv.y),None)
self.assertGreater(self.marv.movementLeft,0)
res = self.marv.move(self.marv.x-1,self.marv.y)
self.assertTrue(res)
self.assertEqual([self.marv.x,self.marv.y],[1,3])
self.assertEqual(self.marv.currentHealth,40-Test.healthPerMove)
Test.grid[1][3].remove(self.marv)
def _testYView(doBottom):
w = Test.currentWidget()
top, bottom = w.yview()
if type(top) != type(0.0) or type(bottom) != type(0.0):
return 'bad type ' + str(top) + ' ' + str(bottom)
if doBottom:
if bottom != 1.0:
return 'bottom is ' + str(bottom)
else:
if top != 0.0:
return 'top is ' + str(top)
def _checkGridInfo():
w = Test.currentWidget()
b8 = w.grid_slaves(column=0, row=3)[0]
info = b8.grid_info()
if info['in'] == w:
rtn = {}
for key, value in list(info.items()):
if key != 'in':
rtn[key] = value
return rtn
return 'BAD'
def _makeGridButtons():
w = Test.currentWidget()
b1 = tkinter.Button(w, text = 'Button 1')
b2 = tkinter.Button(w, text = 'Button 2')
b3 = tkinter.Button(w, text = 'Button 3')
b4 = tkinter.Button(w, text = 'Button 4')
b5 = tkinter.Button(w, text = 'Button 5')
b6 = tkinter.Button(w, text = 'Button 6')
b7 = tkinter.Button(w, text = 'Button 7')
b8 = tkinter.Button(w, text = 'Button 8')
b1.grid(column=0, row=0)
b2.grid(column=1, row=0)
b3.grid(column=2, row=0, ipadx=50, ipady=50, padx=50, pady=50, sticky='nsew')
b4.grid(column=3, row=0)
b5.grid(column=0, row=1)
b6.grid(column=2, row=1, columnspan=2, rowspan=2, sticky='nsew')
b7.grid(column=0, row=2)
b8.grid(column=0, row=3, columnspan=4, padx=50, sticky='ew')
def _delVectorItem(index):
w = Test.currentWidget()
del w[index]
def _createMarkerButton():
w = Test.currentWidget()
button = tkinter.Button(w, text='This is\na button')
w.marker_create('window', coords=(10, 200), window=button)
def _getVectorSlice(index1, index2):
w = Test.currentWidget()
return w[index1:index2]
def allTests(communicator):
sys.stdout.write("testing equals() for Slice structures... ")
sys.stdout.flush()
#
# Define some default values.
#
def_s2 = Test.S2(True, 98, 99, 100, 101, "string", (1, 2, 3),
Test.S1("name"))
#
# Compare default-constructed structures.
#
test(Test.S2() == Test.S2())
#
# Change one member at a time.
#
v = copy.copy(def_s2)
test(v == def_s2)
v = copy.copy(def_s2)
v.bo = False
test(v != def_s2)
v = copy.copy(def_s2)
v.by = v.by - 1
test(v != def_s2)
v = copy.copy(def_s2)
v.sh = v.sh - 1
test(v != def_s2)
v = copy.copy(def_s2)
v.i = v.i - 1
test(v != def_s2)
v = copy.copy(def_s2)
v.l = v.l - 1
test(v != def_s2)
v = copy.copy(def_s2)
v.str = ""
test(v != def_s2)
#
# String member
#
v1 = copy.copy(def_s2)
v1.str = "string"
test(v1 == def_s2)
v1 = copy.copy(def_s2)
v2 = copy.copy(def_s2)
v1.str = None
test(v1 != v2)
v1 = copy.copy(def_s2)
v2 = copy.copy(def_s2)
v2.str = None
test(v1 != v2)
v1 = copy.copy(def_s2)
v2 = copy.copy(def_s2)
v1.str = None
v2.str = None
test(v1 == v2)
#
# Sequence member
#
v1 = copy.copy(def_s2)
v1.seq = copy.copy(def_s2.seq)
test(v1 == def_s2)
v1 = copy.copy(def_s2)
v1.seq = ()
test(v1 != def_s2)
v1 = copy.copy(def_s2)
v1.seq = (1, 2, 3)
test(v1 == def_s2)
v1 = copy.copy(def_s2)
v2 = copy.copy(def_s2)
v1.seq = None
test(v1 != v2)
v1 = copy.copy(def_s2)
v2 = copy.copy(def_s2)
v2.seq = None
test(v1 != v2)
#
# Struct member
#
v1 = copy.copy(def_s2)
v1.s = copy.copy(def_s2.s)
test(v1 == def_s2)
v1 = copy.copy(def_s2)
v1.s = Test.S1("name")
test(v1 == def_s2)
v1 = copy.copy(def_s2)
v1.s = Test.S1("noname")
test(v1 != def_s2)
v1 = copy.copy(def_s2)
v2 = copy.copy(def_s2)
v1.s = None
test(v1 != v2)
v1 = copy.copy(def_s2)
v2 = copy.copy(def_s2)
v2.s = None
test(v1 != v2)
#
# Define some default values.
#
def_s3 = Test.S3(Test.C("name"), {"1": "2"},
communicator.stringToProxy("test"))
#
# Compare default-constructed structures.
#
test(Test.S3() == Test.S3())
#
# Change one member at a time.
#
v1 = copy.copy(def_s3)
test(v1 == def_s3)
v1.obj = None
test(v1 != def_s3)
v1.obj = Test.C("name")
test(v1 != def_s3)
v1 = copy.copy(def_s3)
v1.sd = copy.copy(def_s3.sd)
test(v1 == def_s3)
v1.sd = None
test(v1 != def_s3)
v1.sd = {"1": "3"}
test(v1 != def_s3)
v1 = copy.copy(def_s3)
v1.prx = None
test(v1 != def_s3)
v1.prx = communicator.stringToProxy("test")
test(v1 == def_s3)
v1.prx = communicator.stringToProxy("test2")
test(v1 != def_s3)
print("ok")
def PBSUnknown2AsPreservedWithGraph(self, current=None):
r = Test.PSUnknown2()
r.pi = 5
r.ps = "preserved"
r.pb = r
return Ice.Future.completed(r)
def _setbackground(name, colour):
w = Test.currentWidget()
w.pane(name).configure(background = colour)
print("Step 3: Copy/paste G12 and A3 ")
editingContext.Selection.SetRange([G12, A3])
atfEdit.Copy()
atfEdit.Paste()
G12Copy = circuitContainer.Elements[circuitContainer.Elements.Count - 2]
A3Copy = circuitContainer.Elements[circuitContainer.Elements.Count - 1]
G12Copy.Name = 'GC12'
A3Copy.Name = 'AC3'
#excise
print("Step 4: promote group G12 and A3 to template library")
hist.Begin("promote to template Library")
templateCmds.PromoteToTemplateLibrary([G12, A3])
templatingContext = templateCmds.TemplatingContext
Test.Equal(
2, templatingContext.RootFolder.Templates.Count,
"Varify two template items are created in the root folder of the template library"
)
hist.End()
print(
"Step 5: make edges that connect from regular elements to referencing elements and vice versa"
)
hist.Begin("Making more edges")
edgesBefore = editingContext.CircuitContainer.Wires.Count
G12Ref = CircuitEditorUtil.GetElement(circuitContainer, 'G12')
A3Ref = CircuitEditorUtil.GetElement(circuitContainer, 'A3')
#edge from a regular group to a referencing element
G12Module = Adapters.Cast[Module](G12Copy.DomNode)
A3RefModule = Adapters.Cast[Module](A3Ref.DomNode)
#editingContext.Connect(G12Module, G12Module.Type.Outputs[0], A3RefModule, A3RefModule.Type.Inputs[0], None)
#edge from a regular group to a referencing group
def oneElementCycle(self, current=None):
b = Test.B()
b.sb = "B1.sb"
b.pb = b
return b
def SUnknownAsObject(self, current=None):
su = Test.SUnknown()
su.su = "SUnknown.su"
return su
def SBSUnknownDerivedAsSBaseCompact(self, current=None):
sbsud = Test.SBSUnknownDerived()
sbsud.sb = "SBSUnknownDerived.sb"
sbsud.sbsud = "SBSUnknownDerived.sbsud"
return sbsud
def SBSKnownDerivedAsSBSKnownDerived(self, current=None):
sbskd = Test.SBSKnownDerived()
sbskd.sb = "SBSKnownDerived.sb"
sbskd.sbskd = "SBSKnownDerived.sbskd"
return sbskd
def useForward(self, current=None):
f = Test.Forward()
f.h = Test.Hidden()
f.h.f = f
return f
def allTests(communicator):
ref = "test:default -p 12010"
base = communicator.stringToProxy(ref)
test(base)
custom = Test.CustomPrx.checkedCast(base)
test(custom)
byteList = [1, 2, 3, 4, 5]
if sys.version_info[0] == 2:
byteString = ''.join(map(chr, byteList))
else:
byteString = bytes(byteList)
stringList = ['s1', 's2', 's3']
sys.stdout.write("testing custom sequences... ")
sys.stdout.flush()
(r, b2) = custom.opByteString1(byteString)
if sys.version_info[0] == 2:
test(isinstance(r, str))
test(isinstance(b2, str))
else:
test(isinstance(r, bytes))
test(isinstance(b2, bytes))
test(r == byteString)
test(b2 == byteString)
(r, b2) = custom.opByteString2(byteString)
test(isinstance(r, tuple))
test(isinstance(b2, list))
for i in range(0, len(byteList)):
test(r[i] == byteList[i])
test(b2[i] == byteList[i])
(r, b2) = custom.opByteList1(byteList)
test(isinstance(r, list))
test(isinstance(b2, list))
for i in range(0, len(byteList)):
test(r[i] == byteList[i])
test(b2[i] == byteList[i])
(r, b2) = custom.opByteList2(byteList)
if sys.version_info[0] == 2:
test(isinstance(r, str))
else:
test(isinstance(r, bytes))
test(isinstance(b2, tuple))
test(r == byteString)
for i in range(0, len(byteList)):
test(b2[i] == byteList[i])
(r, b2) = custom.opStringList1(stringList)
test(isinstance(r, list))
test(isinstance(b2, list))
test(r == stringList)
test(b2 == stringList)
(r, b2) = custom.opStringList2(stringList)
test(isinstance(r, tuple))
test(isinstance(b2, tuple))
for i in range(0, len(stringList)):
test(r[i] == stringList[i])
test(b2[i] == stringList[i])
(r, b2) = custom.opStringTuple1(stringList)
test(isinstance(r, tuple))
test(isinstance(b2, tuple))
for i in range(0, len(stringList)):
test(r[i] == stringList[i])
test(b2[i] == stringList[i])
(r, b2) = custom.opStringTuple2(stringList)
test(isinstance(r, list))
test(isinstance(b2, list))
test(r == stringList)
test(b2 == stringList)
s = Test.S()
s.b1 = byteList
s.b2 = byteList
s.b3 = byteList
s.b4 = byteList
s.s1 = stringList
s.s2 = stringList
s.s3 = stringList
s.s4 = stringList
custom.sendS(s)
c = Test.C()
c.b1 = byteList
c.b2 = byteList
c.b3 = byteList
c.b4 = byteList
c.s1 = stringList
c.s2 = stringList
c.s3 = stringList
c.s4 = stringList
custom.sendC(c)
print("ok")
return custom
def _populatePage(pageName):
w = Test.currentWidget()
page = w.page(pageName)
text = tkinter.Text(page)
text.pack()
return w.pagenames()[w.index(pageName)]
def opMStruct1(self, current):
return Ice.Future.completed(
Test.MyClass.OpMStruct1MarshaledResult(Test.Structure(), current))
#!/usr/bin/env python
import os
import re
import sys
import Tkinter
import Test
Test.initialise()
# Uncomment these to modify period between tests and how much output
# to print:
#Test.setdelay(1000)
#Test.setverbose(1)
# Ignore Tkinter test since it does not test any Pmw functionality
# (only Tkinter) and it fails under MS-Windows 95 (and it hasn't been
# kept up-to-date with changes to Tk.
ignoreTests = ('Tkinter_test.py',)
# Also ignore Blt test since it causes Blt 2.4z to core dump.
if Tkinter.TkVersion >= 8.4:
ignoreTests = ignoreTests + ('Blt_test.py',)
allTestData = ()
files = os.listdir(os.curdir)
files.sort()
for file in files:
if file not in ignoreTests and re.search('^.+_test.py$', file) is not None:
test = file[:-3]
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.NoValueFactoryException:
# 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.NoValueFactoryException:
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.addValueFactory(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.addValueFactory(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 _bogus():
w = Test.currentWidget()
w.bogus()
def returnOptionalClass(self, req, current=None):
return Ice.Future.completed(Test.OneOptional(53))
def _delVectorItem(index):
w = Test.currentWidget()
del w[index]
def opMStruct1(self, current):
return Ice.Future.completed(
Test.Initial.OpMStruct1MarshaledResult(Test.SmallStruct(),
current))
def _createInterior():
w = Test.currentWidget()
for i in range(3):
lb = Pmw.ScrolledListBox(w.interior(),
items = range(20), listbox_height = 6)
lb.pack(padx = 10, pady = 10)
def create_test_results():
import shutil
import os
import FemGui
import femresult.resulttools as resulttools
from femtools import ccxtools
stat_types = ["U1", "U2", "U3", "Uabs", "Sabs", "MaxPrin", "MidPrin", "MinPrin", "MaxShear", "Peeq", "Temp", "MFlow", "NPress"]
temp_dir = testtools.get_fem_test_tmp_dir()
static_analysis_dir = temp_dir + 'FEM_ccx_static/'
frequency_analysis_dir = temp_dir + 'FEM_ccx_frequency/'
thermomech_analysis_dir = temp_dir + 'FEM_ccx_thermomech/'
Flow1D_thermomech_analysis_dir = temp_dir + 'FEM_ccx_Flow1D_thermomech/'
# run all unit tests from this module
import Test
import sys
current_module = sys.modules[__name__]
Test.runTestsFromModule(current_module)
# static cube
FreeCAD.open(static_analysis_dir + 'cube_static.fcstd')
FemGui.setActiveAnalysis(FreeCAD.ActiveDocument.Analysis)
fea = ccxtools.FemToolsCcx()
print("create static result files")
fea.reset_all()
fea.run()
fea.load_results()
stats_static = []
for s in stat_types:
statval = resulttools.get_stats(FreeCAD.ActiveDocument.getObject('CalculiX_static_results'), s)
stats_static.append("{0}: ({1:.14g}, {2:.14g}, {3:.14g})\n".format(s, statval[0], statval[1], statval[2]))
static_expected_values_file = static_analysis_dir + 'cube_static_expected_values'
f = open(static_expected_values_file, 'w')
for s in stats_static:
f.write(s)
f.close()
frd_result_file = os.path.splitext(fea.inp_file_name)[0] + '.frd'
dat_result_file = os.path.splitext(fea.inp_file_name)[0] + '.dat'
frd_static_test_result_file = static_analysis_dir + 'cube_static.frd'
dat_static_test_result_file = static_analysis_dir + 'cube_static.dat'
shutil.copyfile(frd_result_file, frd_static_test_result_file)
shutil.copyfile(dat_result_file, dat_static_test_result_file)
# frequency cube
FreeCAD.open(frequency_analysis_dir + 'cube_frequency.fcstd')
FemGui.setActiveAnalysis(FreeCAD.ActiveDocument.Analysis)
fea = ccxtools.FemToolsCcx()
print("create frequency result files")
fea.reset_all()
fea.solver.EigenmodesCount = 1 # we should only have one result object
fea.run()
fea.load_results()
stats_frequency = []
for s in stat_types:
statval = resulttools.get_stats(FreeCAD.ActiveDocument.getObject('CalculiX_frequency_mode_1_results'), s)
stats_frequency.append("{0}: ({1:.14g}, {2:.14g}, {3:.14g})\n".format(s, statval[0], statval[1], statval[2]))
frequency_expected_values_file = frequency_analysis_dir + 'cube_frequency_expected_values'
f = open(frequency_expected_values_file, 'w')
for s in stats_frequency:
f.write(s)
f.close()
frd_frequency_test_result_file = frequency_analysis_dir + 'cube_frequency.frd'
dat_frequency_test_result_file = frequency_analysis_dir + 'cube_frequency.dat'
shutil.copyfile(frd_result_file, frd_frequency_test_result_file)
shutil.copyfile(dat_result_file, dat_frequency_test_result_file)
# thermomech
print("create thermomech result files")
FreeCAD.open(thermomech_analysis_dir + 'spine_thermomech.fcstd')
FemGui.setActiveAnalysis(FreeCAD.ActiveDocument.Analysis)
fea = ccxtools.FemToolsCcx()
fea.reset_all()
fea.run()
fea.load_results()
stats_thermomech = []
for s in stat_types:
statval = resulttools.get_stats(FreeCAD.ActiveDocument.getObject('CalculiX_thermomech_results'), s)
stats_thermomech.append("{0}: ({1:.14g}, {2:.14g}, {3:.14g})\n".format(s, statval[0], statval[1], statval[2]))
thermomech_expected_values_file = thermomech_analysis_dir + 'spine_thermomech_expected_values'
f = open(thermomech_expected_values_file, 'w')
for s in stats_thermomech:
f.write(s)
f.close()
frd_result_file = os.path.splitext(fea.inp_file_name)[0] + '.frd'
dat_result_file = os.path.splitext(fea.inp_file_name)[0] + '.dat'
frd_thermomech_test_result_file = thermomech_analysis_dir + 'spine_thermomech.frd'
dat_thermomech_test_result_file = thermomech_analysis_dir + 'spine_thermomech.dat'
shutil.copyfile(frd_result_file, frd_thermomech_test_result_file)
shutil.copyfile(dat_result_file, dat_thermomech_test_result_file)
print('Results copied to the appropriate FEM test dirs in: ' + temp_dir)
# Flow1D
print("create Flow1D result files")
FreeCAD.open(Flow1D_thermomech_analysis_dir + 'Flow1D_thermomech.fcstd')
FemGui.setActiveAnalysis(FreeCAD.ActiveDocument.Analysis)
fea = ccxtools.FemToolsCcx()
fea.reset_all()
fea.run()
fea.load_results()
stats_flow1D = []
for s in stat_types:
statval = resulttools.get_stats(FreeCAD.ActiveDocument.getObject('CalculiX_thermomech_time_1_0_results'), s)
stats_flow1D.append("{0}: ({1:.14g}, {2:.14g}, {3:.14g})\n".format(s, statval[0], statval[1], statval[2]))
Flow1D_thermomech_expected_values_file = Flow1D_thermomech_analysis_dir + 'Flow1D_thermomech_expected_values'
f = open(Flow1D_thermomech_expected_values_file, 'w')
for s in stats_flow1D:
f.write(s)
f.close()
frd_result_file = os.path.splitext(fea.inp_file_name)[0] + '.frd'
dat_result_file = os.path.splitext(fea.inp_file_name)[0] + '.dat'
frd_Flow1D_thermomech_test_result_file = Flow1D_thermomech_analysis_dir + 'Flow1D_thermomech.frd'
dat_Flow1D_thermomech_test_result_file = Flow1D_thermomech_analysis_dir + 'Flow1D_thermomech.dat'
shutil.copyfile(frd_result_file, frd_Flow1D_thermomech_test_result_file)
shutil.copyfile(dat_result_file, dat_Flow1D_thermomech_test_result_file)
print('Flow1D thermomech results copied to the appropriate FEM test dirs in: ' + temp_dir)
def _getVectorItem(index):
w = Test.currentWidget()
return w[index]
def main():
'''
Train.train()
'''
Test.test()
def _setVectorItem(index, value):
w = Test.currentWidget()
w[index] = value
def sequenceTest(self, p1, p2, current=None):
ss = Test.SS3()
ss.c1 = p1
ss.c2 = p2
return ss
# Tests for Blt widgets.
import os
import tkinter
import Test
import Pmw
Test.initialise()
testData = ()
# Blt vector type
def _setVectorItem(index, value):
w = Test.currentWidget()
w[index] = value
def _getVectorItem(index):
w = Test.currentWidget()
return w[index]
def _getVectorSlice(index1, index2):
w = Test.currentWidget()
return w[index1:index2]
def _delVectorItem(index):
w = Test.currentWidget()
del w[index]
def twoways(communicator, p):
literals = p.opStringLiterals()
test(Test.s0 == "\\")
test(Test.s0 == Test.sw0)
test(Test.s0 == literals[0])
test(Test.s0 == literals[11])
test(Test.s1 == "A")
test(Test.s1 == Test.sw1)
test(Test.s1 == literals[1])
test(Test.s1 == literals[12])
test(Test.s2 == "Ice")
test(Test.s2 == Test.sw2)
test(Test.s2 == literals[2])
test(Test.s2 == literals[13])
test(Test.s3 == "A21")
test(Test.s3 == Test.sw3)
test(Test.s3 == literals[3])
test(Test.s3 == literals[14])
test(Test.s4 == "\\u0041 \\U00000041")
test(Test.s4 == Test.sw4)
test(Test.s4 == literals[4])
test(Test.s4 == literals[15])
test(Test.s5 == "\xc3\xbf" if version_info[0] < 3 else b"\xc3\xbf".decode("utf-8"))
test(Test.s5 == Test.sw5)
test(Test.s5 == literals[5])
test(Test.s5 == literals[16])
test(Test.s6 == "\xcf\xbf" if version_info[0] < 3 else b"\xcf\xbf".decode("utf-8"))
test(Test.s6 == Test.sw6)
test(Test.s6 == literals[6])
test(Test.s6 == literals[17])
test(Test.s7 == "\xd7\xb0" if version_info[0] < 3 else b"\xd7\xb0".decode("utf-8"))
test(Test.s7 == Test.sw7)
test(Test.s7 == literals[7])
test(Test.s7 == literals[18])
test(Test.s8 == "\xf0\x90\x80\x80" if version_info[0] < 3 else b"\xf0\x90\x80\x80".decode("utf-8"))
test(Test.s8 == Test.sw8)
test(Test.s8 == literals[8])
test(Test.s8 == literals[19])
test(Test.s9 == "\xf0\x9f\x8d\x8c" if version_info[0] < 3 else b"\xf0\x9f\x8d\x8c".decode("utf-8"))
test(Test.s9 == Test.sw9)
test(Test.s9 == literals[9])
test(Test.s9 == literals[20])
test(Test.s10 == "\xe0\xb6\xa7" if version_info[0] < 3 else b"\xe0\xb6\xa7".decode("utf-8"))
test(Test.s10 == Test.sw10)
test(Test.s10 == literals[10])
test(Test.s10 == literals[21])
test(Test.ss0 == "\'\"\x3f\\\a\b\f\n\r\t\v\x06")
test(Test.ss0 == Test.ss1)
test(Test.ss0 == Test.ss2)
test(Test.ss0 == literals[22])
test(Test.ss0 == literals[23])
test(Test.ss0 == literals[24])
test(Test.ss3 == "\\\\U\\u\\")
test(Test.ss3 == literals[25])
test(Test.ss4 == "\\A\\")
test(Test.ss4 == literals[26])
test(Test.ss5 == "\\u0041\\")
test(Test.ss5 == literals[27])
test(Test.su0 == Test.su1)
test(Test.su0 == Test.su2)
test(Test.su0 == literals[28])
test(Test.su0 == literals[29])
test(Test.su0 == literals[30])
#
# ice_ping
#
p.ice_ping()
#
# ice_isA
#
test(p.ice_isA(Test.MyClass.ice_staticId()))
#
# ice_ids
#
ids = p.ice_ids()
test(len(ids) == 3)
test(ids[0] == "::Ice::Object")
test(ids[1] == "::Test::MyClass")
test(ids[2] == "::Test::MyDerivedClass")
#
# ice_id
#
test(p.ice_id() == Test.MyDerivedClass.ice_staticId())
#
# Prx ice_staticId
#
test(Test.MyClassPrx.ice_staticId() == Test.MyClass.ice_staticId())
test(Test.MyDerivedClassPrx.ice_staticId() == Test.MyDerivedClass.ice_staticId())
test(Ice.ObjectPrx.ice_staticId() == Ice.Object.ice_staticId())
#
# opVoid
#
p.opVoid()
#
# opByte
#
r, b = p.opByte(0xff, 0x0f)
test(b == 0xf0)
test(r == 0xff)
#
# opBool
#
r, b = p.opBool(True, False)
test(b)
test(not r)
#
# opShortIntLong
#
r, s, i, l = p.opShortIntLong(10, 11, 12)
test(s == 10)
test(i == 11)
test(l == 12)
test(r == 12)
r, s, i, l = p.opShortIntLong(-32768, -2147483648, -9223372036854775808)
test(s == -32768)
test(i == -2147483648)
test(l == -9223372036854775808)
test(r == -9223372036854775808)
r, s, i, l = p.opShortIntLong(32767, 2147483647, 9223372036854775807)
test(s == 32767)
test(i == 2147483647)
test(l == 9223372036854775807)
test(r == 9223372036854775807)
#
# opFloatDouble
#
r, f, d = p.opFloatDouble(3.14, 1.1E10)
test(f - 3.14 < 0.001)
test(d == 1.1E10)
test(r == 1.1E10)
#
# Test invalid ranges for numbers
#
try:
r, b = p.opByte(0x01ff, 0x01ff)
test(False)
except ValueError:
pass
try:
r, s, i, l = p.opShortIntLong(32767 + 1, 0, 0)
test(False)
except ValueError:
pass
try:
r, s, i, l = p.opShortIntLong(-32768 -1, 0, 0)
test(False)
except ValueError:
pass
try:
r, s, i, l = p.opShortIntLong(0, 2147483647 + 1, 0)
test(False)
except ValueError:
pass
try:
r, s, i, l = p.opShortIntLong(0, -2147483648 - 1, 0)
test(False)
except ValueError:
pass
try:
r, s, i, l = p.opShortIntLong(0, 0, 9223372036854775807 + 1)
test(False)
except ValueError:
pass
try:
r, s, i, l = p.opShortIntLong(0, 0, -9223372036854775808 - 1)
test(False)
except ValueError:
pass
r, f, d = p.opFloatDouble(3.402823466E38, 0.0)
r, f, d = p.opFloatDouble(-3.402823466E38, 0.0)
for val in ('inf', '-inf'):
r, f, d = p.opFloatDouble(float(val), float(val))
test(math.isinf(r) and math.isinf(f) and math.isinf(d))
for val in ('nan', '-nan'):
r, f, d = p.opFloatDouble(float(val), float(val))
test(math.isnan(r) and math.isnan(f) and math.isnan(d))
try:
r, f, d = p.opFloatDouble(3.402823466E38*2, 0.0)
test(False)
except ValueError:
pass
try:
r, f, d = p.opFloatDouble(-3.402823466E38*2, 0.0)
test(False)
except ValueError:
pass
#
# opString
#
r, s = p.opString("hello", "world")
test(s == "world hello")
test(r == "hello world")
if sys.version_info[0] == 2:
r, s = p.opString(unicode("hello"), unicode("world"))
test(s == "world hello")
test(r == "hello world")
#
# opMyEnum
#
r, e = p.opMyEnum(Test.MyEnum.enum2)
test(e == Test.MyEnum.enum2)
test(r == Test.MyEnum.enum3)
#
# opMyClass
#
r, c1, c2 = p.opMyClass(p)
test(Ice.proxyIdentityAndFacetEqual(c1, p))
test(not Ice.proxyIdentityAndFacetEqual(c2, p))
test(Ice.proxyIdentityAndFacetEqual(r, p))
test(c1.ice_getIdentity() == Ice.stringToIdentity("test"))
test(c2.ice_getIdentity() == Ice.stringToIdentity("noSuchIdentity"))
test(r.ice_getIdentity() == Ice.stringToIdentity("test"))
r.opVoid()
c1.opVoid()
try:
c2.opVoid()
test(False)
except Ice.ObjectNotExistException:
pass
r, c1, c2 = p.opMyClass(None)
test(not c1)
test(c2)
test(Ice.proxyIdentityAndFacetEqual(r, p))
r.opVoid()
#
# opStruct
#
si1 = Test.Structure()
si1.p = p
si1.e = Test.MyEnum.enum3
si1.s = Test.AnotherStruct()
si1.s.s = "abc"
si2 = Test.Structure()
si2.p = None
si2.e = Test.MyEnum.enum2
si2.s = Test.AnotherStruct()
si2.s.s = "def"
rso, so = p.opStruct(si1, si2)
test(not rso.p)
test(rso.e == Test.MyEnum.enum2)
test(rso.s.s == "def")
test(so.p == p)
test(so.e == Test.MyEnum.enum3)
test(so.s.s == "a new string")
so.p.opVoid()
# Test marshalling of null structs and structs with null members.
si1 = Test.Structure()
si2 = None
rso, so = p.opStruct(si1, si2)
test(rso.p is None)
test(rso.e == Test.MyEnum.enum1)
test(rso.s.s == "")
test(so.p is None)
test(so.e == Test.MyEnum.enum1)
test(so.s.s == "a new string")
#
# opByteS
#
bsi1 = (0x01, 0x11, 0x12, 0x22)
bsi2 = (0xf1, 0xf2, 0xf3, 0xf4)
rso, bso = p.opByteS(bsi1, bsi2)
test(len(bso) == 4)
test(len(rso) == 8)
if sys.version_info[0] == 2:
test(bso[0] == '\x22')
test(bso[1] == '\x12')
test(bso[2] == '\x11')
test(bso[3] == '\x01')
test(rso[0] == '\x01')
test(rso[1] == '\x11')
test(rso[2] == '\x12')
test(rso[3] == '\x22')
test(rso[4] == '\xf1')
test(rso[5] == '\xf2')
test(rso[6] == '\xf3')
test(rso[7] == '\xf4')
else:
test(bso[0] == 0x22)
test(bso[1] == 0x12)
test(bso[2] == 0x11)
test(bso[3] == 0x01)
test(rso[0] == 0x01)
test(rso[1] == 0x11)
test(rso[2] == 0x12)
test(rso[3] == 0x22)
test(rso[4] == 0xf1)
test(rso[5] == 0xf2)
test(rso[6] == 0xf3)
test(rso[7] == 0xf4)
#
# opByteS (array)
#
bsi1 = array.array('B')
bsi1.fromlist([0x01, 0x11, 0x12, 0x22])
bsi2 = array.array('B')
bsi2.fromlist([0xf1, 0xf2, 0xf3, 0xf4])
rso, bso = p.opByteS(bsi1, bsi2)
test(len(bso) == 4)
test(len(rso) == 8)
if sys.version_info[0] == 2:
test(bso[0] == '\x22')
test(bso[1] == '\x12')
test(bso[2] == '\x11')
test(bso[3] == '\x01')
test(rso[0] == '\x01')
test(rso[1] == '\x11')
test(rso[2] == '\x12')
test(rso[3] == '\x22')
test(rso[4] == '\xf1')
test(rso[5] == '\xf2')
test(rso[6] == '\xf3')
test(rso[7] == '\xf4')
else:
test(bso[0] == 0x22)
test(bso[1] == 0x12)
test(bso[2] == 0x11)
test(bso[3] == 0x01)
test(rso[0] == 0x01)
test(rso[1] == 0x11)
test(rso[2] == 0x12)
test(rso[3] == 0x22)
test(rso[4] == 0xf1)
test(rso[5] == 0xf2)
test(rso[6] == 0xf3)
test(rso[7] == 0xf4)
#
# opBoolS
#
bsi1 = (True, True, False)
bsi2 = (False,)
rso, bso = p.opBoolS(bsi1, bsi2)
test(len(bso) == 4)
test(bso[0])
test(bso[1])
test(not bso[2])
test(not bso[3])
test(len(rso) == 3)
test(not rso[0])
test(rso[1])
test(rso[2])
#
# opBoolS (array)
#
bsi1 = array.array('B')
bsi1.fromlist([1, 1, 0])
bsi2 = array.array('B')
bsi2.fromlist([0])
rso, bso = p.opBoolS(bsi1, bsi2)
test(len(bso) == 4)
test(bso[0])
test(bso[1])
test(not bso[2])
test(not bso[3])
test(len(rso) == 3)
test(not rso[0])
test(rso[1])
test(rso[2])
#
# opShortIntLongS
#
ssi = (1, 2, 3)
isi = (5, 6, 7, 8)
lsi = (10, 30, 20)
rso, sso, iso, lso = p.opShortIntLongS(ssi, isi, lsi)
test(len(sso) == 3)
test(sso[0] == 1)
test(sso[1] == 2)
test(sso[2] == 3)
test(len(iso) == 4)
test(iso[0] == 8)
test(iso[1] == 7)
test(iso[2] == 6)
test(iso[3] == 5)
test(len(lso) == 6)
test(lso[0] == 10)
test(lso[1] == 30)
test(lso[2] == 20)
test(lso[3] == 10)
test(lso[4] == 30)
test(lso[5] == 20)
test(len(rso) == 3)
test(rso[0] == 10)
test(rso[1] == 30)
test(rso[2] == 20)
#
# opShortIntLongS (array)
#
ssi = array.array('h')
ssi.fromlist([1, 2, 3])
isi = array.array('i')
isi.fromlist([5, 6, 7, 8])
lsi = (10, 30, 20) # Can't store Ice::Long in an array.
rso, sso, iso, lso = p.opShortIntLongS(ssi, isi, lsi)
test(len(sso) == 3)
test(sso[0] == 1)
test(sso[1] == 2)
test(sso[2] == 3)
test(len(iso) == 4)
test(iso[0] == 8)
test(iso[1] == 7)
test(iso[2] == 6)
test(iso[3] == 5)
test(len(lso) == 6)
test(lso[0] == 10)
test(lso[1] == 30)
test(lso[2] == 20)
test(lso[3] == 10)
test(lso[4] == 30)
test(lso[5] == 20)
test(len(rso) == 3)
test(rso[0] == 10)
test(rso[1] == 30)
test(rso[2] == 20)
#
# opFloatDoubleS
#
fsi = (3.14, 1.11)
dsi = (1.1E10, 1.2E10, 1.3E10)
rso, fso, dso = p.opFloatDoubleS(fsi, dsi)
test(len(fso) == 2)
test(fso[0] - 3.14 < 0.001)
test(fso[1] - 1.11 < 0.001)
test(len(dso) == 3)
test(dso[0] == 1.3E10)
test(dso[1] == 1.2E10)
test(dso[2] == 1.1E10)
test(len(rso) == 5)
test(rso[0] == 1.1E10)
test(rso[1] == 1.2E10)
test(rso[2] == 1.3E10)
test(rso[3] - 3.14 < 0.001)
test(rso[4] - 1.11 < 0.001)
#
# opFloatDoubleS (array)
#
fsi = array.array('f')
fsi.fromlist([3.14, 1.11])
dsi = array.array('d')
dsi.fromlist([1.1E10, 1.2E10, 1.3E10])
rso, fso, dso = p.opFloatDoubleS(fsi, dsi)
test(len(fso) == 2)
test(fso[0] - 3.14 < 0.001)
test(fso[1] - 1.11 < 0.001)
test(len(dso) == 3)
test(dso[0] == 1.3E10)
test(dso[1] == 1.2E10)
test(dso[2] == 1.1E10)
test(len(rso) == 5)
test(rso[0] == 1.1E10)
test(rso[1] == 1.2E10)
test(rso[2] == 1.3E10)
test(rso[3] - 3.14 < 0.001)
test(rso[4] - 1.11 < 0.001)
#
# opStringS
#
ssi1 = ('abc', 'de', 'fghi')
ssi2 = ('xyz',)
rso, sso = p.opStringS(ssi1, ssi2)
test(len(sso) == 4)
test(sso[0] == "abc")
test(sso[1] == "de")
test(sso[2] == "fghi")
test(sso[3] == "xyz")
test(len(rso) == 3)
test(rso[0] == "fghi")
test(rso[1] == "de")
test(rso[2] == "abc")
#
# opByteSS
#
bsi1 = ((0x01, 0x11, 0x12), (0xff,))
bsi2 = ((0x0e,), (0xf2, 0xf1))
rso, bso = p.opByteSS(bsi1, bsi2)
test(len(bso) == 2)
test(len(bso[0]) == 1)
test(len(bso[1]) == 3)
test(len(rso) == 4)
test(len(rso[0]) == 3)
test(len(rso[1]) == 1)
test(len(rso[2]) == 1)
test(len(rso[3]) == 2)
if sys.version_info[0] == 2:
test(bso[0][0] == '\xff')
test(bso[1][0] == '\x01')
test(bso[1][1] == '\x11')
test(bso[1][2] == '\x12')
test(rso[0][0] == '\x01')
test(rso[0][1] == '\x11')
test(rso[0][2] == '\x12')
test(rso[1][0] == '\xff')
test(rso[2][0] == '\x0e')
test(rso[3][0] == '\xf2')
test(rso[3][1] == '\xf1')
else:
test(bso[0][0] == 0xff)
test(bso[1][0] == 0x01)
test(bso[1][1] == 0x11)
test(bso[1][2] == 0x12)
test(rso[0][0] == 0x01)
test(rso[0][1] == 0x11)
test(rso[0][2] == 0x12)
test(rso[1][0] == 0xff)
test(rso[2][0] == 0x0e)
test(rso[3][0] == 0xf2)
test(rso[3][1] == 0xf1)
#
# opBoolSS
#
bsi1 = ((True,), (False,), (True, True),)
bsi2 = ((False, False, True),)
rso, bso = p.opBoolSS(bsi1, bsi2)
test(len(bso) == 4)
test(len(bso[0]) == 1)
test(bso[0][0])
test(len(bso[1]) == 1)
test(not bso[1][0])
test(len(bso[2]) == 2)
test(bso[2][0])
test(bso[2][1])
test(len(bso[3]) == 3)
test(not bso[3][0])
test(not bso[3][1])
test(bso[3][2])
test(len(rso) == 3)
test(len(rso[0]) == 2)
test(rso[0][0])
test(rso[0][1])
test(len(rso[1]) == 1)
test(not rso[1][0])
test(len(rso[2]) == 1)
test(rso[2][0])
#
# opShortIntLongSS
#
ssi = ((1,2,5), (13,), ())
isi = ((24, 98), (42,))
lsi = ((496, 1729),)
rso, sso, iso, lso = p.opShortIntLongSS(ssi, isi, lsi)
test(len(rso) == 1)
test(len(rso[0]) == 2)
test(rso[0][0] == 496)
test(rso[0][1] == 1729)
test(len(sso) == 3)
test(len(sso[0]) == 3)
test(sso[0][0] == 1)
test(sso[0][1] == 2)
test(sso[0][2] == 5)
test(len(sso[1]) == 1)
test(sso[1][0] == 13)
test(len(sso[2]) == 0)
test(len(iso) == 2)
test(len(iso[0]) == 1)
test(iso[0][0] == 42)
test(len(iso[1]) == 2)
test(iso[1][0] == 24)
test(iso[1][1] == 98)
test(len(lso) == 2)
test(len(lso[0]) == 2)
test(lso[0][0] == 496)
test(lso[0][1] == 1729)
test(len(lso[1]) == 2)
test(lso[1][0] == 496)
test(lso[1][1] == 1729)
#
# opFloatDoubleSS
#
fsi = ((3.14,), (1.11,), ())
dsi = ((1.1E10, 1.2E10, 1.3E10),)
rso, fso, dso = p.opFloatDoubleSS(fsi, dsi)
test(len(fso) == 3)
test(len(fso[0]) == 1)
test(fso[0][0] - 3.14 < 0.001)
test(len(fso[1]) == 1)
test(fso[1][0] - 1.11 < 0.001)
test(len(fso[2]) == 0)
test(len(dso) == 1)
test(len(dso[0]) == 3)
test(dso[0][0] == 1.1E10)
test(dso[0][1] == 1.2E10)
test(dso[0][2] == 1.3E10)
test(len(rso) == 2)
test(len(rso[0]) == 3)
test(rso[0][0] == 1.1E10)
test(rso[0][1] == 1.2E10)
test(rso[0][2] == 1.3E10)
test(len(rso[1]) == 3)
test(rso[1][0] == 1.1E10)
test(rso[1][1] == 1.2E10)
test(rso[1][2] == 1.3E10)
#
# opStringSS
#
ssi1 = (('abc',), ('de', 'fghi'))
ssi2 = ((), (), ('xyz',))
rso, sso = p.opStringSS(ssi1, ssi2)
test(len(sso) == 5)
test(len(sso[0]) == 1)
test(sso[0][0] == "abc")
test(len(sso[1]) == 2)
test(sso[1][0] == "de")
test(sso[1][1] == "fghi")
test(len(sso[2]) == 0)
test(len(sso[3]) == 0)
test(len(sso[4]) == 1)
test(sso[4][0] == "xyz")
test(len(rso) == 3)
test(len(rso[0]) == 1)
test(rso[0][0] == "xyz")
test(len(rso[1]) == 0)
test(len(rso[2]) == 0)
#
# opStringSSS
#
sssi1 = ((('abc', 'de'), ('xyz',)), (('hello',),))
sssi2 = ((('', ''), ('abcd',)), (('',),), ())
rsso, ssso = p.opStringSSS(sssi1, sssi2)
test(len(ssso) == 5)
test(len(ssso[0]) == 2)
test(len(ssso[0][0]) == 2)
test(len(ssso[0][1]) == 1)
test(len(ssso[1]) == 1)
test(len(ssso[1][0]) == 1)
test(len(ssso[2]) == 2)
test(len(ssso[2][0]) == 2)
test(len(ssso[2][1]) == 1)
test(len(ssso[3]) == 1)
test(len(ssso[3][0]) == 1)
test(len(ssso[4]) == 0)
test(ssso[0][0][0] == "abc")
test(ssso[0][0][1] == "de")
test(ssso[0][1][0] == "xyz")
test(ssso[1][0][0] == "hello")
test(ssso[2][0][0] == "")
test(ssso[2][0][1] == "")
test(ssso[2][1][0] == "abcd")
test(ssso[3][0][0] == "")
test(len(rsso) == 3)
test(len(rsso[0]) == 0)
test(len(rsso[1]) == 1)
test(len(rsso[1][0]) == 1)
test(len(rsso[2]) == 2)
test(len(rsso[2][0]) == 2)
test(len(rsso[2][1]) == 1)
test(rsso[1][0][0] == "")
test(rsso[2][0][0] == "")
test(rsso[2][0][1] == "")
test(rsso[2][1][0] == "abcd")
#
# opByteBoolD
#
di1 = {10: True, 100: False}
di2 = {10: True, 11: False, 101: True}
ro, do = p.opByteBoolD(di1, di2)
test(do == di1)
test(len(ro) == 4)
test(ro[10])
test(not ro[11])
test(not ro[100])
test(ro[101])
#
# opShortIntD
#
di1 = {110: -1, 1100: 123123}
di2 = {110: -1, 111: -100, 1101: 0}
ro, do = p.opShortIntD(di1, di2)
test(do == di1)
test(len(ro) == 4)
test(ro[110] == -1)
test(ro[111] == -100)
test(ro[1100] == 123123)
test(ro[1101] == 0)
#
# opLongFloatD
#
di1 = {999999110: -1.1, 999999111: 123123.2}
di2 = {999999110: -1.1, 999999120: -100.4, 999999130: 0.5}
ro, do = p.opLongFloatD(di1, di2)
for k in do:
test(math.fabs(do[k] - di1[k]) < 0.01)
test(len(ro) == 4)
test(ro[999999110] - -1.1 < 0.01)
test(ro[999999120] - -100.4 < 0.01)
test(ro[999999111] - 123123.2 < 0.01)
test(ro[999999130] - 0.5 < 0.01)
#
# opStringStringD
#
di1 = {'foo': 'abc -1.1', 'bar': 'abc 123123.2'}
di2 = {'foo': 'abc -1.1', 'FOO': 'abc -100.4', 'BAR': 'abc 0.5'}
ro, do = p.opStringStringD(di1, di2)
test(do == di1)
test(len(ro) == 4)
test(ro["foo"] == "abc -1.1")
test(ro["FOO"] == "abc -100.4")
test(ro["bar"] == "abc 123123.2")
test(ro["BAR"] == "abc 0.5")
#
# opStringMyEnumD
#
di1 = {'abc': Test.MyEnum.enum1, '': Test.MyEnum.enum2}
di2 = {'abc': Test.MyEnum.enum1, 'qwerty': Test.MyEnum.enum3, 'Hello!!': Test.MyEnum.enum2}
ro, do = p.opStringMyEnumD(di1, di2)
test(do == di1)
test(len(ro) == 4)
test(ro["abc"] == Test.MyEnum.enum1)
test(ro["qwerty"] == Test.MyEnum.enum3)
test(ro[""] == Test.MyEnum.enum2)
test(ro["Hello!!"] == Test.MyEnum.enum2)
#
# opMyEnumStringD
#
di1 = {Test.MyEnum.enum1: 'abc'}
di2 = {Test.MyEnum.enum2: 'Hello!!', Test.MyEnum.enum3: 'qwerty'}
ro, do = p.opMyEnumStringD(di1, di2)
test(do == di1)
test(len(ro) == 3)
test(ro[Test.MyEnum.enum1] == "abc")
test(ro[Test.MyEnum.enum2] == "Hello!!")
test(ro[Test.MyEnum.enum3] == "qwerty")
#
# opMyStructMyEnumD
#
s11 = Test.MyStruct()
s11.i = 1
s11.j = 1
s12 = Test.MyStruct()
s12.i = 1
s12.j = 2
s22 = Test.MyStruct()
s22.i = 2
s22.j = 2
s23 = Test.MyStruct()
s23.i = 2
s23.j = 3
di1 = {s11: Test.MyEnum.enum1, s12: Test.MyEnum.enum2}
di2 = {s11: Test.MyEnum.enum1, s22: Test.MyEnum.enum3, s23: Test.MyEnum.enum2}
ro, do = p.opMyStructMyEnumD(di1, di2)
test(do == di1)
test(len(ro) == 4)
test(ro[s11] == Test.MyEnum.enum1)
test(ro[s12] == Test.MyEnum.enum2)
test(ro[s22] == Test.MyEnum.enum3)
test(ro[s23] == Test.MyEnum.enum2)
#
# opByteBoolDS
#
dsi1 = ({ 10: True, 100: False }, { 10: True, 11: False, 101: True })
dsi2 = ({ 100: False, 101: False },)
ro, do = p.opByteBoolDS(dsi1, dsi2)
test(len(ro) == 2)
test(len(ro[0]) == 3)
test(ro[0][10])
test(not ro[0][11])
test(ro[0][101])
test(len(ro[1]) == 2)
test(ro[1][10])
test(not ro[1][100])
test(len(do) == 3)
test(len(do[0]) == 2)
test(not do[0][100])
test(not do[0][101])
test(len(do[1]) == 2)
test(do[1][10])
test(not do[1][100])
test(len(do[2]) == 3)
test(do[2][10])
test(not do[2][11])
test(do[2][101])
#
# opShortIntDS
#
dsi1 = ({ 110: -1, 1100: 123123 }, { 110: -1, 111: -100, 1101: 0 })
dsi2 = ({ 100: -1001 },)
ro, do = p.opShortIntDS(dsi1, dsi2)
test(len(ro) == 2)
test(len(ro[0]) == 3)
test(ro[0][110] == -1)
test(ro[0][111] == -100)
test(ro[0][1101] == 0)
test(len(ro[1]) == 2)
test(ro[1][110] == -1)
test(ro[1][1100] == 123123)
test(len(do) == 3)
test(len(do[0]) == 1)
test(do[0][100] == -1001)
test(len(do[1]) == 2)
test(do[1][110] == -1)
test(do[1][1100] == 123123)
test(len(do[2]) == 3)
test(do[2][110] == -1)
test(do[2][111] == -100)
test(do[2][1101] == 0)
#
# opLongFloatDS
#
dsi1 = ({ 999999110: -1.1, 999999111: 123123.2 }, { 999999110: -1.1, 999999120: -100.4, 999999130: 0.5 })
dsi2 = ({ 999999140: 3.14 },)
ro, do = p.opLongFloatDS(dsi1, dsi2)
test(len(ro) == 2)
test(len(ro[0]) == 3)
test(ro[0][999999110] - -1.1 < 0.01)
test(ro[0][999999120] - -100.4 < 0.01)
test(ro[0][999999130] - 0.5 < 0.01)
test(len(ro[1]) == 2)
test(ro[1][999999110] - -1.1 < 0.01)
test(ro[1][999999111] - 123123.2 < 0.01)
test(len(do) == 3)
test(len(do[0]) == 1)
test(do[0][999999140] - 3.14 < 0.01)
test(len(do[1]) == 2)
test(do[1][999999110] - -1.1 < 0.01)
test(do[1][999999111] - 123123.2 < 0.01)
test(len(do[2]) == 3)
test(do[2][999999110] - -1.1 < 0.01)
test(do[2][999999120] - -100.4 < 0.01)
test(do[2][999999130] - 0.5 < 0.01)
#
# opStringStringDS
#
dsi1 = ({ "foo": "abc -1.1", "bar": "abc 123123.2" }, { "foo": "abc -1.1", "FOO": "abc -100.4", "BAR": "abc 0.5" })
dsi2 = ({ "f00": "ABC -3.14" },)
ro, do = p.opStringStringDS(dsi1, dsi2)
test(len(ro) == 2)
test(len(ro[0]) == 3)
test(ro[0]["foo"] == "abc -1.1")
test(ro[0]["FOO"] == "abc -100.4")
test(ro[0]["BAR"] == "abc 0.5")
test(len(ro[1]) == 2)
test(ro[1]["foo"] == "abc -1.1")
test(ro[1]["bar"] == "abc 123123.2")
test(len(do) == 3)
test(len(do[0]) == 1)
test(do[0]["f00"] == "ABC -3.14")
test(len(do[1]) == 2)
test(do[1]["foo"] == "abc -1.1")
test(do[1]["bar"] == "abc 123123.2")
test(len(do[2]) == 3)
test(do[2]["foo"] == "abc -1.1")
test(do[2]["FOO"] == "abc -100.4")
test(do[2]["BAR"] == "abc 0.5")
#
# opStringMyEnumDS
#
dsi1 = (
{ "abc": Test.MyEnum.enum1, "": Test.MyEnum.enum2 },
{ "abc": Test.MyEnum.enum1, "qwerty": Test.MyEnum.enum3, "Hello!!": Test.MyEnum.enum2 }
)
dsi2 = ({ "Goodbye": Test.MyEnum.enum1 },)
ro, do = p.opStringMyEnumDS(dsi1, dsi2)
test(len(ro) == 2)
test(len(ro[0]) == 3)
test(ro[0]["abc"] == Test.MyEnum.enum1)
test(ro[0]["qwerty"] == Test.MyEnum.enum3)
test(ro[0]["Hello!!"] == Test.MyEnum.enum2)
test(len(ro[1]) == 2)
test(ro[1]["abc"] == Test.MyEnum.enum1)
test(ro[1][""] == Test.MyEnum.enum2)
test(len(do) == 3)
test(len(do[0]) == 1)
test(do[0]["Goodbye"] == Test.MyEnum.enum1)
test(len(do[1]) == 2)
test(do[1]["abc"] == Test.MyEnum.enum1)
test(do[1][""] == Test.MyEnum.enum2)
test(len(do[2]) == 3)
test(do[2]["abc"] == Test.MyEnum.enum1)
test(do[2]["qwerty"] == Test.MyEnum.enum3)
test(do[2]["Hello!!"] == Test.MyEnum.enum2)
#
# opMyEnumStringDS
#
dsi1 = ({ Test.MyEnum.enum1: 'abc' }, { Test.MyEnum.enum2: 'Hello!!', Test.MyEnum.enum3: 'qwerty'})
dsi2 = ({ Test.MyEnum.enum1: 'Goodbye' },)
ro, do = p.opMyEnumStringDS(dsi1, dsi2)
test(len(ro) == 2)
test(len(ro[0]) == 2)
test(ro[0][Test.MyEnum.enum2] == "Hello!!")
test(ro[0][Test.MyEnum.enum3] == "qwerty")
test(len(ro[1]) == 1)
test(ro[1][Test.MyEnum.enum1] == "abc")
test(len(do) == 3)
test(len(do[0]) == 1)
test(do[0][Test.MyEnum.enum1] == "Goodbye")
test(len(do[1]) == 1)
test(do[1][Test.MyEnum.enum1] == "abc")
test(len(do[2]) == 2)
test(do[2][Test.MyEnum.enum2] == "Hello!!")
test(do[2][Test.MyEnum.enum3] == "qwerty")
#
# opMyStructMyEnumDS
#
s11 = Test.MyStruct(1, 1)
s12 = Test.MyStruct(1, 2)
s22 = Test.MyStruct(2, 2)
s23 = Test.MyStruct(2, 3)
dsi1 = (
{ s11: Test.MyEnum.enum1, s12: Test.MyEnum.enum2 },
{ s11: Test.MyEnum.enum1, s22: Test.MyEnum.enum3, s23: Test.MyEnum.enum2 }
)
dsi2 = ({ s23: Test.MyEnum.enum3 },)
ro, do = p.opMyStructMyEnumDS(dsi1, dsi2)
test(len(ro) == 2)
test(len(ro[0]) == 3)
test(ro[0][s11] == Test.MyEnum.enum1)
test(ro[0][s22] == Test.MyEnum.enum3)
test(ro[0][s23] == Test.MyEnum.enum2)
test(len(ro[1]) == 2)
test(ro[1][s11] == Test.MyEnum.enum1)
test(ro[1][s12] == Test.MyEnum.enum2)
test(len(do) == 3)
test(len(do[0]) == 1)
test(do[0][s23] == Test.MyEnum.enum3)
test(len(do[1]) == 2)
test(do[1][s11] == Test.MyEnum.enum1)
test(do[1][s12] == Test.MyEnum.enum2)
test(len(do[2]) == 3)
test(do[2][s11] == Test.MyEnum.enum1)
test(do[2][s22] == Test.MyEnum.enum3)
test(do[2][s23] == Test.MyEnum.enum2)
#
#opByteByteSD
#
sdi1 = { 0x01: (0x01, 0x11), 0x22: (0x12,) }
sdi2 = { 0xf1: (0xf2, 0xf3) }
ro, do = p.opByteByteSD(sdi1, sdi2)
if sys.version_info[0] == 2:
test(len(do) == 1)
test(len(do[0xf1]) == 2)
test(do[0xf1][0] == '\xf2')
test(do[0xf1][1] == '\xf3')
test(len(ro) == 3)
test(len(ro[0x01]) == 2)
test(ro[0x01][0] == '\x01')
test(ro[0x01][1] == '\x11')
test(len(ro[0x22]) == 1)
test(ro[0x22][0] == '\x12')
test(len(ro[0xf1]) == 2)
test(ro[0xf1][0] == '\xf2')
test(ro[0xf1][1] == '\xf3')
else:
test(len(do) == 1)
test(len(do[0xf1]) == 2)
test(do[0xf1][0] == 0xf2)
test(do[0xf1][1] == 0xf3)
test(len(ro) == 3)
test(len(ro[0x01]) == 2)
test(ro[0x01][0] == 0x01)
test(ro[0x01][1] == 0x11)
test(len(ro[0x22]) == 1)
test(ro[0x22][0] == 0x12)
test(len(ro[0xf1]) == 2)
test(ro[0xf1][0] == 0xf2)
test(ro[0xf1][1] == 0xf3)
#
# opBoolBoolSD
#
sdi1 = { False: (True, False), True: (False, True, True) }
sdi2 = { False: (True, False) }
ro, do = p.opBoolBoolSD(sdi1, sdi2)
test(len(do) == 1)
test(len(do[False]) == 2)
test(do[False][0])
test(not do[False][1])
test(len(ro) == 2)
test(len(ro[False]) == 2)
test(ro[False][0])
test(not ro[False][1])
test(len(ro[True]) == 3)
test(not ro[True][0])
test(ro[True][1])
test(ro[True][2])
#
# opShortShortSD
#
sdi1 = { 1: (1, 2, 3), 2: (4, 5) }
sdi2 = { 4: (6, 7) }
ro, do = p.opShortShortSD(sdi1, sdi2)
test(len(do) == 1)
test(len(do[4]) == 2)
test(do[4][0] == 6)
test(do[4][1] == 7)
test(len(ro) == 3)
test(len(ro[1]) == 3)
test(ro[1][0] == 1)
test(ro[1][1] == 2)
test(ro[1][2] == 3)
test(len(ro[2]) == 2)
test(ro[2][0] == 4)
test(ro[2][1] == 5)
test(len(ro[4]) == 2)
test(ro[4][0] == 6)
test(ro[4][1] == 7)
#
# opIntIntSD
#
sdi1 = { 100: (100, 200, 300), 200: (400, 500) }
sdi2 = { 400: (600, 700) }
ro, do = p.opIntIntSD(sdi1, sdi2)
test(len(do) == 1)
test(len(do[400]) == 2)
test(do[400][0] == 600)
test(do[400][1] == 700)
test(len(ro) == 3)
test(len(ro[100]) == 3)
test(ro[100][0] == 100)
test(ro[100][1] == 200)
test(ro[100][2] == 300)
test(len(ro[200]) == 2)
test(ro[200][0] == 400)
test(ro[200][1] == 500)
test(len(ro[400]) == 2)
test(ro[400][0] == 600)
test(ro[400][1] == 700)
#
# opLongLongSD
#
sdi1 = { 999999990: (999999110, 999999111, 999999110), 999999991: (999999120, 999999130) }
sdi2 = { 999999992: (999999110, 999999120) }
ro, do = p.opLongLongSD(sdi1, sdi2)
test(len(do) == 1)
test(len(do[999999992]) == 2)
test(do[999999992][0] == 999999110)
test(do[999999992][1] == 999999120)
test(len(ro) == 3)
test(len(ro[999999990]) == 3)
test(ro[999999990][0] == 999999110)
test(ro[999999990][1] == 999999111)
test(ro[999999990][2] == 999999110)
test(len(ro[999999991]) == 2)
test(ro[999999991][0] == 999999120)
test(ro[999999991][1] == 999999130)
test(len(ro[999999992]) == 2)
test(ro[999999992][0] == 999999110)
test(ro[999999992][1] == 999999120)
#
# opStringFloatSD
#
sdi1 = { "abc": (-1.1, 123123.2, 100.0), "ABC": (42.24, -1.61) }
sdi2 = { "aBc": (-3.14, 3.14) }
ro, do = p.opStringFloatSD(sdi1, sdi2)
test(len(do) == 1)
test(len(do["aBc"]) == 2)
test(do["aBc"][0] - -3.14 < 0.01)
test(do["aBc"][1] - 3.14 < 0.01)
test(len(ro) == 3)
test(len(ro["abc"]) == 3)
test(ro["abc"][0] - -1.1 < 0.01)
test(ro["abc"][1] - 123123.2 < 0.01)
test(ro["abc"][2] - 100.0 < 0.01)
test(len(ro["ABC"]) == 2)
test(ro["ABC"][0] - 42.24 < 0.01)
test(ro["ABC"][1] - -1.61 < 0.01)
test(len(ro["aBc"]) == 2)
test(ro["aBc"][0] - -3.14 < 0.01)
test(ro["aBc"][1] - 3.14 < 0.01)
#
# opStringDoubleSD
#
sdi1 = { "Hello!!": (1.1E10, 1.2E10, 1.3E10), "Goodbye": (1.4E10, 1.5E10) }
sdi2 = { "": (1.6E10, 1.7E10) }
ro, do = p.opStringDoubleSD(sdi1, sdi2)
test(len(do) == 1)
test(len(do[""]) == 2)
test(do[""][0] == 1.6E10)
test(do[""][1] == 1.7E10)
test(len(ro) == 3)
test(len(ro["Hello!!"]) == 3)
test(ro["Hello!!"][0] == 1.1E10)
test(ro["Hello!!"][1] == 1.2E10)
test(ro["Hello!!"][2] == 1.3E10)
test(len(ro["Goodbye"]) == 2)
test(ro["Goodbye"][0] == 1.4E10)
test(ro["Goodbye"][1] == 1.5E10)
test(len(ro[""]) == 2)
test(ro[""][0] == 1.6E10)
test(ro[""][1] == 1.7E10)
#
# opStringStringSD
#
sdi1 = { "abc": ("abc", "de", "fghi") , "def": ("xyz", "or") }
sdi2 = { "ghi": ("and", "xor") }
ro, do = p.opStringStringSD(sdi1, sdi2)
test(len(do) == 1)
test(len(do["ghi"]) == 2)
test(do["ghi"][0] == "and")
test(do["ghi"][1] == "xor")
test(len(ro) == 3)
test(len(ro["abc"]) == 3)
test(ro["abc"][0] == "abc")
test(ro["abc"][1] == "de")
test(ro["abc"][2] == "fghi")
test(len(ro["def"]) == 2)
test(ro["def"][0] == "xyz")
test(ro["def"][1] == "or")
test(len(ro["ghi"]) == 2)
test(ro["ghi"][0] == "and")
test(ro["ghi"][1] == "xor")
#
# opMyEnumMyEnumSD
#
sdi1 = {
Test.MyEnum.enum3: (Test.MyEnum.enum1, Test.MyEnum.enum1, Test.MyEnum.enum2),
Test.MyEnum.enum2: (Test.MyEnum.enum1, Test.MyEnum.enum2)
}
sdi2 = { Test.MyEnum.enum1: (Test.MyEnum.enum3, Test.MyEnum.enum3) }
ro, do = p.opMyEnumMyEnumSD(sdi1, sdi2)
test(len(do) == 1)
test(len(do[Test.MyEnum.enum1]) == 2)
test(do[Test.MyEnum.enum1][0] == Test.MyEnum.enum3)
test(do[Test.MyEnum.enum1][1] == Test.MyEnum.enum3)
test(len(ro) == 3)
test(len(ro[Test.MyEnum.enum3]) == 3)
test(ro[Test.MyEnum.enum3][0] == Test.MyEnum.enum1)
test(ro[Test.MyEnum.enum3][1] == Test.MyEnum.enum1)
test(ro[Test.MyEnum.enum3][2] == Test.MyEnum.enum2)
test(len(ro[Test.MyEnum.enum2]) == 2)
test(ro[Test.MyEnum.enum2][0] == Test.MyEnum.enum1)
test(ro[Test.MyEnum.enum2][1] == Test.MyEnum.enum2)
test(len(ro[Test.MyEnum.enum1]) == 2)
test(ro[Test.MyEnum.enum1][0] == Test.MyEnum.enum3)
test(ro[Test.MyEnum.enum1][1] == Test.MyEnum.enum3)
#
# opIntS
#
lengths = ( 0, 1, 2, 126, 127, 128, 129, 253, 254, 255, 256, 257, 1000 )
for l in lengths:
s = []
for i in range(l):
s.append(i)
r = p.opIntS(s)
test(len(r) == l)
for j in range(len(r)):
test(r[j] == -j)
#
# opContext
#
ctx = {'one': 'ONE', 'two': 'TWO', 'three': 'THREE'}
r = p.opContext()
test(len(p.ice_getContext()) == 0)
test(r != ctx)
r = p.opContext(ctx)
test(len(p.ice_getContext()) == 0)
test(r == ctx)
p2 = Test.MyClassPrx.checkedCast(p.ice_context(ctx))
test(p2.ice_getContext() == ctx)
r = p2.opContext()
test(r == ctx)
r = p2.opContext(ctx)
test(r == ctx)
#
# Test implicit context propagation
#
if p.ice_getConnection():
impls = ( 'Shared', 'PerThread' )
for i in impls:
initData = Ice.InitializationData()
initData.properties = communicator.getProperties().clone()
initData.properties.setProperty('Ice.ImplicitContext', i)
ic = Ice.initialize(data=initData)
ctx = {'one': 'ONE', 'two': 'TWO', 'three': 'THREE'}
p1 = Test.MyClassPrx.uncheckedCast(ic.stringToProxy('test:default -p 12010'))
ic.getImplicitContext().setContext(ctx)
test(ic.getImplicitContext().getContext() == ctx)
test(p1.opContext() == ctx)
test(ic.getImplicitContext().containsKey('zero') == False)
r = ic.getImplicitContext().put('zero', 'ZERO')
test(r == '')
test(ic.getImplicitContext().containsKey('zero') == True)
test(ic.getImplicitContext().get('zero') == 'ZERO')
ctx = ic.getImplicitContext().getContext()
test(p1.opContext() == ctx)
prxContext = {'one': 'UN', 'four': 'QUATRE'}
combined = ctx.copy()
combined.update(prxContext)
test(combined['one'] == 'UN')
p2 = Test.MyClassPrx.uncheckedCast(p1.ice_context(prxContext))
ic.getImplicitContext().setContext({})
test(p2.opContext() == prxContext)
ic.getImplicitContext().setContext(ctx)
test(p2.opContext() == combined)
test(ic.getImplicitContext().remove('one') == 'ONE')
ic.destroy()
d = 1278312346.0 / 13.0
ds = []
for i in range(5):
ds.append(d)
p.opDoubleMarshaling(d, ds)
#
# opIdempotent
#
p.opIdempotent()
#
# opNonmutating
#
p.opNonmutating()
test(p.opByte1(0xFF) == 0xFF)
test(p.opShort1(0x7FFF) == 0x7FFF)
test(p.opInt1(0x7FFFFFFF) == 0x7FFFFFFF)
test(p.opLong1(0x7FFFFFFFFFFFFFFF) == 0x7FFFFFFFFFFFFFFF)
test(p.opFloat1(1.0) == 1.0)
test(p.opDouble1(1.0) == 1.0)
test(p.opString1("opString1") == "opString1")
test(len(p.opStringS1(None)) == 0)
test(len(p.opByteBoolD1(None)) == 0)
test(len(p.opStringS2(None)) == 0)
test(len(p.opByteBoolD2(None)) == 0)
d = Test.MyDerivedClassPrx.uncheckedCast(p)
s = Test.MyStruct1()
s.tesT = "Test.MyStruct1.s"
s.myClass = None
s.myStruct1 = "Test.MyStruct1.myStruct1"
s = d.opMyStruct1(s)
test(s.tesT == "Test.MyStruct1.s")
test(s.myClass == None)
test(s.myStruct1 == "Test.MyStruct1.myStruct1")
c = Test.MyClass1()
c.tesT = "Test.MyClass1.testT"
c.myClass = None
c.myClass1 = "Test.MyClass1.myClass1"
c = d.opMyClass1(c)
test(c.tesT == "Test.MyClass1.testT")
test(c.myClass == None)
test(c.myClass1 == "Test.MyClass1.myClass1")
p1 = p.opMStruct1()
p1.e = Test.MyEnum.enum3
(p3, p2) = p.opMStruct2(p1)
test(p2 == p1 and p3 == p1)
p.opMSeq1()
p1 = ["test"]
(p3, p2) = p.opMSeq2(p1)
test(p2[0] == "test" and p3[0] == "test")
p.opMDict1()
p1 = { "test": "test" }
(p3, p2) = p.opMDict2(p1)
test(p3["test"] == "test" and p2["test"] == "test")
if '-kern' in args:
fullarg = args[args.index("-kern")+1]
kerntype = fullarg[:fullarg.rfind('_')]
print kerntype
dist = float(fullarg[fullarg.rfind('_')+1:])
print dist
else:
kerntype = 'quartic'
dist = 900000.0
except:
print "Kernel Argument is not formmated correctly"
print "it should be something like quartic_900000 or epanech_800000 (units must be meters)"
print "run with -help for more options"
sys.exit("Error")
Test.test(f, rf_std_in, b_direct, ulist, kerntype)
#except:
# print "ERROR: THERE WAS A PROBLEM INTERPRETING THE ARGUMENTS"
# print "Must Specify -mode"
# print "Execute GWRMain.py -help for information"
elif "-help" in sys.argv:
print "---------------------"
print "MODE ARGUMENTS"
print "-mode"
print "db_load ((-tf OR -df OR -tstf), -conn, -tbl)"
print "Build_ref_files (-tf, -rf_std_out, -rf_obs_out, -wordlist(OPTIONAL))"
print "NOT FUNCTIONAL: Create_Wu ((-tf OR -df OR -tstf), -kern, -ulist, -wu_dir_out)"
print "NOT FUNCTIONAL: Create_Y ((-tf OR -df OR -tstf), -ulist, -y_dir_out)"
print "Create_Wu_Y (-ptbl, -conn, -pointgrid(OPTIONAL), -kern(OPTIONAL), -zeroed(OPTOINAL), -ulist, -wu_y_dir_out, -rf_obs_in)"
# Based on iwidgets2.2.0/tests/dialog.test code.
import sys
import Tkinter
import Test
import Pmw
Test.initialise()
if Tkinter.TkVersion >= 8.3:
version = sys.version_info
if version[0] > 2 or (version[0] == 2 and version[1] > 0):
expected1 = "AttributeError: Dialog instance has no attribute 'bogus'"
else:
expected1 = "AttributeError: 'Dialog' instance has no attribute 'bogus'"
else:
expected1 = 'AttributeError: bogus'
c = Pmw.Dialog
def _addListbox():
global _lb
w = Test.currentWidget()
_lb = Tkinter.Listbox(w.interior(), relief='sunken')
_lb.pack(fill='both', expand='yes')
def _addListEntry(text):
_lb.insert('end', text)
def _getTopPageName():
w = Test.currentWidget()
return w._topPageName
def _addListbox():
global _lb
w = Test.currentWidget()
_lb = Tkinter.Listbox(w.interior(), relief='sunken')
_lb.pack(fill='both', expand='yes')
targetE.append([1,0,0,0,0]) #Values inputsTraining = array(inputT) targetTraining = array(targetT) inputsEvaluting = array(valuate) targetEvaluting = array(targetE) #Neural network inputNodes = 900 hiddenLayers = (60,) outputNodes = 5 # Maximun and minimun value for wieght matrix maxVal = 0.5 minVal = -0.5 doTraining = True # If it is true it will do the training, in other case it loads the old matrix. ''''''''''''''''''''''''''''''''''''''''''''''''''''''''' '' End parameters to configure ''''''''''''''''''''''''''''''''''''''''''''''''''''''''' weightMatrices = Test.get_weight_matrices(inputNodes,hiddenLayers,outputNodes,maxVal,minVal) test = Test(inputsTraining,targetTraining,inputsEvaluting,targetEvaluting,20,0.1) test.test(inputNodes,hiddenLayers,outputNodes,weightMatrices,doTraining)
def _test_deactivate(result):
w = Test.currentWidget()
w.after(Test.delay() + 4000,
lambda widget=w, r=result: widget.deactivate(r))
def opMG1(self, current):
return Ice.Future.completed(
Test.Initial.OpMG1MarshaledResult(Test.G(), current))
def SBaseAsSBase(self, current=None):
sb = Test.SBase()
sb.sb = "SBase.sb"
return sb
import Test
from Plex import *
import sys
lex = Lexicon([
(Seq(Any("ab"), Rep(Any("ab01"))), 'ident'),
(Seq(Any("01"), Rep(Any("01"))), 'num'),
(Any(' \n'), IGNORE),
(Str("abba"), 'abba'),
(Any('([{!"#') + Rep(AnyBut('!"#}])')) + Any('!"#}])'), IGNORE)
],
debug = Test.debug,
timings = sys.stderr
)
Test.run(lex, "test2", debug = 0, trace = 0)
def opOptionalException(self, a, b, o, current=None):
f = Ice.Future()
f.set_exception(Test.OptionalException(False, a, b, o))
return f
if len(sys.argv) != 2:
usageExit()
testName = sys.argv[1]
if testName not in tests:
print 'Unknown test "' + testName + '"'
usageExit()
if testName == 'reinitialise_test':
# Run this by itself, since it calls Tkinter.Tk, mainloop, etc.
reinitialise_test()
sys.exit()
# Use Pmw version in this distribution:
Test.initialise()
root = Test.root
root.deiconify()
# To use a different version of Pmw, comment out the three above lines
# and the "import Test" line and uncomment these three:
# root = Tkinter.Tk()
# Pmw.setversion('1.0')
# Pmw.initialise(root)
testFunction = locals()[testName]
testFunction()
if testName != 'memoryleak2_test':
# This does not use mainloop.
root.mainloop()
def opDerivedException(self, a, b, o, current=None):
f = Ice.Future()
f.set_exception(Test.DerivedException(False, a, b, o, b, o))
return f
# Based on iwidgets2.2.0/tests/entryfield.test code.
import tkinter
import Test
import Pmw
Test.initialise()
_myValidators = {"hello": (lambda s: s == "hello", len)}
c = Pmw.EntryField
kw_1 = {"entry_width": 12, "labelpos": "n", "label_text": "Entry Field:"}
tests_1 = (
(c.pack, (), {"padx": 10, "pady": 10, "fill": "both", "expand": 1}),
(Test.num_options, (), 10),
("errorbackground", "red"),
("hull_background", "yellow"),
("label_background", "yellow"),
("entry_background", "yellow"),
("hull_show", "X", 'TclError: unknown option "-show"'),
("entry_show", ""),
("entry_borderwidth", 4),
("entry_borderwidth", 2),
("command", Test.callback),
("hull_cursor", "gumby"),
("entry_exportselection", 0),
("label_foreground", "Green"),
("entry_foreground", "Green"),
("label_foreground", "Black"),
("entry_foreground", "Black"),
def twowaysNewAMI(communicator, p):
cb = Callback()
p.begin_ice_ping(cb.ping, cb.exCB)
cb.check()
cb = Callback()
p.begin_ice_isA(Test.MyClass.ice_staticId(), cb.isA, cb.exCB)
cb.check()
cb = Callback()
p.begin_ice_id(cb.id, cb.exCB)
cb.check()
cb = Callback()
p.begin_ice_ids(cb.ids, cb.exCB)
cb.check()
r = p.begin_opVoid()
p.end_opVoid(r)
cb = Callback()
p.begin_opVoid(cb.opVoid, cb.exCB)
cb.check()
r = p.begin_opByte(0xff, 0x0f)
(ret, p3) = p.end_opByte(r)
test(p3 == 0xf0)
test(ret == 0xff)
cb = Callback()
p.begin_opByte(0xff, 0x0f, cb.opByte, cb.exCB)
cb.check()
cb = Callback()
p.begin_opBool(True, False, cb.opBool, cb.exCB)
cb.check()
cb = Callback()
p.begin_opShortIntLong(10, 11, 12, cb.opShortIntLong, cb.exCB)
cb.check()
cb = Callback()
p.begin_opFloatDouble(3.14, 1.1E10, cb.opFloatDouble, cb.exCB)
cb.check()
cb = Callback()
p.begin_opString("hello", "world", cb.opString, cb.exCB)
cb.check()
cb = Callback()
p.begin_opMyEnum(Test.MyEnum.enum2, cb.opMyEnum, cb.exCB)
cb.check()
cb = Callback(communicator)
p.begin_opMyClass(p, cb.opMyClass, cb.exCB)
cb.check()
si1 = Test.Structure()
si1.p = p
si1.e = Test.MyEnum.enum3
si1.s = Test.AnotherStruct()
si1.s.s = "abc"
si2 = Test.Structure()
si2.p = None
si2.e = Test.MyEnum.enum2
si2.s = Test.AnotherStruct()
si2.s.s = "def"
cb = Callback(communicator)
p.begin_opStruct(si1, si2, cb.opStruct, cb.exCB)
cb.check()
bsi1 = (0x01, 0x11, 0x12, 0x22)
bsi2 = (0xf1, 0xf2, 0xf3, 0xf4)
cb = Callback()
p.begin_opByteS(bsi1, bsi2, cb.opByteS, cb.exCB)
cb.check()
bsi1 = (True, True, False)
bsi2 = (False, )
cb = Callback()
p.begin_opBoolS(bsi1, bsi2, cb.opBoolS, cb.exCB)
cb.check()
ssi = (1, 2, 3)
isi = (5, 6, 7, 8)
lsi = (10, 30, 20)
cb = Callback()
p.begin_opShortIntLongS(ssi, isi, lsi, cb.opShortIntLongS, cb.exCB)
cb.check()
fsi = (3.14, 1.11)
dsi = (1.1E10, 1.2E10, 1.3E10)
cb = Callback()
p.begin_opFloatDoubleS(fsi, dsi, cb.opFloatDoubleS, cb.exCB)
cb.check()
ssi1 = ('abc', 'de', 'fghi')
ssi2 = ('xyz', )
cb = Callback()
p.begin_opStringS(ssi1, ssi2, cb.opStringS, cb.exCB)
cb.check()
bsi1 = ((0x01, 0x11, 0x12), (0xff, ))
bsi2 = ((0x0e, ), (0xf2, 0xf1))
cb = Callback()
p.begin_opByteSS(bsi1, bsi2, cb.opByteSS, cb.exCB)
cb.check()
fsi = ((3.14, ), (1.11, ), ())
dsi = ((1.1E10, 1.2E10, 1.3E10), )
cb = Callback()
p.begin_opFloatDoubleSS(fsi, dsi, cb.opFloatDoubleSS, cb.exCB)
cb.check()
ssi1 = (('abc', ), ('de', 'fghi'))
ssi2 = ((), (), ('xyz', ))
cb = Callback()
p.begin_opStringSS(ssi1, ssi2, cb.opStringSS, cb.exCB)
cb.check()
di1 = {10: True, 100: False}
di2 = {10: True, 11: False, 101: True}
cb = Callback()
p.begin_opByteBoolD(di1, di2, cb.opByteBoolD, cb.exCB)
cb.check()
di1 = {110: -1, 1100: 123123}
di2 = {110: -1, 111: -100, 1101: 0}
cb = Callback()
p.begin_opShortIntD(di1, di2, cb.opShortIntD, cb.exCB)
cb.check()
di1 = {999999110: -1.1, 999999111: 123123.2}
di2 = {999999110: -1.1, 999999120: -100.4, 999999130: 0.5}
cb = Callback()
p.begin_opLongFloatD(di1, di2, cb.opLongFloatD, cb.exCB)
cb.check()
di1 = {'foo': 'abc -1.1', 'bar': 'abc 123123.2'}
di2 = {'foo': 'abc -1.1', 'FOO': 'abc -100.4', 'BAR': 'abc 0.5'}
cb = Callback()
p.begin_opStringStringD(di1, di2, cb.opStringStringD, cb.exCB)
cb.check()
di1 = {'abc': Test.MyEnum.enum1, '': Test.MyEnum.enum2}
di2 = {
'abc': Test.MyEnum.enum1,
'qwerty': Test.MyEnum.enum3,
'Hello!!': Test.MyEnum.enum2
}
cb = Callback()
p.begin_opStringMyEnumD(di1, di2, cb.opStringMyEnumD, cb.exCB)
cb.check()
di1 = {Test.MyEnum.enum1: 'abc'}
di2 = {Test.MyEnum.enum2: 'Hello!!', Test.MyEnum.enum3: 'qwerty'}
cb = Callback()
p.begin_opMyEnumStringD(di1, di2, cb.opMyEnumStringD, cb.exCB)
cb.check()
s11 = Test.MyStruct()
s11.i = 1
s11.j = 1
s12 = Test.MyStruct()
s12.i = 1
s12.j = 2
s22 = Test.MyStruct()
s22.i = 2
s22.j = 2
s23 = Test.MyStruct()
s23.i = 2
s23.j = 3
di1 = {s11: Test.MyEnum.enum1, s12: Test.MyEnum.enum2}
di2 = {
s11: Test.MyEnum.enum1,
s22: Test.MyEnum.enum3,
s23: Test.MyEnum.enum2
}
cb = Callback()
p.begin_opMyStructMyEnumD(di1, di2, cb.opMyStructMyEnumD, cb.exCB)
cb.check()
lengths = (0, 1, 2, 126, 127, 128, 129, 253, 254, 255, 256, 257, 1000)
for l in lengths:
s = []
for i in range(l):
s.append(i)
cb = Callback(l)
p.begin_opIntS(s, cb.opIntS, cb.exCB)
cb.check()
ctx = {'one': 'ONE', 'two': 'TWO', 'three': 'THREE'}
test(len(p.ice_getContext()) == 0)
r = p.begin_opContext()
c = p.end_opContext(r)
test(c != ctx)
test(len(p.ice_getContext()) == 0)
r = p.begin_opContext(_ctx=ctx)
c = p.end_opContext(r)
test(c == ctx)
p2 = Test.MyClassPrx.checkedCast(p.ice_context(ctx))
test(p2.ice_getContext() == ctx)
r = p2.begin_opContext()
c = p2.end_opContext(r)
test(c == ctx)
r = p2.begin_opContext(_ctx=ctx)
c = p2.end_opContext(r)
test(c == ctx)
#
# Test implicit context propagation
#
impls = ('Shared', 'PerThread')
for i in impls:
initData = Ice.InitializationData()
initData.properties = communicator.getProperties().clone()
initData.properties.setProperty('Ice.ImplicitContext', i)
ic = Ice.initialize(data=initData)
ctx = {'one': 'ONE', 'two': 'TWO', 'three': 'THREE'}
p3 = Test.MyClassPrx.uncheckedCast(
ic.stringToProxy("test:default -p 12010"))
ic.getImplicitContext().setContext(ctx)
test(ic.getImplicitContext().getContext() == ctx)
r = p3.begin_opContext()
c = p3.end_opContext(r)
test(c == ctx)
ic.getImplicitContext().put('zero', 'ZERO')
ctx = ic.getImplicitContext().getContext()
r = p3.begin_opContext()
c = p3.end_opContext(r)
test(c == ctx)
prxContext = {'one': 'UN', 'four': 'QUATRE'}
combined = {}
combined.update(ctx)
combined.update(prxContext)
test(combined['one'] == 'UN')
p3 = Test.MyClassPrx.uncheckedCast(p3.ice_context(prxContext))
ic.getImplicitContext().setContext({})
r = p3.begin_opContext()
c = p3.end_opContext(r)
test(c == prxContext)
ic.getImplicitContext().setContext(ctx)
r = p3.begin_opContext()
c = p3.end_opContext(r)
test(c == combined)
ic.destroy()
cb = Callback()
p.begin_opIdempotent(cb.opIdempotent, cb.exCB)
cb.check()
cb = Callback()
p.begin_opNonmutating(cb.opNonmutating, cb.exCB)
cb.check()
derived = Test.MyDerivedClassPrx.checkedCast(p)
test(derived)
cb = Callback()
derived.begin_opDerived(cb.opDerived, cb.exCB)
cb.check()
