コード例 #1
0
ファイル: test_cffi_backend.py プロジェクト: daqing15/pyzmq
    def test_zmq_recv(self):
        ctx = C.zmq_ctx_new()

        sender = C.zmq_socket(ctx, REQ)
        receiver = C.zmq_socket(ctx, REP)

        assert 0 == C.zmq_bind(receiver, 'tcp://*:2222')
        assert 0 == C.zmq_connect(sender, 'tcp://127.0.0.1:2222')

        time.sleep(0.1)

        zmq_msg = ffi.new('zmq_msg_t*')
        message = ffi.new('char[5]', 'Hello')

        C.zmq_msg_init_data(zmq_msg,
                            ffi.cast('void*', message),
                            ffi.cast('size_t', 5),
                            ffi.NULL,
                            ffi.NULL)

        zmq_msg2 = ffi.new('zmq_msg_t*')
        C.zmq_msg_init(zmq_msg2)

        assert 5 == C.zmq_msg_send(zmq_msg, sender, 0)
        assert 5 == C.zmq_msg_recv(zmq_msg2, receiver, 0)
        assert 5 == C.zmq_msg_size(zmq_msg2)
        assert b"Hello" == ffi.buffer(C.zmq_msg_data(zmq_msg2),
                                      C.zmq_msg_size(zmq_msg2))[:]
        assert C.zmq_close(sender) == 0
        assert C.zmq_close(receiver) == 0
        assert C.zmq_ctx_destroy(ctx) == 0
コード例 #2
0
    def test_zmq_recv(self):
        ctx = C.zmq_ctx_new()

        sender = C.zmq_socket(ctx, REQ)
        receiver = C.zmq_socket(ctx, REP)

        assert 0 == C.zmq_bind(receiver, 'tcp://*:2222')
        assert 0 == C.zmq_connect(sender, 'tcp://127.0.0.1:2222')

        time.sleep(0.1)

        zmq_msg = ffi.new('zmq_msg_t*')
        message = ffi.new('char[5]', 'Hello')

        C.zmq_msg_init_data(zmq_msg, ffi.cast('void*', message),
                            ffi.cast('size_t', 5), ffi.NULL, ffi.NULL)

        zmq_msg2 = ffi.new('zmq_msg_t*')
        C.zmq_msg_init(zmq_msg2)

        assert 5 == C.zmq_msg_send(zmq_msg, sender, 0)
        assert 5 == C.zmq_msg_recv(zmq_msg2, receiver, 0)
        assert 5 == C.zmq_msg_size(zmq_msg2)
        assert b"Hello" == ffi.buffer(C.zmq_msg_data(zmq_msg2),
                                      C.zmq_msg_size(zmq_msg2))[:]
        assert C.zmq_close(sender) == 0
        assert C.zmq_close(receiver) == 0
        assert C.zmq_ctx_destroy(ctx) == 0
コード例 #3
0
ファイル: test_cffi_backend.py プロジェクト: 326029212/pyzmq
    def test_zmq_send(self):
        ctx = C.zmq_ctx_new()

        sender = C.zmq_socket(ctx, REQ)
        receiver = C.zmq_socket(ctx, REP)

        assert 0 == C.zmq_bind(receiver, b'tcp://*:7777')
        assert 0 == C.zmq_connect(sender, b'tcp://127.0.0.1:7777')

        time.sleep(0.1)

        zmq_msg = ffi.new('zmq_msg_t*')
        message = ffi.new('char[5]', b'Hello')

        C.zmq_msg_init_data(zmq_msg,
                            ffi.cast('void*', message),
                            ffi.cast('size_t', 5),
                            ffi.NULL,
                            ffi.NULL)

        assert 5 == C.zmq_msg_send(zmq_msg, sender, 0)
        assert 0 == C.zmq_msg_close(zmq_msg)
        assert C.zmq_close(sender) == 0
        assert C.zmq_close(receiver) == 0
        assert C.zmq_ctx_destroy(ctx) == 0
コード例 #4
0
    def test_zmq_send(self):
        ctx = C.zmq_ctx_new()

        sender = C.zmq_socket(ctx, REQ)
        receiver = C.zmq_socket(ctx, REP)

        assert 0 == C.zmq_bind(receiver, b'tcp://*:7777')
        assert 0 == C.zmq_connect(sender, b'tcp://127.0.0.1:7777')

        time.sleep(0.1)

        zmq_msg = ffi.new('zmq_msg_t*')
        message = ffi.new('char[5]', b'Hello')

        C.zmq_msg_init_data(
            zmq_msg,
            ffi.cast('void*', message),
            ffi.cast('size_t', 5),
            ffi.NULL,
            ffi.NULL,
        )

        assert 5 == C.zmq_msg_send(zmq_msg, sender, 0)
        assert 0 == C.zmq_msg_close(zmq_msg)
        assert C.zmq_close(sender) == 0
        assert C.zmq_close(receiver) == 0
        assert C.zmq_ctx_destroy(ctx) == 0
コード例 #5
0
    def test_zmq_msg_init_data(self):
        zmq_msg = ffi.new('zmq_msg_t*')
        message = ffi.new('char[5]', 'Hello')

        assert 0 == C.zmq_msg_init_data(zmq_msg, ffi.cast('void*', message), 5,
                                        ffi.NULL, ffi.NULL)

        assert ffi.NULL != zmq_msg
        assert 0 == C.zmq_msg_close(zmq_msg)
コード例 #6
0
    def test_zmq_msg_data(self):
        zmq_msg = ffi.new('zmq_msg_t*')
        message = ffi.new('char[]', 'Hello')
        assert 0 == C.zmq_msg_init_data(zmq_msg, ffi.cast('void*', message), 5,
                                        ffi.NULL, ffi.NULL)

        data = C.zmq_msg_data(zmq_msg)

        assert ffi.NULL != zmq_msg
        assert ffi.string(ffi.cast("char*", data)) == 'Hello'
        assert 0 == C.zmq_msg_close(zmq_msg)
コード例 #7
0
ファイル: test_cffi_backend.py プロジェクト: daqing15/pyzmq
    def test_zmq_msg_init_data(self):
        zmq_msg = ffi.new('zmq_msg_t*')
        message = ffi.new('char[5]', 'Hello')

        assert 0 == C.zmq_msg_init_data(zmq_msg,
                                        ffi.cast('void*', message),
                                        5,
                                        ffi.NULL,
                                        ffi.NULL)

        assert ffi.NULL != zmq_msg
        assert 0 == C.zmq_msg_close(zmq_msg)
コード例 #8
0
ファイル: test_cffi_backend.py プロジェクト: daqing15/pyzmq
    def test_zmq_msg_data(self):
        zmq_msg = ffi.new('zmq_msg_t*')
        message = ffi.new('char[]', 'Hello')
        assert 0 == C.zmq_msg_init_data(zmq_msg,
                                        ffi.cast('void*', message),
                                        5,
                                        ffi.NULL,
                                        ffi.NULL)

        data = C.zmq_msg_data(zmq_msg)

        assert ffi.NULL != zmq_msg
        assert ffi.string(ffi.cast("char*", data)) == 'Hello'
        assert 0 == C.zmq_msg_close(zmq_msg)
コード例 #9
0
    def test_zmq_getsockopt(self):
        ctx = C.zmq_ctx_new()
        socket = C.zmq_socket(ctx, PUSH)

        identity = ffi.new('char[]', b'zmq')
        ret = C.zmq_setsockopt(socket, IDENTITY, ffi.cast('void*', identity), 3)
        assert ret == 0

        option_len = ffi.new('size_t*', 3)
        option = ffi.new('char[3]')
        ret = C.zmq_getsockopt(socket, IDENTITY, ffi.cast('void*', option), option_len)

        assert ret == 0
        assert ffi.string(ffi.cast('char*', option))[0:1] == b"z"
        assert ffi.string(ffi.cast('char*', option))[1:2] == b"m"
        assert ffi.string(ffi.cast('char*', option))[2:3] == b"q"
        assert ctx != ffi.NULL
        assert ffi.NULL != socket
        assert 0 == C.zmq_close(socket)
        assert 0 == C.zmq_ctx_destroy(ctx)
コード例 #10
0
ファイル: test_cffi_backend.py プロジェクト: daqing15/pyzmq
    def test_zmq_setsockopt(self):
        ctx = C.zmq_ctx_new()
        socket = C.zmq_socket(ctx, PUSH)

        identity = ffi.new('char[3]', 'zmq')
        ret = C.zmq_setsockopt(socket, IDENTITY, ffi.cast('void*', identity), 3)

        assert ret == 0
        assert ctx != ffi.NULL
        assert ffi.NULL != socket
        assert 0 == C.zmq_close(socket)
        assert 0 == C.zmq_ctx_destroy(ctx)
コード例 #11
0
    def test_zmq_setsockopt(self):
        ctx = C.zmq_ctx_new()
        socket = C.zmq_socket(ctx, PUSH)

        identity = ffi.new('char[3]', b'zmq')
        ret = C.zmq_setsockopt(socket, IDENTITY, ffi.cast('void*', identity), 3)

        assert ret == 0
        assert ctx != ffi.NULL
        assert ffi.NULL != socket
        assert 0 == C.zmq_close(socket)
        assert 0 == C.zmq_ctx_destroy(ctx)
コード例 #12
0
ファイル: test_cffi_backend.py プロジェクト: daqing15/pyzmq
    def test_zmq_getsockopt(self):
        ctx = C.zmq_ctx_new()
        socket = C.zmq_socket(ctx, PUSH)

        identity = ffi.new('char[]', 'zmq')
        ret = C.zmq_setsockopt(socket, IDENTITY, ffi.cast('void*', identity), 3)
        assert ret == 0

        option_len = ffi.new('size_t*', 3)
        option = ffi.new('char*')
        ret = C.zmq_getsockopt(socket,
                            IDENTITY,
                            ffi.cast('void*', option),
                            option_len)

        assert ret == 0
        assert ffi.string(ffi.cast('char*', option))[0] == "z"
        assert ffi.string(ffi.cast('char*', option))[1] == "m"
        assert ffi.string(ffi.cast('char*', option))[2] == "q"
        assert ctx != ffi.NULL
        assert ffi.NULL != socket
        assert 0 == C.zmq_close(socket)
        assert 0 == C.zmq_ctx_destroy(ctx)
コード例 #13
0
    def test_zmq_poll(self):
        ctx = C.zmq_ctx_new()

        sender = C.zmq_socket(ctx, REQ)
        receiver = C.zmq_socket(ctx, REP)

        r1 = C.zmq_bind(receiver, 'tcp://*:3333')
        r2 = C.zmq_connect(sender, 'tcp://127.0.0.1:3333')

        zmq_msg = ffi.new('zmq_msg_t*')
        message = ffi.new('char[5]', 'Hello')

        C.zmq_msg_init_data(zmq_msg, ffi.cast('void*', message),
                            ffi.cast('size_t', 5), ffi.NULL, ffi.NULL)

        receiver_pollitem = ffi.new('zmq_pollitem_t*')
        receiver_pollitem.socket = receiver
        receiver_pollitem.fd = 0
        receiver_pollitem.events = POLLIN | POLLOUT
        receiver_pollitem.revents = 0

        ret = C.zmq_poll(ffi.NULL, 0, 0)
        assert ret == 0

        ret = C.zmq_poll(receiver_pollitem, 1, 0)
        assert ret == 0

        ret = C.zmq_msg_send(zmq_msg, sender, 0)
        print((ffi.string(C.zmq_strerror(C.zmq_errno()))))
        assert ret == 5

        time.sleep(0.2)

        ret = C.zmq_poll(receiver_pollitem, 1, 0)
        assert ret == 1

        assert int(receiver_pollitem.revents) & POLLIN
        assert not int(receiver_pollitem.revents) & POLLOUT

        zmq_msg2 = ffi.new('zmq_msg_t*')
        C.zmq_msg_init(zmq_msg2)

        ret_recv = C.zmq_msg_recv(zmq_msg2, receiver, 0)
        assert ret_recv == 5

        assert 5 == C.zmq_msg_size(zmq_msg2)
        assert b"Hello" == ffi.buffer(C.zmq_msg_data(zmq_msg2),
                                      C.zmq_msg_size(zmq_msg2))[:]

        sender_pollitem = ffi.new('zmq_pollitem_t*')
        sender_pollitem.socket = sender
        sender_pollitem.fd = 0
        sender_pollitem.events = POLLIN | POLLOUT
        sender_pollitem.revents = 0

        ret = C.zmq_poll(sender_pollitem, 1, 0)
        assert ret == 0

        zmq_msg_again = ffi.new('zmq_msg_t*')
        message_again = ffi.new('char[11]', 'Hello Again')

        C.zmq_msg_init_data(zmq_msg_again, ffi.cast('void*', message_again),
                            ffi.cast('size_t', 11), ffi.NULL, ffi.NULL)

        assert 11 == C.zmq_msg_send(zmq_msg_again, receiver, 0)

        time.sleep(0.2)

        assert 0 <= C.zmq_poll(sender_pollitem, 1, 0)
        assert int(sender_pollitem.revents) & POLLIN
        assert 11 == C.zmq_msg_recv(zmq_msg2, sender, 0)
        assert 11 == C.zmq_msg_size(zmq_msg2)
        assert b"Hello Again" == ffi.buffer(C.zmq_msg_data(zmq_msg2),
                                            int(C.zmq_msg_size(zmq_msg2)))[:]
        assert 0 == C.zmq_close(sender)
        assert 0 == C.zmq_close(receiver)
        assert 0 == C.zmq_ctx_destroy(ctx)
        assert 0 == C.zmq_msg_close(zmq_msg)
        assert 0 == C.zmq_msg_close(zmq_msg2)
        assert 0 == C.zmq_msg_close(zmq_msg_again)
コード例 #14
0
    def test_zmq_msg_init_size(self):
        zmq_msg = ffi.new('zmq_msg_t*')

        assert ffi.NULL != zmq_msg
        assert 0 == C.zmq_msg_init_size(zmq_msg, 10)
        assert 0 == C.zmq_msg_close(zmq_msg)
コード例 #15
0
ファイル: test_cffi_backend.py プロジェクト: daqing15/pyzmq
    def test_zmq_poll(self):
        ctx = C.zmq_ctx_new()

        sender = C.zmq_socket(ctx, REQ)
        receiver = C.zmq_socket(ctx, REP)

        r1 = C.zmq_bind(receiver, 'tcp://*:3333')
        r2 = C.zmq_connect(sender, 'tcp://127.0.0.1:3333')

        zmq_msg = ffi.new('zmq_msg_t*')
        message = ffi.new('char[5]', 'Hello')

        C.zmq_msg_init_data(zmq_msg,
                            ffi.cast('void*', message),
                            ffi.cast('size_t', 5),
                            ffi.NULL,
                            ffi.NULL)

        receiver_pollitem = ffi.new('zmq_pollitem_t*')
        receiver_pollitem.socket = receiver
        receiver_pollitem.fd = 0
        receiver_pollitem.events = POLLIN | POLLOUT
        receiver_pollitem.revents = 0

        ret = C.zmq_poll(ffi.NULL, 0, 0)
        assert ret == 0

        ret = C.zmq_poll(receiver_pollitem, 1, 0)
        assert ret == 0

        ret = C.zmq_msg_send(zmq_msg, sender, 0)
        print(ffi.string(C.zmq_strerror(C.zmq_errno())))
        assert ret == 5

        time.sleep(0.2)

        ret = C.zmq_poll(receiver_pollitem, 1, 0)
        assert ret == 1

        assert int(receiver_pollitem.revents) & POLLIN
        assert not int(receiver_pollitem.revents) & POLLOUT

        zmq_msg2 = ffi.new('zmq_msg_t*')
        C.zmq_msg_init(zmq_msg2)

        ret_recv = C.zmq_msg_recv(zmq_msg2, receiver, 0)
        assert ret_recv == 5

        assert 5 == C.zmq_msg_size(zmq_msg2)
        assert b"Hello" == ffi.buffer(C.zmq_msg_data(zmq_msg2),
                                    C.zmq_msg_size(zmq_msg2))[:]

        sender_pollitem = ffi.new('zmq_pollitem_t*')
        sender_pollitem.socket = sender
        sender_pollitem.fd = 0
        sender_pollitem.events = POLLIN | POLLOUT
        sender_pollitem.revents = 0

        ret = C.zmq_poll(sender_pollitem, 1, 0)
        assert ret == 0

        zmq_msg_again = ffi.new('zmq_msg_t*')
        message_again = ffi.new('char[11]', 'Hello Again')

        C.zmq_msg_init_data(zmq_msg_again,
                            ffi.cast('void*', message_again),
                            ffi.cast('size_t', 11),
                            ffi.NULL,
                            ffi.NULL)

        assert 11 == C.zmq_msg_send(zmq_msg_again, receiver, 0)

        time.sleep(0.2)

        assert 0 <= C.zmq_poll(sender_pollitem, 1, 0)
        assert int(sender_pollitem.revents) & POLLIN
        assert 11 == C.zmq_msg_recv(zmq_msg2, sender, 0)
        assert 11 == C.zmq_msg_size(zmq_msg2)
        assert b"Hello Again" == ffi.buffer(C.zmq_msg_data(zmq_msg2),
                                            int(C.zmq_msg_size(zmq_msg2)))[:]
        assert 0 == C.zmq_close(sender)
        assert 0 == C.zmq_close(receiver)
        assert 0 == C.zmq_ctx_destroy(ctx)
        assert 0 == C.zmq_msg_close(zmq_msg)
        assert 0 == C.zmq_msg_close(zmq_msg2)
        assert 0 == C.zmq_msg_close(zmq_msg_again)
コード例 #16
0
ファイル: test_cffi_backend.py プロジェクト: daqing15/pyzmq
    def test_zmq_msg_init_size(self):
        zmq_msg = ffi.new('zmq_msg_t*')

        assert ffi.NULL != zmq_msg
        assert 0 == C.zmq_msg_init_size(zmq_msg, 10)
        assert 0 == C.zmq_msg_close(zmq_msg)