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)