summaryrefslogtreecommitdiff
path: root/python/test/Ice/operations/ServerAMD.py
diff options
context:
space:
mode:
Diffstat (limited to 'python/test/Ice/operations/ServerAMD.py')
-rwxr-xr-xpython/test/Ice/operations/ServerAMD.py407
1 files changed, 215 insertions, 192 deletions
diff --git a/python/test/Ice/operations/ServerAMD.py b/python/test/Ice/operations/ServerAMD.py
index f3dd86e001b..0b727f42970 100755
--- a/python/test/Ice/operations/ServerAMD.py
+++ b/python/test/Ice/operations/ServerAMD.py
@@ -8,7 +8,11 @@
#
# **********************************************************************
-import os, sys, traceback, threading
+import os, sys, traceback, threading, time
+
+haveConcurrentFuture = sys.version_info.major > 3 or (sys.version_info.major == 3 and sys.version_info.minor >= 5)
+if haveConcurrentFuture:
+ import concurrent.futures
import Ice
slice_dir = Ice.getSliceDir()
@@ -23,87 +27,96 @@ def test(b):
if not b:
raise RuntimeError('test assertion failed')
-class Thread_opVoid(threading.Thread):
- def __init__(self, cb):
+class FutureThread(threading.Thread):
+ def __init__(self, f, r):
threading.Thread.__init__(self)
- self.cb = cb
+ self.future = f
+ self.result = r
def run(self):
- self.cb.ice_response()
+ time.sleep(0.01)
+ self.future.set_result(self.result)
-class MyDerivedClassI(Test.MyDerivedClass):
+class MyDerivedClassI(Test._MyDerivedClassDisp):
def __init__(self):
- self.opVoidThread = None
- self.opVoidThreadLock = threading.Lock()
+ self.threads = []
+ self.threadLock = threading.Lock()
self.lock = threading.Lock()
self.opByteSOnewayCount = 0
def ice_isA(self, id, current=None):
test(current.mode == Ice.OperationMode.Nonmutating)
- return Test.MyDerivedClass.ice_isA(self, id, current)
+ return Test._MyDerivedClassDisp.ice_isA(self, id, current)
def ice_ping(self, current=None):
test(current.mode == Ice.OperationMode.Nonmutating)
- Test.MyDerivedClass.ice_ping(self, current)
+ Test._MyDerivedClassDisp.ice_ping(self, current)
def ice_ids(self, current=None):
test(current.mode == Ice.OperationMode.Nonmutating)
- return Test.MyDerivedClass.ice_ids(self, current)
+ return Test._MyDerivedClassDisp.ice_ids(self, current)
def ice_id(self, current=None):
test(current.mode == Ice.OperationMode.Nonmutating)
- return Test.MyDerivedClass.ice_id(self, current)
+ return Test._MyDerivedClassDisp.ice_id(self, current)
- def shutdown_async(self, cb, current=None):
- self.opVoidThreadLock.acquire()
- if self.opVoidThread:
- self.opVoidThread.join()
- self.opVoidThread = None
- self.opVoidThreadLock.release()
+ def shutdown(self, current=None):
+ with self.threadLock:
+ for thread in self.threads:
+ thread.join()
+ self.threads = []
current.adapter.getCommunicator().shutdown()
- cb.ice_response()
- def opVoid_async(self, cb, current=None):
+ def opVoid(self, current=None):
test(current.mode == Ice.OperationMode.Normal)
- self.opVoidThreadLock.acquire()
- if self.opVoidThread:
- self.opVoidThread.join()
- self.opVoidThread = None
+ f = Ice.Future()
+
+ with self.threadLock:
+ thread = FutureThread(f, None)
+ self.threads.append(thread)
+ thread.start()
- self.opVoidThread = Thread_opVoid(cb)
- self.opVoidThread.start()
- self.opVoidThreadLock.release()
+ return f
- def opByte_async(self, cb, p1, p2, current=None):
- cb.ice_response(p1, p1 ^ p2)
+ def opByte(self, p1, p2, current=None):
+ # Test the ability to use another Future type
+ if haveConcurrentFuture:
+ f = concurrent.futures.Future()
+ with self.threadLock:
+ thread = FutureThread(f, (p1, p1 ^ p2))
+ self.threads.append(thread)
+ thread.start()
+ else:
+ f = Ice.Future.completed((p1, p1 ^ p2))
+ return f
- def opBool_async(self, cb, p1, p2, current=None):
- cb.ice_response(p2, p1)
+ def opBool(self, p1, p2, current=None):
+ return Ice.Future.completed((p2, p1))
- def opShortIntLong_async(self, cb, p1, p2, p3, current=None):
- cb.ice_response(p3, p1, p2, p3)
+ def opShortIntLong(self, p1, p2, p3, current=None):
+ return Ice.Future.completed((p3, p1, p2, p3))
- def opFloatDouble_async(self, cb, p1, p2, current=None):
- cb.ice_response(p2, p1, p2)
+ def opFloatDouble(self, p1, p2, current=None):
+ return Ice.Future.completed((p2, p1, p2))
- def opString_async(self, cb, p1, p2, current=None):
- cb.ice_response(p1 + " " + p2, p2 + " " + p1)
+ def opString(self, p1, p2, current=None):
+ return Ice.Future.completed((p1 + " " + p2, p2 + " " + p1))
- def opMyEnum_async(self, cb, p1, current=None):
- cb.ice_response(Test.MyEnum.enum3, p1)
+ def opMyEnum(self, p1, current=None):
+ return Ice.Future.completed((Test.MyEnum.enum3, p1))
- def opMyClass_async(self, cb, p1, current=None):
+ def opMyClass(self, p1, current=None):
p2 = p1
- p3 = Test.MyClassPrx.uncheckedCast(current.adapter.createProxy(communicator.stringToIdentity("noSuchIdentity")))
- cb.ice_response(Test.MyClassPrx.uncheckedCast(current.adapter.createProxy(current.id)), p2, p3)
+ p3 = Test.MyClassPrx.uncheckedCast(current.adapter.createProxy(Ice.stringToIdentity("noSuchIdentity")))
+ return Ice.Future.completed((Test.MyClassPrx.uncheckedCast(current.adapter.createProxy(current.id)), p2, p3))
- def opStruct_async(self, cb, p1, p2, current=None):
+ def opStruct(self, p1, p2, current=None):
p1.s.s = "a new string"
- cb.ice_response(p2, p1)
+ return Ice.Future.completed((p2, p1))
- def opByteS_async(self, cb, p1, p2, current=None):
+ def opByteS(self, p1, p2, current=None):
if sys.version_info[0] == 2:
# By default sequence<byte> maps to a string.
p3 = map(ord, p1)
@@ -113,310 +126,327 @@ class MyDerivedClassI(Test.MyDerivedClass):
else:
p3 = bytes(reversed(p1))
r = p1 + p2
- cb.ice_response(r, p3)
+ return Ice.Future.completed((r, p3))
- def opBoolS_async(self, cb, p1, p2, current=None):
+ def opBoolS(self, p1, p2, current=None):
p3 = p1[0:]
p3.extend(p2)
r = p1[0:]
r.reverse();
- cb.ice_response(r, p3)
+ return Ice.Future.completed((r, p3))
- def opShortIntLongS_async(self, cb, p1, p2, p3, current=None):
+ def opShortIntLongS(self, p1, p2, p3, current=None):
p4 = p1[0:]
p5 = p2[0:]
p5.reverse()
p6 = p3[0:]
p6.extend(p3)
- cb.ice_response(p3, p4, p5, p6)
+ return Ice.Future.completed((p3, p4, p5, p6))
- def opFloatDoubleS_async(self, cb, p1, p2, current=None):
+ def opFloatDoubleS(self, p1, p2, current=None):
p3 = p1[0:]
p4 = p2[0:]
p4.reverse()
r = p2[0:]
r.extend(p1)
- cb.ice_response(r, p3, p4)
+ return Ice.Future.completed((r, p3, p4))
- def opStringS_async(self, cb, p1, p2, current=None):
+ def opStringS(self, p1, p2, current=None):
p3 = p1[0:]
p3.extend(p2)
r = p1[0:]
r.reverse()
- cb.ice_response(r, p3)
+ return Ice.Future.completed((r, p3))
- def opByteSS_async(self, cb, p1, p2, current=None):
+ def opByteSS(self, p1, p2, current=None):
p3 = p1[0:]
p3.reverse()
r = p1[0:]
r.extend(p2)
- cb.ice_response(r, p3)
+ return Ice.Future.completed((r, p3))
- def opBoolSS_async(self, cb, p1, p2, current=None):
+ def opBoolSS(self, p1, p2, current=None):
p3 = p1[0:]
p3.extend(p2)
r = p1[0:]
r.reverse()
- cb.ice_response(r, p3)
+ return Ice.Future.completed((r, p3))
- def opShortIntLongSS_async(self, cb, p1, p2, p3, current=None):
+ def opShortIntLongSS(self, p1, p2, p3, current=None):
p4 = p1[0:]
p5 = p2[0:]
p5.reverse()
p6 = p3[0:]
p6.extend(p3)
- cb.ice_response(p3, p4, p5, p6)
+ return Ice.Future.completed((p3, p4, p5, p6))
- def opFloatDoubleSS_async(self, cb, p1, p2, current=None):
+ def opFloatDoubleSS(self, p1, p2, current=None):
p3 = p1[0:]
p4 = p2[0:]
p4.reverse()
r = p2[0:]
r.extend(p2)
- cb.ice_response(r, p3, p4)
+ return Ice.Future.completed((r, p3, p4))
- def opStringSS_async(self, cb, p1, p2, current=None):
+ def opStringSS(self, p1, p2, current=None):
p3 = p1[0:]
p3.extend(p2)
r = p2[0:]
r.reverse()
- cb.ice_response(r, p3)
+ return Ice.Future.completed((r, p3))
- def opStringSSS_async(self, cb, p1, p2, current=None):
+ def opStringSSS(self, p1, p2, current=None):
p3 = p1[0:]
p3.extend(p2)
r = p2[0:]
r.reverse()
- cb.ice_response(r, p3)
+ return Ice.Future.completed((r, p3))
- def opByteBoolD_async(self, cb, p1, p2, current=None):
+ def opByteBoolD(self, p1, p2, current=None):
p3 = p1.copy()
r = p1.copy()
r.update(p2)
- cb.ice_response(r, p3)
+ return Ice.Future.completed((r, p3))
- def opShortIntD_async(self, cb, p1, p2, current=None):
+ def opShortIntD(self, p1, p2, current=None):
p3 = p1.copy()
r = p1.copy()
r.update(p2)
- cb.ice_response(r, p3)
+ return Ice.Future.completed((r, p3))
- def opLongFloatD_async(self, cb, p1, p2, current=None):
+ def opLongFloatD(self, p1, p2, current=None):
p3 = p1.copy()
r = p1.copy()
r.update(p2)
- cb.ice_response(r, p3)
+ return Ice.Future.completed((r, p3))
- def opStringStringD_async(self, cb, p1, p2, current=None):
+ def opStringStringD(self, p1, p2, current=None):
p3 = p1.copy()
r = p1.copy()
r.update(p2)
- cb.ice_response(r, p3)
+ return Ice.Future.completed((r, p3))
- def opStringMyEnumD_async(self, cb, p1, p2, current=None):
+ def opStringMyEnumD(self, p1, p2, current=None):
p3 = p1.copy()
r = p1.copy()
r.update(p2)
- cb.ice_response(r, p3)
+ return Ice.Future.completed((r, p3))
- def opMyEnumStringD_async(self, cb, p1, p2, current=None):
+ def opMyEnumStringD(self, p1, p2, current=None):
p3 = p1.copy()
r = p1.copy()
r.update(p2)
- cb.ice_response(r, p3)
+ return Ice.Future.completed((r, p3))
- def opMyStructMyEnumD_async(self, cb, p1, p2, current=None):
+ def opMyStructMyEnumD(self, p1, p2, current=None):
p3 = p1.copy()
r = p1.copy()
r.update(p2)
- cb.ice_response(r, p3)
+ return Ice.Future.completed((r, p3))
- def opByteBoolDS_async(self, cb, p1, p2, current=None):
+ def opByteBoolDS(self, p1, p2, current=None):
p3 = p2[0:]
p3.extend(p1)
r = p1[::-1]
- cb.ice_response(r, p3)
+ return Ice.Future.completed((r, p3))
- def opShortIntDS_async(self, cb, p1, p2, current=None):
+ def opShortIntDS(self, p1, p2, current=None):
p3 = p2[0:]
p3.extend(p1)
r = p1[::-1]
- cb.ice_response(r, p3)
+ return Ice.Future.completed((r, p3))
- def opLongFloatDS_async(self, cb, p1, p2, current=None):
+ def opLongFloatDS(self, p1, p2, current=None):
p3 = p2[0:]
p3.extend(p1)
r = p1[::-1]
- cb.ice_response(r, p3)
+ return Ice.Future.completed((r, p3))
- def opStringStringDS_async(self, cb, p1, p2, current=None):
+ def opStringStringDS(self, p1, p2, current=None):
p3 = p2[0:]
p3.extend(p1)
r = p1[::-1]
- cb.ice_response(r, p3)
+ return Ice.Future.completed((r, p3))
- def opStringMyEnumDS_async(self, cb, p1, p2, current=None):
+ def opStringMyEnumDS(self, p1, p2, current=None):
p3 = p2[0:]
p3.extend(p1)
r = p1[::-1]
- cb.ice_response(r, p3)
+ return Ice.Future.completed((r, p3))
- def opMyEnumStringDS_async(self, cb, p1, p2, current=None):
+ def opMyEnumStringDS(self, p1, p2, current=None):
p3 = p2[0:]
p3.extend(p1)
r = p1[::-1]
- cb.ice_response(r, p3)
+ return Ice.Future.completed((r, p3))
- def opMyStructMyEnumDS_async(self, cb, p1, p2, current=None):
+ def opMyStructMyEnumDS(self, p1, p2, current=None):
p3 = p2[0:]
p3.extend(p1)
r = p1[::-1]
- cb.ice_response(r, p3)
+ return Ice.Future.completed((r, p3))
- def opByteByteSD_async(self, cb, p1, p2, current=None):
+ def opByteByteSD(self, p1, p2, current=None):
p3 = p2.copy()
r = p1.copy()
r.update(p2)
- cb.ice_response(r, p3)
+ return Ice.Future.completed((r, p3))
- def opBoolBoolSD_async(self, cb, p1, p2, current=None):
+ def opBoolBoolSD(self, p1, p2, current=None):
p3 = p2.copy()
r = p1.copy()
r.update(p2)
- cb.ice_response(r, p3)
+ return Ice.Future.completed((r, p3))
- def opShortShortSD_async(self, cb, p1, p2, current=None):
+ def opShortShortSD(self, p1, p2, current=None):
p3 = p2.copy()
r = p1.copy()
r.update(p2)
- cb.ice_response(r, p3)
+ return Ice.Future.completed((r, p3))
- def opIntIntSD_async(self, cb, p1, p2, current=None):
+ def opIntIntSD(self, p1, p2, current=None):
p3 = p2.copy()
r = p1.copy()
r.update(p2)
- cb.ice_response(r, p3)
+ return Ice.Future.completed((r, p3))
- def opLongLongSD_async(self, cb, p1, p2, current=None):
+ def opLongLongSD(self, p1, p2, current=None):
p3 = p2.copy()
r = p1.copy()
r.update(p2)
- cb.ice_response(r, p3)
+ return Ice.Future.completed((r, p3))
- def opStringFloatSD_async(self, cb, p1, p2, current=None):
+ def opStringFloatSD(self, p1, p2, current=None):
p3 = p2.copy()
r = p1.copy()
r.update(p2)
- cb.ice_response(r, p3)
+ return Ice.Future.completed((r, p3))
- def opStringDoubleSD_async(self, cb, p1, p2, current=None):
+ def opStringDoubleSD(self, p1, p2, current=None):
p3 = p2.copy()
r = p1.copy()
r.update(p2)
- cb.ice_response(r, p3)
+ return Ice.Future.completed((r, p3))
- def opStringStringSD_async(self, cb, p1, p2, current=None):
+ def opStringStringSD(self, p1, p2, current=None):
p3 = p2.copy()
r = p1.copy()
r.update(p2)
- cb.ice_response(r, p3)
+ return Ice.Future.completed((r, p3))
- def opMyEnumMyEnumSD_async(self, cb, p1, p2, current=None):
+ def opMyEnumMyEnumSD(self, p1, p2, current=None):
p3 = p2.copy()
r = p1.copy()
r.update(p2)
- cb.ice_response(r, p3)
+ return Ice.Future.completed((r, p3))
- def opIntS_async(self, cb, s, current=None):
- cb.ice_response([-x for x in s])
+ def opIntS(self, s, current=None):
+ return Ice.Future.completed([-x for x in s])
- def opByteSOneway_async(self, cb, s, current=None):
- self.lock.acquire()
- self.opByteSOnewayCount += 1
- self.lock.release()
- cb.ice_response()
+ def opByteSOneway(self, s, current=None):
+ with self.lock:
+ self.opByteSOnewayCount += 1
+ return Ice.Future.completed(None)
- def opByteSOnewayCallCount_async(self, cb, current=None):
- self.lock.acquire()
- count = self.opByteSOnewayCount
- self.opByteSOnewayCount = 0
- self.lock.release()
- cb.ice_response(count)
+ def opByteSOnewayCallCount(self, current=None):
+ with self.lock:
+ count = self.opByteSOnewayCount
+ self.opByteSOnewayCount = 0
+ return Ice.Future.completed(count)
- def opDoubleMarshaling_async(self, cb, p1, p2, current=None):
+ def opDoubleMarshaling(self, p1, p2, current=None):
d = 1278312346.0 / 13.0;
test(p1 == d)
for i in p2:
test(i == d)
- cb.ice_response()
+ return Ice.Future.completed(None)
- def opContext_async(self, cb, current=None):
- cb.ice_response(current.ctx)
+ def opContext(self, current=None):
+ return Ice.Future.completed(current.ctx)
- def opIdempotent_async(self, cb, current=None):
+ def opIdempotent(self, current=None):
test(current.mode == Ice.OperationMode.Idempotent)
- cb.ice_response()
+ return Ice.Future.completed(None)
- def opNonmutating_async(self, cb, current=None):
+ def opNonmutating(self, current=None):
test(current.mode == Ice.OperationMode.Nonmutating)
- cb.ice_response()
-
- def opDerived_async(self, cb, current=None):
- cb.ice_response()
-
- def opByte1_async(self, cb, value, current=None):
- cb.ice_response(value)
-
- def opShort1_async(self, cb, value, current=None):
- cb.ice_response(value)
-
- def opInt1_async(self, cb, value, current=None):
- cb.ice_response(value)
-
- def opLong1_async(self, cb, value, current=None):
- cb.ice_response(value)
-
- def opFloat1_async(self, cb, value, current=None):
- cb.ice_response(value)
-
- def opDouble1_async(self, cb, value, current=None):
- cb.ice_response(value)
-
- def opString1_async(self, cb, value, current=None):
- cb.ice_response(value)
-
- def opStringS1_async(self, cb, value, current=None):
- cb.ice_response(value)
-
- def opByteBoolD1_async(self, cb, value, current=None):
- cb.ice_response(value)
-
- def opStringS2_async(self, cb, value, current=None):
- cb.ice_response(value)
-
- def opByteBoolD2_async(self, cb, value, current=None):
- cb.ice_response(value)
-
- def opMyClass1_async(self, cb, value, current=None):
- return cb.ice_response(value)
-
- def opMyStruct1_async(self, cb, value, current=None):
- return cb.ice_response(value)
-
- def opStringLiterals_async(self, cb, current=None):
- return cb.ice_response([
+ return Ice.Future.completed(None)
+
+ def opDerived(self, current=None):
+ return Ice.Future.completed(None)
+
+ def opByte1(self, value, current=None):
+ return Ice.Future.completed(value)
+
+ def opShort1(self, value, current=None):
+ return Ice.Future.completed(value)
+
+ def opInt1(self, value, current=None):
+ return Ice.Future.completed(value)
+
+ def opLong1(self, value, current=None):
+ return Ice.Future.completed(value)
+
+ def opFloat1(self, value, current=None):
+ return Ice.Future.completed(value)
+
+ def opDouble1(self, value, current=None):
+ return Ice.Future.completed(value)
+
+ def opString1(self, value, current=None):
+ return Ice.Future.completed(value)
+
+ def opStringS1(self, value, current=None):
+ return Ice.Future.completed(value)
+
+ def opByteBoolD1(self, value, current=None):
+ return Ice.Future.completed(value)
+
+ def opStringS2(self, value, current=None):
+ return Ice.Future.completed(value)
+
+ def opByteBoolD2(self, value, current=None):
+ return Ice.Future.completed(value)
+
+ def opMyClass1(self, value, current=None):
+ return Ice.Future.completed(value)
+
+ def opMyStruct1(self, value, current=None):
+ return Ice.Future.completed(value)
+
+ def opStringLiterals(self, current=None):
+ return Ice.Future.completed([
Test.s0, Test.s1, Test.s2, Test.s3, Test.s4, Test.s5, Test.s6, Test.s7, Test.s8, Test.s9, Test.s10,
- Test.sw0, Test.sw1, Test.sw2, Test.sw3, Test.sw4, Test.sw5, Test.sw6, Test.sw7, Test.sw8, Test.sw9, Test.sw10,
+ Test.sw0, Test.sw1, Test.sw2, Test.sw3, Test.sw4, Test.sw5, Test.sw6, Test.sw7, Test.sw8, Test.sw9,
+ Test.sw10,
Test.ss0, Test.ss1, Test.ss2, Test.ss3, Test.ss4, Test.ss5,
Test.su0, Test.su1, Test.su2])
-
- def opWStringLiterals_async(self, cb, current=None):
- return self.opStringLiterals_async(cb, current)
+
+ def opWStringLiterals(self, current=None):
+ return self.opStringLiterals(current)
+
+ def opMStruct1(self, current):
+ return Ice.Future.completed(Test.Structure())
+
+ def opMStruct2(self, p1, current):
+ return Ice.Future.completed((p1, p1))
+
+ def opMSeq1(self, current):
+ return Ice.Future.completed([])
+
+ def opMSeq2(self, p1, current):
+ return Ice.Future.completed((p1, p1))
+
+ def opMDict1(self, current):
+ return Ice.Future.completed({})
+
+ def opMDict2(self, p1, current):
+ return Ice.Future.completed((p1, p1))
def run(args, communicator):
communicator.getProperties().setProperty("TestAdapter.Endpoints", "default -p 12010:udp")
adapter = communicator.createObjectAdapter("TestAdapter")
- adapter.add(MyDerivedClassI(), communicator.stringToIdentity("test"))
+ adapter.add(MyDerivedClassI(), Ice.stringToIdentity("test"))
adapter.activate()
communicator.waitForShutdown()
return True
@@ -425,17 +455,10 @@ try:
initData = Ice.InitializationData()
initData.properties = Ice.createProperties(sys.argv)
initData.properties.setProperty("Ice.Warn.Dispatch", "0");
- communicator = Ice.initialize(sys.argv, initData)
- status = run(sys.argv, communicator)
+ with Ice.initialize(sys.argv, initData) as communicator:
+ status = run(sys.argv, communicator)
except:
traceback.print_exc()
status = False
-if communicator:
- try:
- communicator.destroy()
- except:
- traceback.print_exc()
- status = False
-
sys.exit(not status)
generated by cgit v1.2.3 (git 2.46.0) at 2025-08-03 18:26:27 +0000