def test_hwn(self):
# Create pair of socket, each with high watermark of 2. Thus the
# total buffer space should be 4 messages.
sb = self.ctx.pull(rcvhwm=2)
sc = self.ctx.push(sndhwm=2)
with sb.bind_inproc('a'), sc.connect_inproc('a'):
# Try to send 10 messages. Only 4 should succeed.
for t in range(10):
try:
sc.send(None, 0, nowait=True)
if t < 4:
self.assertEqual(sc.last_rc, 0)
except self.xs.XSError as e:
self.assertTrue(e.errno, self.XS.EAGAIN)
# there should be now 4 messages pending, consume them.
for i in lrange(4): # @UnusedVariable
sb.recv(0)
self.assertEqual(sb.last_rc, 0)
# now it should be possible to send one more.
self.assertEqual(sc.send(None, 0).last_rc, 0)
# consume the remaining message
sb.recv(0)
self.assertEqual(sb.last_rc, 0)
s1 = self.ctx.pull()
s2 = self.ctx.push(sndhwm=5)
# Following part of the tests checks whether small HWMs don't
# interact with command throttling in strange ways.
with s1.bind_tcp('127.0.0.1:5858'), s2.connect_tcp('127.0.0.1:5858'):
self.assertTrue(s1.last_rc >= 0)
self.assertTrue(s2.last_rc >= 0)
for i in lrange(10): # @UnusedVariable
self.assertEqual(s2.send('test', nowait=True).last_rc, 4)
s1.recv(4)
self.assertEqual(s1.last_rc, 4)
def test_hwn(self):
from ctypes import sizeof, byref, c_int, c_ubyte
from crossroads.lowest import array
XS, xs = twoget(self)
ctx = xs.init()
self.assertTrue(ctx)
# Create pair of socket, each with high watermark of 2. Thus the total
# buffer space should be 4 messages.
sb = xs.socket(ctx, XS.PULL)
self.assertTrue(sb)
hwm = c_int(2)
self.assertEqual(
xs.setsockopt(sb, XS.RCVHWM, byref(hwm), sizeof(hwm)), 0
)
self.assertNotEqual(xs.bind(sb, b'inproc://a'), -1)
sc = xs.socket(ctx, XS.PUSH)
self.assertTrue(sc)
self.assertEqual(
xs.setsockopt(sc, XS.SNDHWM, byref(hwm), sizeof(hwm)), 0
)
self.assertNotEqual(xs.connect(sc, b'inproc://a'), -1)
# try to send 10 messages. Only 4 should succeed.
for t in range(10):
try:
rc = xs.send(sc, None, 0, XS.DONTWAIT)
if t < 4:
self.assertEqual(rc, 0)
except xs.XSError as e:
self.assertTrue(e.errno, XS.EAGAIN)
# There should be now 4 messages pending, consume them.
for i in lrange(4): # @UnusedVariable
self.assertEqual(xs.recv(sb, None, 0, 0), 0)
# Now it should be possible to send one more.
self.assertEqual(xs.send(sc, None, 0, 0), 0)
# Consume the remaining message.
self.assertEqual(xs.recv(sb, None, 0, 0), 0)
self.assertEqual(xs.close(sc), 0)
self.assertEqual(xs.close(sb), 0)
self.assertEqual(xs.term(ctx), 0)
# Following part of the tests checks whether small HWMs don't interact
# with command throttling in strange ways.
ctx = xs.init()
self.assertTrue(ctx)
s1 = xs.socket(ctx, XS.PULL)
self.assertTrue(s1)
s2 = xs.socket(ctx, XS.PUSH)
self.assertTrue(s2)
hwm = c_int(5)
self.assertEqual(
xs.setsockopt(s2, XS.SNDHWM, byref(hwm), sizeof(hwm)), 0
)
self.assertTrue(xs.bind(s1, b'tcp://127.0.0.1:5858') >= 0)
self.assertTrue(xs.connect(s2, b'tcp://127.0.0.1:5858') >= 0)
for i in lrange(10): # @UnusedVariable
self.assertEqual(xs.send(s2, b'test', 4, XS.DONTWAIT), 4)
buf = array(c_ubyte, 4)
self.assertEqual(xs.recv(s1, buf, sizeof(buf), 0), 4)
self.assertEqual(xs.close(s2), 0)
self.assertEqual(xs.close(s1), 0)
self.assertEqual(xs.term(ctx), 0)
def test_regrep_device(self):
from stuf.six import byteme
# create a req/rep device
xreq = self.ctx.xreq()
xrep = self.ctx.xrep()
# create a worker
rep = self.ctx.rep()
# create a client
req = self.ctx.req()
with xreq.bind_tcp('127.0.0.1:5560'), xrep.bind_tcp('127.0.0.1:5561'),\
rep.connect_tcp('127.0.0.1:5560'), req.connect_tcp('127.0.0.1:5561'):
# send a request
self.assertEqual(req.send(b'ABC', 3, True).last_rc, 3)
self.assertEqual(req.send(b'DEF', 3).last_rc, 3)
# pass the reply through the device
for i in lrange(4): # @UnusedVariable
msg = xrep.recvmsg()
self.assertTrue(msg.last_rc >= 0)
rc = xreq.sendmsg(msg, True if msg.more else False).last_rc
self.assertTrue(rc >= 0)
self.assertEqual(msg.more, 0)
# receive the request
buff = rep.recv(3)
self.assertEqual(byteme(buff), b'ABC')
self.assertEqual(buff.last_rc, 3)
self.assertEqual(buff.more, 1)
buff = rep.recv(3)
self.assertEqual(buff.last_rc, 3)
self.assertEqual(byteme(buff), b'DEF')
self.assertEqual(buff.more, 0)
# send the reply
self.assertEqual(rep.send(b'GHI', 3, more=True).last_rc, 3)
self.assertEqual(rep.send(b'JKL', 3).last_rc, 3)
# pass the reply through the device
for i in lrange(4): # @UnusedVariable
msg = xreq.recvmsg()
self.assertTrue(msg.last_rc >= 0)
rc = xrep.sendmsg(msg, True if msg.more else False).last_rc
self.assertTrue(rc >= 0)
# receive the reply
buff = req.recv(3)
self.assertEqual(buff.last_rc, 3)
self.assertEqual(byteme(buff), b'GHI')
self.assertEqual(buff.more, 1)
buff2 = req.recv(3)
self.assertEqual(buff2.last_rc, 3)
self.assertEqual(byteme(buff2), b'JKL')
self.assertEqual(buff2.more, 0)
def test_multiset_operations(self):
from stuf.utils import lrange
from random import randrange
# Verify that adding a zero counter will strip zeros and negatives
c = self._impone(a=10, b=-2, c=0) + self._impone()
self.assertEqual(dict(c), dict(a=10))
elements = 'abcd'
for _ in lrange(1000):
# test random pairs of multisets
p = self._impone(
dict((elem, randrange(-2, 4)) for elem in elements))
p.update(e=1, f=-1, g=0)
q = self._impone(
dict((elem, randrange(-2, 4)) for elem in elements))
q.update(h=1, i=-1, j=0)
for counterop, numberop in [
(self._impone.__add__, lambda x, y: max(0, x + y)),
(self._impone.__sub__, lambda x, y: max(0, x - y)),
(self._impone.__or__, lambda x, y: max(0, x, y)),
(self._impone.__and__, lambda x, y: max(0, min(x, y))),
]:
result = counterop(p, q)
for x in elements:
self.assertEqual(numberop(p[x], q[x]), result[x],
(counterop, x, p, q))
# verify that results exclude non-positive counts
self.assertTrue(x > 0 for x in result.values())
elements = 'abcdef'
for _ in lrange(100):
# verify that random multisets with no repeats are exactly like sets
p = self._impone(dict(
(elem, randrange(0, 2)) for elem in elements))
q = self._impone(dict(
(elem, randrange(0, 2)) for elem in elements))
for counterop, setop in [
(self._impone.__sub__, set.__sub__),
(self._impone.__or__, set.__or__),
(self._impone.__and__, set.__and__),
]:
counter_result = counterop(p, q)
set_result = setop(set(p.elements()), set(q.elements()))
self.assertEqual(counter_result, dict.fromkeys(set_result, 1))
def test_basics(self):
from stuf.utils import lrange
c = self._impone('abcaba')
self.assertEqual(c.most_common(), [('a', 3), ('b', 2), ('c', 1)])
for i in lrange(5):
self.assertEqual(c.most_common(i), [('a', 3), ('b', 2),
('c', 1)][:i])
self.assertEqual(''.join(sorted(c.elements())), 'aaabbc')
c.a += 1 # increment an existing value
c.b -= 2 # sub existing value to zero
del c.c # remove an entry
del c.c # make sure that del doesn't raise KeyError
c.d -= 2 # sub from a missing value
c.e = -5 # directly assign a missing value
c.f += 4 # add to a missing value
def test_regrep_device(self):
from ctypes import sizeof, c_int, c_size_t, c_ubyte
from crossroads.lowest import array
XS, xs = twoget(self)
ctx = xs.init()
self.assertTrue(ctx)
# create a req/rep device.
xreq = xs.socket(ctx, XS.XREQ)
self.assertTrue(xreq)
self.assertNotEqual(xs.bind(xreq, b'tcp://127.0.0.1:5560'), -1)
xrep = xs.socket(ctx, XS.XREP)
self.assertTrue(xrep)
self.assertNotEqual(xs.bind(xrep, b'tcp://127.0.0.1:5561'), -1)
# create a worker.
rep = xs.socket(ctx, XS.REP)
self.assertTrue(rep)
self.assertNotEqual(xs.connect(rep, b'tcp://127.0.0.1:5560'), -1)
# create a client.
req = xs.socket(ctx, XS.REQ)
self.assertTrue(req)
self.assertNotEqual(xs.connect(req, b'tcp://127.0.0.1:5561'), -1)
# send a request.
self.assertEqual(xs.send(req, b'ABC', 3, XS.SNDMORE), 3)
self.assertEqual(xs.send(req, b'DEF', 3, 0), 3)
# pass the request through the device.
for i in lrange(4): # @UnusedVariable
msg = xs.msg_t()
self.assertEqual(xs.msg_init(msg), 0)
rc = xs.recvmsg(xrep, msg, 0)
self.assertTrue(rc >= 0)
rcvmore = c_int()
sz = c_size_t(sizeof(rcvmore))
self.assertEqual(xs.getsockopt(xrep, XS.RCVMORE, rcvmore, sz), 0)
rc = xs.sendmsg(xreq, msg, XS.SNDMORE if rcvmore else 0)
self.assertTrue(rc >= 0)
# receive the request.
buff = array(c_ubyte, 3)
self.assertEqual(xs.recv(rep, buff, 3, 0), 3)
self.assertEqual(bytearray(buff), b'ABC')
rcvmore = c_int()
sz = c_size_t(sizeof(rcvmore))
self.assertEqual(xs.getsockopt(rep, XS.RCVMORE, rcvmore, sz), 0)
self.assertTrue(rcvmore)
self.assertEqual(xs.recv(rep, buff, 3, 0), 3)
self.assertEqual(bytearray(buff), b'DEF')
self.assertEqual(xs.getsockopt(rep, XS.RCVMORE, rcvmore, sz), 0)
self.assertFalse(rcvmore)
# send the reply.
self.assertEqual(xs.send(rep, b'GHI', 3, XS.SNDMORE), 3)
self.assertEqual(xs.send(rep, b'JKL', 3, 0), 3)
# pass the reply through the device.
for i in lrange(4): # @UnusedVariable
msg = xs.msg_t()
self.assertEqual(xs.msg_init(msg), 0)
self.assertTrue(xs.recvmsg(xreq, msg, 0) >= 0)
self.assertEqual(xs.getsockopt(xreq, XS.RCVMORE, rcvmore, sz), 0)
self.assertTrue(
xs.sendmsg(xrep, msg, XS.SNDMORE if rcvmore else 0) >= 0
)
# receive the reply.
self.assertEqual(xs.recv(req, buff, 3, 0), 3)
self.assertEqual(bytearray(buff), b'GHI')
self.assertEqual(xs.getsockopt(req, XS.RCVMORE, rcvmore, sz), 0
)
self.assertTrue(rcvmore)
self.assertEqual(xs.recv(req, buff, 3, 0), 3)
self.assertEqual(bytearray(buff), b'JKL')
self.assertEqual(xs.getsockopt(req, XS.RCVMORE, rcvmore, sz), 0)
self.assertFalse(rcvmore)
# clean up.
self.assertEqual(xs.close(req), 0)
self.assertEqual(xs.close(rep), 0)
self.assertEqual(xs.close(xrep), 0)
self.assertEqual(xs.close(xreq), 0)
self.assertEqual(xs.term(ctx), 0)
