desc stringlengths 3 26.7k | decl stringlengths 11 7.89k | bodies stringlengths 8 553k |
|---|---|---|
'setting socket options with ctx attributes'
| def test_sockopts(self):
| ctx = self.Context()
ctx.linger = 5
self.assertEqual(ctx.linger, 5)
s = ctx.socket(zmq.REQ)
self.assertEqual(s.linger, 5)
self.assertEqual(s.getsockopt(zmq.LINGER), 5)
s.close()
ctx.subscribe = ''
s = ctx.socket(zmq.REQ)
s.close()
ctx.term()
|
'Context.destroy should close sockets'
| def test_destroy(self):
| ctx = self.Context()
sockets = [ctx.socket(zmq.REP) for i in range(65)]
[s.close() for s in sockets[::2]]
ctx.destroy()
time.sleep(0.01)
for s in sockets:
self.assertTrue(s.closed)
|
'Context.destroy should set linger on closing sockets'
| def test_destroy_linger(self):
| (req, rep) = self.create_bound_pair(zmq.REQ, zmq.REP)
req.send('hi')
time.sleep(0.01)
self.context.destroy(linger=0)
time.sleep(0.01)
for s in (req, rep):
self.assertTrue(s.closed)
|
'Context.term won\'t close sockets'
| def test_term_noclose(self):
| ctx = self.Context()
s = ctx.socket(zmq.REQ)
self.assertFalse(s.closed)
t = Thread(target=ctx.term)
t.start()
t.join(timeout=0.1)
self.assertTrue(t.is_alive(), 'Context should be waiting')
s.close()
t.join(timeout=0.1)
self.assertFalse(t.is_alive(), 'Context should ... |
'test close&term by garbage collection alone'
| def test_gc(self):
| if PYPY:
raise SkipTest("GC doesn't work ")
def gcf():
def inner():
ctx = self.Context()
s = ctx.socket(zmq.PUSH)
inner()
gc.collect()
t = Thread(target=gcf)
t.start()
t.join(timeout=1)
self.assertFalse(t.is_alive(), 'Garbage co... |
'ctx.destroy should succeed when cyclic ref prevents gc'
| def test_cyclic_destroy(self):
| class CyclicReference(object, ):
def __init__(self, parent=None):
self.parent = parent
def crash(self, sock):
self.sock = sock
self.child = CyclicReference(self)
def crash_zmq():
ctx = self.Context()
sock = ctx.socket(zmq.PULL)
c = Cycl... |
'ctx.term should not crash active threads (#139)'
| def test_term_thread(self):
| ctx = self.Context()
evt = Event()
evt.clear()
def block():
s = ctx.socket(zmq.REP)
s.bind_to_random_port('tcp://127.0.0.1')
evt.set()
try:
s.recv()
except zmq.ZMQError as e:
self.assertEqual(e.errno, zmq.ETERM)
return
f... |
'make sure Poller.poll timeout has the right units (milliseconds).'
| def test_timeout(self):
| (s1, s2) = self.create_bound_pair(zmq.PAIR, zmq.PAIR)
poller = self.Poller()
poller.register(s1, zmq.POLLIN)
tic = time.time()
evt = poller.poll(0.005)
toc = time.time()
self.assertTrue(((toc - tic) < 0.1))
tic = time.time()
evt = poller.poll(5)
toc = time.time()
self.assertT... |
'make sure select timeout has the right units (seconds).'
| def test_timeout(self):
| (s1, s2) = self.create_bound_pair(zmq.PAIR, zmq.PAIR)
tic = time.time()
(r, w, x) = zmq.select([s1, s2], [], [], 0.005)
toc = time.time()
self.assertTrue(((toc - tic) < 1))
self.assertTrue(((toc - tic) > 0.001))
tic = time.time()
(r, w, x) = zmq.select([s1, s2], [], [], 0.25)
toc = t... |
'Create CURVE certificates for a test'
| def create_certs(self):
| base_dir = tempfile.mkdtemp()
keys_dir = os.path.join(base_dir, 'certificates')
public_keys_dir = os.path.join(base_dir, 'public_keys')
secret_keys_dir = os.path.join(base_dir, 'private_keys')
os.mkdir(keys_dir)
os.mkdir(public_keys_dir)
os.mkdir(secret_keys_dir)
(server_public_file, ser... |
'Remove certificates for a test'
| def remove_certs(self, base_dir):
| shutil.rmtree(base_dir)
|
'Return server and client certificate keys'
| def load_certs(self, secret_keys_dir):
| server_secret_file = os.path.join(secret_keys_dir, 'server.key_secret')
client_secret_file = os.path.join(secret_keys_dir, 'client.key_secret')
(server_public, server_secret) = zmq.auth.load_certificate(server_secret_file)
(client_public, client_secret) = zmq.auth.load_certificate(client_secret_file)
... |
'Check if client can connect to server using tcp transport'
| def can_connect(self, server, client):
| result = False
iface = 'tcp://127.0.0.1'
port = server.bind_to_random_port(iface)
client.connect(('%s:%i' % (iface, port)))
msg = ['Hello World']
if server.poll(1000, zmq.POLLOUT):
server.send_multipart(msg)
if client.poll(1000):
rcvd_msg = client.recv_multipart()
... |
'threaded auth - NULL'
| def test_null(self):
| self.auth.stop()
self.auth = None
self.context = self.Context()
server = self.socket(zmq.PUSH)
client = self.socket(zmq.PULL)
self.assertTrue(self.can_connect(server, client))
server = self.socket(zmq.PUSH)
server.zap_domain = 'global'
client = self.socket(zmq.PULL)
self.assertTr... |
'threaded auth - Blacklist'
| def test_blacklist(self):
| self.auth.deny('127.0.0.1')
server = self.socket(zmq.PUSH)
server.zap_domain = 'global'
client = self.socket(zmq.PULL)
self.assertFalse(self.can_connect(server, client))
|
'threaded auth - Whitelist'
| def test_whitelist(self):
| self.auth.allow('127.0.0.1')
server = self.socket(zmq.PUSH)
server.zap_domain = 'global'
client = self.socket(zmq.PULL)
self.assertTrue(self.can_connect(server, client))
|
'threaded auth - PLAIN'
| def test_plain(self):
| server = self.socket(zmq.PUSH)
server.plain_server = True
client = self.socket(zmq.PULL)
client.plain_username = 'admin'
client.plain_password = 'Password'
self.assertFalse(self.can_connect(server, client))
server = self.socket(zmq.PUSH)
server.plain_server = True
client = self.socke... |
'threaded auth - CURVE'
| def test_curve(self):
| self.auth.allow('127.0.0.1')
certs = self.load_certs(self.secret_keys_dir)
(server_public, server_secret, client_public, client_secret) = certs
server = self.socket(zmq.PUSH)
server.curve_publickey = server_public
server.curve_secretkey = server_secret
server.curve_server = True
client =... |
'threaded auth - CURVE'
| @skip_pypy
def test_curve_user_id(self):
| self.auth.allow('127.0.0.1')
certs = self.load_certs(self.secret_keys_dir)
(server_public, server_secret, client_public, client_secret) = certs
self.auth.configure_curve(domain='*', location=self.public_keys_dir)
server = self.socket(zmq.PULL)
server.curve_publickey = server_public
server.cu... |
'Check if client can connect to server using tcp transport'
| def attempt_connection(self):
| iface = 'tcp://127.0.0.1'
port = self.server.bind_to_random_port(iface)
self.client.connect(('%s:%i' % (iface, port)))
|
'Send a message from server to a client'
| def send_msg(self):
| msg = ['Hello World']
self.pushstream.send_multipart(msg)
|
'A message was received, as expected.'
| def on_message_succeed(self, frames):
| if (frames != ['Hello World']):
self.fail_msg = 'Unexpected message received'
self.io_loop.stop()
|
'A message was received, unexpectedly.'
| def on_message_fail(self, frames):
| self.fail_msg = 'Received messaged unexpectedly, security failed'
self.io_loop.stop()
|
'Test timer expired, indicates test success'
| def on_test_timeout_succeed(self):
| self.io_loop.stop()
|
'Test timer expired, indicates test failure'
| def on_test_timeout_fail(self):
| self.fail_msg = 'Test timed out'
self.io_loop.stop()
|
'ioloop auth - NONE'
| @should_auth
def test_none(self):
| self.auth.stop()
self.auth = None
|
'ioloop auth - NULL'
| @should_auth
def test_null(self):
| self.server.zap_domain = 'global'
|
'ioloop auth - Blacklist'
| @should_not_auth
def test_blacklist(self):
| self.auth.deny('127.0.0.1')
self.server.zap_domain = 'global'
|
'ioloop auth - Whitelist'
| @should_auth
def test_whitelist(self):
| self.auth.allow('127.0.0.1')
self.server.setsockopt(zmq.ZAP_DOMAIN, 'global')
|
'ioloop auth - PLAIN, unconfigured server'
| @should_not_auth
def test_plain_unconfigured_server(self):
| self.client.plain_username = 'admin'
self.client.plain_password = 'Password'
self.server.plain_server = True
|
'ioloop auth - PLAIN, configured server'
| @should_auth
def test_plain_configured_server(self):
| self.client.plain_username = 'admin'
self.client.plain_password = 'Password'
self.server.plain_server = True
self.auth.configure_plain(domain='*', passwords={'admin': 'Password'})
|
'ioloop auth - PLAIN, bogus credentials'
| @should_not_auth
def test_plain_bogus_credentials(self):
| self.client.plain_username = 'admin'
self.client.plain_password = 'Bogus'
self.server.plain_server = True
self.auth.configure_plain(domain='*', passwords={'admin': 'Password'})
|
'ioloop auth - CURVE, unconfigured server'
| @should_not_auth
def test_curve_unconfigured_server(self):
| certs = self.load_certs(self.secret_keys_dir)
(server_public, server_secret, client_public, client_secret) = certs
self.auth.allow('127.0.0.1')
self.server.curve_publickey = server_public
self.server.curve_secretkey = server_secret
self.server.curve_server = True
self.client.curve_publickey ... |
'ioloop auth - CURVE, CURVE_ALLOW_ANY'
| @should_auth
def test_curve_allow_any(self):
| certs = self.load_certs(self.secret_keys_dir)
(server_public, server_secret, client_public, client_secret) = certs
self.auth.allow('127.0.0.1')
self.auth.configure_curve(domain='*', location=zmq.auth.CURVE_ALLOW_ANY)
self.server.curve_publickey = server_public
self.server.curve_secretkey = serve... |
'ioloop auth - CURVE, configured server'
| @should_auth
def test_curve_configured_server(self):
| self.auth.allow('127.0.0.1')
certs = self.load_certs(self.secret_keys_dir)
(server_public, server_secret, client_public, client_secret) = certs
self.auth.configure_curve(domain='*', location=self.public_keys_dir)
self.server.curve_publickey = server_public
self.server.curve_secretkey = server_se... |
'Create a bound socket pair using a random port.'
| def create_bound_pair(self, type1=zmq.PAIR, type2=zmq.PAIR, interface='tcp://127.0.0.1'):
| s1 = self.context.socket(type1)
s1.setsockopt(zmq.LINGER, 0)
port = s1.bind_to_random_port(interface)
s2 = self.context.socket(type2)
s2.setsockopt(zmq.LINGER, 0)
s2.connect(('%s:%s' % (interface, port)))
self.sockets.extend([s1, s2])
return (s1, s2)
|
'call recv[_multipart] in a way that raises if there is nothing to receive'
| def _select_recv(self, multipart, socket, **kwargs):
| if (zmq.zmq_version_info() >= (3, 1, 0)):
time.sleep(0.1)
(r, w, x) = zmq.select([socket], [], [], timeout=5)
assert (len(r) > 0), 'Should have received a message'
kwargs['flags'] = (zmq.DONTWAIT | kwargs.get('flags', 0))
recv = (socket.recv_multipart if multipart else socket.rec... |
'call recv in a way that raises if there is nothing to receive'
| def recv(self, socket, **kwargs):
| return self._select_recv(False, socket, **kwargs)
|
'call recv_multipart in a way that raises if there is nothing to receive'
| def recv_multipart(self, socket, **kwargs):
| return self._select_recv(True, socket, **kwargs)
|
'Test monitoring interface for sockets.'
| @require_zmq_4
def test_monitor(self):
| s_rep = self.context.socket(zmq.REP)
s_req = self.context.socket(zmq.REQ)
self.sockets.extend([s_rep, s_req])
s_req.bind('tcp://127.0.0.1:6666')
s_rep.monitor('inproc://monitor.rep', zmq.EVENT_ALL)
s_event = self.context.socket(zmq.PAIR)
self.sockets.append(s_event)
s_event.connect('inpr... |
'Test connected monitoring socket.'
| @require_zmq_4
def test_monitor_connected(self):
| s_rep = self.context.socket(zmq.REP)
s_req = self.context.socket(zmq.REQ)
self.sockets.extend([s_rep, s_req])
s_req.bind('tcp://127.0.0.1:6667')
s_event = s_rep.get_monitor_socket()
s_event.linger = 0
self.sockets.append(s_event)
s_rep.connect('tcp://127.0.0.1:6667')
m = recv_monitor... |
'test router-router MQ devices'
| def test_router_router(self):
| dev = devices.ThreadMonitoredQueue(zmq.ROUTER, zmq.ROUTER, zmq.PUB, 'in', 'out')
self.device = dev
dev.setsockopt_in(zmq.LINGER, 0)
dev.setsockopt_out(zmq.LINGER, 0)
dev.setsockopt_mon(zmq.LINGER, 0)
binder = self.context.socket(zmq.DEALER)
porta = binder.bind_to_random_port('tcp://127.0.0.1... |
'test that strerror gets the right type.'
| def test_strerror(self):
| for i in range(10):
e = strerror(i)
self.assertTrue(isinstance(e, str))
|
'test that a given list has no duplicates'
| def _duplicate_test(self, namelist, listname):
| dupes = {}
for name in set(namelist):
cnt = namelist.count(name)
if (cnt > 1):
dupes[name] = cnt
if dupes:
self.fail(('The following names occur more than once in %s: %s' % (listname, json.dumps(dupes, indent=2))))
|
'return changed-in key'
| def _change_key(self, change, version):
| return ('%s-in %d.%d.%d' % tuple(([change] + list(version))))
|
'test NULL (default) security'
| def test_null(self):
| server = self.socket(zmq.DEALER)
client = self.socket(zmq.DEALER)
self.assertEqual(client.MECHANISM, zmq.NULL)
self.assertEqual(server.mechanism, zmq.NULL)
self.assertEqual(client.plain_server, 0)
self.assertEqual(server.plain_server, 0)
iface = 'tcp://127.0.0.1'
port = server.bind_to_ra... |
'test PLAIN authentication'
| def test_plain(self):
| server = self.socket(zmq.DEALER)
server.identity = 'IDENT'
client = self.socket(zmq.DEALER)
self.assertEqual(client.plain_username, '')
self.assertEqual(client.plain_password, '')
client.plain_username = USER
client.plain_password = PASS
self.assertEqual(client.getsockopt(zmq.PLAIN_USERN... |
'test PLAIN failed authentication'
| def skip_plain_inauth(self):
| server = self.socket(zmq.DEALER)
server.identity = 'IDENT'
client = self.socket(zmq.DEALER)
self.sockets.extend([server, client])
client.plain_username = USER
client.plain_password = 'incorrect'
server.plain_server = True
self.assertEqual(server.mechanism, zmq.PLAIN)
self.assertEqual... |
'test curve_keypair'
| def test_keypair(self):
| try:
(public, secret) = zmq.curve_keypair()
except zmq.ZMQError:
raise SkipTest('CURVE unsupported')
self.assertEqual(type(secret), bytes)
self.assertEqual(type(public), bytes)
self.assertEqual(len(secret), 40)
self.assertEqual(len(public), 40)
(bsecret, bpublic) = [z85.de... |
'test CURVE encryption'
| def test_curve(self):
| server = self.socket(zmq.DEALER)
server.identity = 'IDENT'
client = self.socket(zmq.DEALER)
self.sockets.extend([server, client])
try:
server.curve_server = True
except zmq.ZMQError as e:
if (e.errno == zmq.EINVAL):
raise SkipTest('CURVE unsupported')
(server_p... |
'Ensure callable check works (py3k).'
| def test_callable_check(self):
| self.stream.on_send((lambda *args: None))
self.stream.on_recv((lambda *args: None))
self.assertRaises(AssertionError, self.stream.on_recv, 1)
self.assertRaises(AssertionError, self.stream.on_send, 1)
self.assertRaises(AssertionError, self.stream.on_recv, zmq)
|
'simple IOLoop creation test'
| def test_simple(self):
| loop = ioloop.IOLoop()
dc = ioloop.PeriodicCallback(loop.stop, 200, loop)
pc = ioloop.PeriodicCallback((lambda : None), 10, loop)
pc.start()
dc.start()
t = Delay(loop.stop, 1)
t.start()
loop.start()
if t.isAlive():
t.abort()
else:
self.fail('IOLoop failed to... |
'Green IOLoop.instance returns the right object'
| def test_instance(self):
| loop = ioloop.IOLoop.instance()
assert isinstance(loop, ioloop.IOLoop)
base_loop = BaseIOLoop.instance()
assert (base_loop is loop)
|
'Green IOLoop.current returns the right object'
| def test_current(self):
| loop = ioloop.IOLoop.current()
assert isinstance(loop, ioloop.IOLoop)
base_loop = BaseIOLoop.current()
assert (base_loop is loop)
|
'Test close(all_fds=True)'
| def test_close_all(self):
| loop = ioloop.IOLoop.instance()
(req, rep) = self.create_bound_pair(zmq.REQ, zmq.REP)
loop.add_handler(req, (lambda msg: msg), ioloop.IOLoop.READ)
loop.add_handler(rep, (lambda msg: msg), ioloop.IOLoop.READ)
self.assertEqual(req.closed, False)
self.assertEqual(rep.closed, False)
loop.close(a... |
'test setting/getting sockopts with unicode strings'
| def test_unicode_sockopts(self):
| topic = 't\xc3\xa9st'
if (str is not unicode):
topic = topic.decode('utf8')
(p, s) = self.create_bound_pair(zmq.PUB, zmq.SUB)
self.assertEqual(s.send_unicode, s.send_unicode)
self.assertEqual(p.recv_unicode, p.recv_unicode)
self.assertRaises(TypeError, s.setsockopt, zmq.SUBSCRIBE, topic)... |
'test integer sockopts'
| def test_int_sockopts(self):
| v = zmq.zmq_version_info()
if (v < (3, 0)):
default_hwm = 0
else:
default_hwm = 1000
(p, s) = self.create_bound_pair(zmq.PUB, zmq.SUB)
p.setsockopt(zmq.LINGER, 0)
self.assertEqual(p.getsockopt(zmq.LINGER), 0)
p.setsockopt(zmq.LINGER, (-1))
self.assertEqual(p.getsockopt(zm... |
'Test that appropriate errors are raised on bad socket options'
| def test_bad_sockopts(self):
| s = self.context.socket(zmq.PUB)
self.sockets.append(s)
s.setsockopt(zmq.LINGER, 0)
self.assertRaisesErrno(zmq.EINVAL, s.setsockopt, 9999, 5)
self.assertRaisesErrno(zmq.EINVAL, s.getsockopt, 9999)
self.assertRaises(TypeError, s.setsockopt, 9999, '5')
self.assertRaisesErrno(zmq.EINVAL, s.sets... |
'test set/getsockopt roundtrip.'
| def test_sockopt_roundtrip(self):
| p = self.context.socket(zmq.PUB)
self.sockets.append(p)
p.setsockopt(zmq.LINGER, 11)
self.assertEqual(p.getsockopt(zmq.LINGER), 11)
|
'test sending unicode objects'
| def test_send_unicode(self):
| (a, b) = self.create_bound_pair(zmq.PAIR, zmq.PAIR)
self.sockets.extend([a, b])
u = '\xc3\xa7\xcf\x80\xc2\xa7'
if (str is not unicode):
u = u.decode('utf8')
self.assertRaises(TypeError, a.send, u, copy=False)
self.assertRaises(TypeError, a.send, u, copy=True)
a.send_unicode(u)
s ... |
'check type on all frames in send_multipart'
| def test_send_multipart_check_type(self):
| (a, b) = self.create_bound_pair(zmq.PAIR, zmq.PAIR)
self.sockets.extend([a, b])
self.assertRaises(TypeError, a.send_multipart, ['a', 5])
a.send_multipart(['b'])
rcvd = self.recv_multipart(b)
self.assertEqual(rcvd, ['b'])
|
'test the MessageTracker object for tracking when zmq is done with a buffer'
| @skip_pypy
def test_tracker(self):
| addr = 'tcp://127.0.0.1'
sock = socket.socket()
sock.bind(('127.0.0.1', 0))
port = sock.getsockname()[1]
iface = ('%s:%i' % (addr, port))
sock.close()
time.sleep(0.1)
a = self.context.socket(zmq.PUSH)
b = self.context.socket(zmq.PULL)
self.sockets.extend([a, b])
a.connect(ifa... |
'set setting/getting sockopts as attributes'
| def test_attr(self):
| s = self.context.socket(zmq.DEALER)
self.sockets.append(s)
linger = 10
s.linger = linger
self.assertEqual(linger, s.linger)
self.assertEqual(linger, s.getsockopt(zmq.LINGER))
self.assertEqual(s.fd, s.getsockopt(zmq.FD))
|
'subclasses can assign attributes'
| def test_subclass(self):
| class S(zmq.Socket, ):
a = None
def __init__(self, *a, **kw):
self.a = (-1)
super(S, self).__init__(*a, **kw)
s = S(self.context, zmq.REP)
self.sockets.append(s)
self.assertEqual(s.a, (-1))
s.a = 1
self.assertEqual(s.a, 1)
a = s.a
self.assertEqual(... |
's.close() after ctx.destroy() should be fine'
| def test_close_after_destroy(self):
| ctx = self.Context()
s = ctx.socket(zmq.REP)
ctx.destroy()
time.sleep(0.01)
s.close()
self.assertTrue(s.closed)
|
'IPC_PATH_MAX_LEN is a sensible value'
| def test_ipc_path_max_length(self):
| if (zmq.IPC_PATH_MAX_LEN == 0):
raise SkipTest('IPC_PATH_MAX_LEN undefined')
msg = ('Surprising value for IPC_PATH_MAX_LEN: %s' % zmq.IPC_PATH_MAX_LEN)
self.assertTrue((zmq.IPC_PATH_MAX_LEN > 30), msg)
self.assertTrue((zmq.IPC_PATH_MAX_LEN < 1025), msg)
|
'test toplevel import'
| def test_toplevel(self):
| import zmq
|
'test core imports'
| def test_core(self):
| from zmq import Context
from zmq import Socket
from zmq import Poller
from zmq import Frame
from zmq import constants
from zmq import device, proxy
from zmq import zmq_version, zmq_version_info, pyzmq_version, pyzmq_version_info
|
'test device imports'
| def test_devices(self):
| import zmq.devices
from zmq.devices import basedevice
from zmq.devices import monitoredqueue
from zmq.devices import monitoredqueuedevice
|
'test log imports'
| def test_log(self):
| import zmq.log
from zmq.log import handlers
|
'test eventloop imports'
| def test_eventloop(self):
| try:
import tornado
except ImportError:
pytest.skip('requires tornado')
import zmq.eventloop
from zmq.eventloop import ioloop
from zmq.eventloop import zmqstream
|
'test util imports'
| def test_utils(self):
| import zmq.utils
from zmq.utils import strtypes
from zmq.utils import jsonapi
|
'test ssh imports'
| def test_ssh(self):
| from zmq.ssh import tunnel
|
'test decorators imports'
| def test_decorators(self):
| from zmq.decorators import context, socket
|
'Message above 30 bytes are never copied by 0MQ.'
| @skip_pypy
def test_above_30(self):
| for i in range(5, 16):
s = ((2 ** i) * x)
self.assertEqual(grc(s), 2)
m = zmq.Frame(s)
self.assertEqual(grc(s), 4)
del m
await_gc(s, 2)
self.assertEqual(grc(s), 2)
del s
|
'Test the str representations of the Frames.'
| def test_str(self):
| for i in range(16):
s = ((2 ** i) * x)
m = zmq.Frame(s)
m_str = str(m)
m_str_b = b(m_str)
self.assertEqual(s, m_str_b)
|
'Test the Frame.bytes property.'
| def test_bytes(self):
| for i in range(1, 16):
s = ((2 ** i) * x)
m = zmq.Frame(s)
b = m.bytes
self.assertEqual(s, m.bytes)
if (not PYPY):
self.assert_((b is not s))
self.assert_((b is m.bytes))
|
'Test the unicode representations of the Frames.'
| def test_unicode(self):
| s = u('asdf')
self.assertRaises(TypeError, zmq.Frame, s)
for i in range(16):
s = ((2 ** i) * u('\xc2\xa7'))
m = zmq.Frame(s.encode('utf8'))
self.assertEqual(s, unicode(m.bytes, 'utf8'))
|
'Test the len of the Frames.'
| def test_len(self):
| for i in range(16):
s = ((2 ** i) * x)
m = zmq.Frame(s)
self.assertEqual(len(s), len(m))
|
'Run through a ref counting cycle with a copy.'
| @skip_pypy
def test_lifecycle1(self):
| for i in range(5, 16):
s = ((2 ** i) * x)
rc = 2
self.assertEqual(grc(s), rc)
m = zmq.Frame(s)
rc += 2
self.assertEqual(grc(s), rc)
m2 = copy.copy(m)
rc += 1
self.assertEqual(grc(s), rc)
buf = m2.buffer
rc += view_rc
sel... |
'Run through a different ref counting cycle with a copy.'
| @skip_pypy
def test_lifecycle2(self):
| for i in range(5, 16):
s = ((2 ** i) * x)
rc = 2
self.assertEqual(grc(s), rc)
m = zmq.Frame(s)
rc += 2
self.assertEqual(grc(s), rc)
m2 = copy.copy(m)
rc += 1
self.assertEqual(grc(s), rc)
buf = m.buffer
rc += view_rc
self... |
'test using a buffer as input'
| def test_buffer_in(self):
| ins = b('\xc2\xa7\xc2\xa7\xc2\xb6\xe2\x80\xa2\xc2\xaa\xc2\xba\xcb\x9c\xc2\xb5\xc2\xac\xcb\x9a\xe2\x80\xa6\xe2\x88\x86\xcb\x99\xc3\xa5\xc3\x9f\xe2\x88\x82\xc2\xa9\xc5\x93\xe2\x88\x91\xc2\xb4\xe2\x80\xa0\xe2\x89\x88\xc3\xa7\xe2\x88\x9a')
m = zmq.Frame(view(ins))
|
'test using a bad object'
| def test_bad_buffer_in(self):
| self.assertRaises(TypeError, zmq.Frame, 5)
self.assertRaises(TypeError, zmq.Frame, object())
|
'receiving buffered output'
| def test_buffer_out(self):
| ins = b('\xc2\xa7\xc2\xa7\xc2\xb6\xe2\x80\xa2\xc2\xaa\xc2\xba\xcb\x9c\xc2\xb5\xc2\xac\xcb\x9a\xe2\x80\xa6\xe2\x88\x86\xcb\x99\xc3\xa5\xc3\x9f\xe2\x88\x82\xc2\xa9\xc5\x93\xe2\x88\x91\xc2\xb4\xe2\x80\xa0\xe2\x89\x88\xc3\xa7\xe2\x88\x9a')
m = zmq.Frame(ins)
outb = m.buffer
self.assertTrue(isinstance(outb, ... |
'memoryview shape info'
| @skip_pypy
def test_memoryview_shape(self):
| if (sys.version_info < (3,)):
raise SkipTest('only test memoryviews on Python 3')
data = b('\xc2\xa7\xc2\xa7\xc2\xb6\xe2\x80\xa2\xc2\xaa\xc2\xba\xcb\x9c\xc2\xb5\xc2\xac\xcb\x9a\xe2\x80\xa6\xe2\x88\x86\xcb\x99\xc3\xa5\xc3\x9f\xe2\x88\x82\xc2\xa9\xc5\x93\xe2\x88\x91\xc2\xb4\xe2\x80\xa0\xe2\... |
'ensure that a message remains intact after multiple sends'
| def test_multisend(self):
| (a, b) = self.create_bound_pair(zmq.PAIR, zmq.PAIR)
s = 'message'
m = zmq.Frame(s)
self.assertEqual(s, m.bytes)
a.send(m, copy=False)
time.sleep(0.1)
self.assertEqual(s, m.bytes)
a.send(m, copy=False)
time.sleep(0.1)
self.assertEqual(s, m.bytes)
a.send(m, copy=True)
time.... |
'test non-copying numpy array messages'
| def test_buffer_numpy(self):
| try:
import numpy
except ImportError:
raise SkipTest('numpy required')
rand = numpy.random.randint
shapes = [rand(2, 16) for i in range(5)]
for i in range(1, (len(shapes) + 1)):
shape = shapes[:i]
A = numpy.random.random(shape)
m = zmq.Frame(A)
if (... |
'test messages from memoryview'
| def test_memoryview(self):
| (major, minor) = sys.version_info[:2]
if (not ((major >= 3) or ((major == 2) and (minor >= 7)))):
raise SkipTest('memoryviews only in python >= 2.7')
s = 'carrotjuice'
v = memoryview(s)
m = zmq.Frame(s)
buf = m.buffer
s2 = buf.tobytes()
self.assertEqual(s2, s)
... |
'check for clobbering message buffers'
| def test_noncopying_recv(self):
| null = ('\x00' * 64)
(sa, sb) = self.create_bound_pair(zmq.PAIR, zmq.PAIR)
for i in range(32):
sb.send(null, copy=False)
m = sa.recv(copy=False)
mb = m.bytes
buf = m.buffer
del m
for i in range(5):
ff = ('\xff' * (40 + (i * 10)))
sb.sen... |
'test non-copying numpy array messages'
| @skip_pypy
def test_buffer_numpy(self):
| try:
import numpy
except ImportError:
raise SkipTest('requires numpy')
if (sys.version_info < (2, 7)):
raise SkipTest('requires new-style buffer interface (py >= 2.7)')
rand = numpy.random.randint
shapes = [rand(2, 5) for i in range(5)]
(a, b) = self.... |
'test Frame.more attribute'
| def test_frame_more(self):
| frame = zmq.Frame('hello')
self.assertFalse(frame.more)
(sa, sb) = self.create_bound_pair(zmq.PAIR, zmq.PAIR)
sa.send_multipart(['hi', 'there'])
frame = self.recv(sb, copy=False)
self.assertTrue(frame.more)
if ((zmq.zmq_version_info()[0] >= 3) and (not PYPY)):
self.assertTrue(frame.g... |
'Wrap an errno style error.
Parameters
errno : int
The ZMQ errno or None. If None, then ``zmq_errno()`` is called and
used.
msg : string
Description of the error or None.'
| def __init__(self, errno=None, msg=None):
| from zmq.backend import strerror, zmq_errno
if (errno is None):
errno = zmq_errno()
if isinstance(errno, int):
self.errno = errno
if (msg is None):
self.strerror = strerror(errno)
else:
self.strerror = msg
elif (msg is None):
self.strerror ... |
'Schedule callback for a raw socket'
| def _watch_raw_socket(self, loop, socket, evt, f):
| if (evt & self._READ):
loop.add_reader(socket, (lambda *args: f()))
if (evt & self._WRITE):
loop.add_writer(socket, (lambda *args: f()))
|
'Unschedule callback for a raw socket'
| def _unwatch_raw_sockets(self, loop, *sockets):
| for socket in sockets:
loop.remove_reader(socket)
loop.remove_writer(socket)
|
'initialize the ioloop event handler'
| def _init_io_state(self):
| self.io_loop.add_reader(self._shadow_sock.FD, (lambda : self._handle_events(0, 0)))
|
'clear any ioloop event handler
called once at close'
| def _clear_io_state(self):
| self.io_loop.remove_reader(self._shadow_sock.FD)
|
'Return a Future for a poll event'
| def poll(self, timeout=(-1)):
| future = self._Future()
if (timeout == 0):
try:
result = super(_AsyncPoller, self).poll(0)
except Exception as e:
future.set_exception(e)
else:
future.set_result(result)
return future
loop = self._default_loop()
watcher = self._Future()... |
'Create an async socket from an existing Socket'
| @classmethod
def from_socket(cls, socket, io_loop=None):
| return cls(_from_socket=socket, io_loop=io_loop)
|
'Receive a complete multipart zmq message.
Returns a Future whose result will be a multipart message.'
| def recv_multipart(self, flags=0, copy=True, track=False):
| return self._add_recv_event('recv_multipart', dict(flags=flags, copy=copy, track=track))
|
'Receive a single zmq frame.
Returns a Future, whose result will be the received frame.
Recommend using recv_multipart instead.'
| def recv(self, flags=0, copy=True, track=False):
| return self._add_recv_event('recv', dict(flags=flags, copy=copy, track=track))
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.