rbczmq 0.1

data/test/test_message.rb

@@ -0,0 +1,201 @@
+# encoding: utf-8
+
+require File.join(File.dirname(__FILE__), 'helper')
+
+class TestZmqMessage < ZmqTestCase
+  def test_message
+    msg = ZMQ::Message.new
+    assert_instance_of ZMQ::Message, msg
+    assert_nil msg.destroy
+  end
+
+  def test_destroyed
+    msg = ZMQ::Message("one", "two")
+    msg.destroy
+    assert_raises ZMQ::Error do
+      msg.encode
+    end
+  end
+
+  def test_message_sugar
+    msg = ZMQ::Message("one", "two", "three")
+    assert_equal "one", msg.popstr
+    assert_equal "two", msg.popstr
+    assert_equal "three", msg.popstr
+  end
+
+  def test_size
+    msg = ZMQ::Message.new
+    assert_equal 0, msg.size
+    msg.pushstr "test"
+    assert_equal 1, msg.size
+  end
+
+  def test_content_size
+    msg = ZMQ::Message.new
+    assert_equal 0, msg.content_size
+    msg.pushstr "test"
+    assert_equal 4, msg.content_size
+  end
+
+  def test_push_pop
+    msg = ZMQ::Message.new
+    assert msg.push ZMQ::Frame("body")
+    assert_equal 1, msg.size
+    assert_equal 4, msg.content_size
+    assert msg.push ZMQ::Frame("header")
+    assert_equal 2, msg.size
+    assert_equal 10, msg.content_size
+
+    assert_equal ZMQ::Frame("header"), msg.pop
+    assert_equal 1, msg.size
+    assert_equal 4, msg.content_size
+
+    assert_equal ZMQ::Frame("body"), msg.pop
+    assert_equal 0, msg.size
+    assert_equal 0, msg.content_size
+  end
+
+  def test_add
+    msg = ZMQ::Message.new
+    msg.push ZMQ::Frame("header")
+    assert msg.add ZMQ::Frame("body")
+    assert_equal 2, msg.size
+    assert_equal ZMQ::Frame("header"), msg.pop
+    assert_equal ZMQ::Frame("body"), msg.pop
+  end
+
+  def test_print
+    msg = ZMQ::Message.new
+    msg.push ZMQ::Frame("header")
+    msg.add ZMQ::Frame("body")
+    assert_nil msg.print
+  end
+
+  def test_first
+    msg = ZMQ::Message.new
+    assert_nil msg.first
+    msg.push ZMQ::Frame("header")
+    msg.add ZMQ::Frame("body")
+    assert_equal ZMQ::Frame("header"), msg.first
+  end
+
+  def test_next
+    msg = ZMQ::Message.new
+    assert_nil msg.next
+    msg.push ZMQ::Frame("header")
+    msg.add ZMQ::Frame("body")
+    assert_equal ZMQ::Frame("header"), msg.next
+    assert_equal ZMQ::Frame("body"), msg.next
+  end
+
+  def test_last
+    msg = ZMQ::Message.new
+    assert_nil msg.last
+    msg.push ZMQ::Frame("header")
+    msg.add ZMQ::Frame("body")
+    assert_equal ZMQ::Frame("body"), msg.last
+  end
+
+  def test_to_a
+    assert_equal [], ZMQ::Message.new.to_a
+    msg = ZMQ::Message("header", "body")
+    assert_equal [ZMQ::Frame("header"), ZMQ::Frame("body")], msg.to_a
+  end
+
+  def test_remove
+    msg = ZMQ::Message.new
+    header = ZMQ::Frame("header")
+    body = ZMQ::Frame("body")
+    msg.push header
+    msg.add body
+    msg.remove(body)
+    assert_equal 1, msg.size
+    assert_equal header, msg.pop
+  end
+
+  def test_pushstr_popstr
+    msg = ZMQ::Message.new
+    assert msg.pushstr "body"
+    assert_equal 1, msg.size
+    assert_equal 4, msg.content_size
+    assert msg.pushstr "header"
+    assert_equal 2, msg.size
+    assert_equal 10, msg.content_size
+
+    assert_equal "header", msg.popstr
+    assert_equal 1, msg.size
+    assert_equal 4, msg.content_size
+
+    assert_equal "body", msg.popstr
+    assert_equal 0, msg.size
+    assert_equal 0, msg.content_size
+  end
+
+  def test_addstr
+    msg = ZMQ::Message.new
+    msg.pushstr "header"
+    assert msg.addstr "body"
+    assert_equal 2, msg.size
+    assert_equal "header", msg.popstr
+    assert_equal "body", msg.popstr
+  end
+
+  def test_wrap_unwrap
+    msg = ZMQ::Message.new
+    body = ZMQ::Frame("body")
+    assert_nil msg.wrap(body)
+    assert_equal 2, msg.size
+    assert_equal 4, msg.content_size
+    assert_equal body, msg.pop
+    assert_equal ZMQ::Frame(""), msg.pop
+
+    assert_equal 0, msg.size
+    assert_nil msg.wrap(body)
+    assert_equal 2, msg.size
+    assert_equal body, msg.unwrap
+    assert_equal 0, msg.size
+  end
+
+  def test_dup
+    msg =  ZMQ::Message.new
+    msg.pushstr "header"
+    dup_msg = msg.dup
+    assert_not_equal dup_msg.object_id, msg.object_id
+    assert_equal msg.size, dup_msg.size
+    assert_equal "header", msg.popstr
+  end
+
+  def test_encode_decode
+    msg =  ZMQ::Message.new
+    msg.pushstr "body"
+    msg.pushstr "header"
+
+    expected = "\006header\004body"
+    assert_equal expected, msg.encode
+
+    decoded = ZMQ::Message.decode(expected)
+    assert_equal "header", decoded.popstr
+    assert_equal "body", decoded.popstr
+
+    assert_nil ZMQ::Message.decode("tainted")
+  end
+
+  def test_equals
+    msg =  ZMQ::Message.new
+    msg.pushstr "body"
+    msg.pushstr "header"
+
+    dup = msg.dup
+    assert_equal msg, msg
+    assert msg.eql?(dup)
+
+    other =  ZMQ::Message.new
+    other.pushstr "header"
+    other.pushstr "body"
+
+    assert_not_equal msg, other
+    assert !msg.eql?(other)
+    assert other.eql?(other)
+  end
+end

data/test/test_poller.rb

@@ -0,0 +1,154 @@
+# encoding: utf-8
+
+require File.join(File.dirname(__FILE__), 'helper')
+
+class TestZmqPoller < ZmqTestCase
+
+  def test_alloc
+    assert_instance_of ZMQ::Poller, ZMQ::Poller.new
+  end
+
+  def test_verbose
+    poller = ZMQ::Poller.new
+    poller.verbose = true
+  end
+
+  def test_poll_sockets
+    ctx = ZMQ::Context.new
+    poller = ZMQ::Poller.new
+    poller.verbose = true
+    assert_equal 0, poller.poll
+    rep = ctx.socket(:REP)
+    rep.linger = 0
+    rep.bind("inproc://test.poll")
+    req = ctx.socket(:REQ)
+    req.linger = 0
+    req.connect("inproc://test.poll")
+
+    assert_raises TypeError do
+      poller.poll :invalid
+    end
+
+    assert_equal 0, poller.poll_nonblock
+
+    assert poller.register_readable(rep)
+    assert req.send("request")
+    sleep 0.1
+
+    assert_equal 1, poller.poll(1)
+    assert_equal [rep], poller.readables
+    assert_equal [], poller.writables
+    rep.recv
+
+    assert poller.register(req)
+    assert rep.send("reply")
+    sleep 0.1
+
+    assert_equal 1, poller.poll(1)
+    assert_equal [req], poller.readables
+    assert_equal [], poller.writables
+  ensure
+    ctx.destroy
+  end
+
+  def test_poll_ios
+    poller = ZMQ::Poller.new
+    r, w = IO.pipe
+
+    poller.register(ZMQ::Pollitem(r, ZMQ::POLLIN))
+    poller.register(ZMQ::Pollitem(w, ZMQ::POLLOUT))
+
+    w.write("message")
+    sleep 0.2
+
+    assert_equal 2, poller.poll(1)
+    assert_equal [r], poller.readables
+    assert_equal [w], poller.writables
+
+    assert_equal "message", r.read(7)
+  end
+
+  def test_poll_ruby_sockets
+    poller = ZMQ::Poller.new
+    server = TCPServer.new("127.0.0.1", 0)
+    f, port, host, addr = server.addr
+    client = TCPSocket.new("127.0.0.1", port)
+    s = server.accept
+
+    poller.register(ZMQ::Pollitem(s, ZMQ::POLLIN))
+    poller.register(ZMQ::Pollitem(client, ZMQ::POLLOUT))
+
+    client.send("message", 0)
+    sleep 0.2
+
+    assert_equal 2, poller.poll(1)
+    assert_equal [s], poller.readables
+    assert_equal [client], poller.writables
+
+    assert_equal "message", s.recv_nonblock(7)
+  end
+
+  def test_register
+    ctx = ZMQ::Context.new
+    rep = ctx.bind(:REP, 'inproc://test.poller-register')
+    req = ctx.connect(:REQ, 'inproc://test.poller-register')
+    poller = ZMQ::Poller.new
+    assert poller.register(rep)
+    assert_raises ZMQ::Error do
+      poller.register(ZMQ::Pollitem.new(req, 0))
+    end
+    unbound = ctx.socket(:REP)
+    assert_raises ZMQ::Error do
+      poller.register(unbound)
+    end
+  ensure
+    ctx.destroy
+  end
+
+  def test_register_readable
+    ctx = ZMQ::Context.new
+    rep = ctx.bind(:REP, 'inproc://test.poller-register_readable')
+    poller = ZMQ::Poller.new
+    assert poller.register_readable(rep)
+  ensure
+    ctx.destroy
+  end
+
+  def test_register_writable
+    ctx = ZMQ::Context.new
+    rep = ctx.bind(:REP, 'inproc://test.poller-register_writable')
+    poller = ZMQ::Poller.new
+    assert poller.register_writable(rep)
+  ensure
+    ctx.destroy
+  end
+
+  def test_remove
+    ctx = ZMQ::Context.new
+    rep = ctx.bind(:REP, 'inproc://test.poller-remove')
+    req = ctx.connect(:REQ, 'inproc://test.poller-remove')
+    poller = ZMQ::Poller.new
+    assert poller.register(req)
+    assert poller.remove(req)
+    assert !poller.remove(rep)
+
+    io_poll_item = ZMQ::Pollitem.new(STDIN, ZMQ::POLLIN)
+    poller.register(io_poll_item)
+    assert poller.remove(io_poll_item)
+
+    poller.register(io_poll_item)
+    assert poller.remove(STDIN)
+  ensure
+    ctx.destroy
+  end
+
+  def test_readables
+    poller = ZMQ::Poller.new
+    assert_equal [], poller.readables
+  end
+
+  def test_writables
+    poller = ZMQ::Poller.new
+    assert_equal [], poller.writables
+  end
+end

data/test/test_pollitem.rb

@@ -0,0 +1,78 @@
+# encoding: utf-8
+
+require File.join(File.dirname(__FILE__), 'helper')
+
+class TestZmqPollitem < ZmqTestCase
+  def test_alloc_io
+    pollitem = ZMQ::Pollitem.new(STDIN, ZMQ::POLLIN)
+    assert_equal STDIN, pollitem.pollable
+    assert_equal ZMQ::POLLIN, pollitem.events
+  end
+
+  def test_alloc_without_events
+    pollitem = ZMQ::Pollitem.new(STDIN)
+    assert pollitem.events & ZMQ::POLLIN
+    assert pollitem.events & ZMQ::POLLOUT
+  end
+
+  def test_alloc_socket
+    ctx = ZMQ::Context.new
+    rep = ctx.bind(:REP, 'inproc://test.pollitem-alloc_socket')
+    pollitem = ZMQ::Pollitem.new(rep, ZMQ::POLLIN)
+    assert_equal rep, pollitem.pollable
+    assert_equal ZMQ::POLLIN, pollitem.events
+  ensure
+    ctx.destroy
+  end
+
+  def test_alloc_ruby_socket
+    srv = TCPServer.new("127.0.0.1", 0)
+    pollitem = ZMQ::Pollitem.new(srv, ZMQ::POLLIN)
+    assert_equal srv, pollitem.pollable
+    assert_equal ZMQ::POLLIN, pollitem.events
+  ensure
+    srv.close if srv
+  end
+
+  def test_verbose
+    ctx = ZMQ::Context.new
+    rep = ctx.bind(:REP, 'inproc://test.pollitem-verbose')
+    pollitem = ZMQ::Pollitem.new(rep, ZMQ::POLLIN)
+    pollitem.verbose = true
+  ensure
+    ctx.destroy
+  end
+
+  def test_handler
+    pollitem = ZMQ::Pollitem.new(STDIN, ZMQ::POLLIN)
+    assert_nil pollitem.handler
+    handler = Module.new
+    pollitem.handler = handler
+    assert_equal handler, pollitem.handler
+  end
+
+  def test_coerce
+    pollitem = ZMQ::Pollitem.new(STDIN)
+    assert_equal pollitem, ZMQ::Pollitem.coerce(pollitem)
+    coerced = ZMQ::Pollitem.coerce(STDIN)
+    assert_instance_of ZMQ::Pollitem, coerced
+    assert_equal STDIN, coerced.pollable
+  end
+
+  def test_alloc_failures
+    ctx = ZMQ::Context.new
+    rep = ctx.socket(:REP)
+    assert_raises ZMQ::Error do
+      ZMQ::Pollitem.new(rep, ZMQ::POLLIN)
+    end
+    rep.bind('inproc://test.pollitem-alloc_failures')
+    assert_raises ZMQ::Error do
+      ZMQ::Pollitem.new(rep, 200)
+    end
+    assert_raises TypeError do
+      ZMQ::Pollitem.new(:invalid, ZMQ::POLLIN)
+    end
+  ensure
+    ctx.destroy
+  end
+end

data/test/test_socket.rb

@@ -0,0 +1,403 @@
+# encoding: utf-8
+
+require File.join(File.dirname(__FILE__), 'helper')
+
+class TestZmqSocket < ZmqTestCase
+  def test_fd
+    ctx = ZMQ::Context.new
+    sock = ctx.socket(:REP)
+    assert Fixnum === sock.fd
+    assert_equal(-1, sock.fd)
+    assert_equal sock.fd, sock.to_i
+  ensure
+    ctx.destroy
+  end
+
+  def test_type
+    ctx = ZMQ::Context.new
+    sock = ctx.socket(:REP)
+    assert_equal ZMQ::REP, sock.type
+  ensure
+    ctx.destroy
+  end
+
+  def test_readable_p
+    ctx = ZMQ::Context.new
+    rep = ctx.socket(:REP)
+    rep.bind("inproc://test.socket-readable_p")
+    req = ctx.connect(:REQ, "inproc://test.socket-readable_p")
+    assert req.writable?
+    req.send("m")
+    sleep 0.1
+    assert rep.readable?
+  ensure
+    ctx.destroy
+  end
+
+  def test_send_socket
+    ctx = ZMQ::Context.new
+    push = ctx.socket(:PUSH)
+    assert_raises ZMQ::Error do
+      push.recv
+    end
+  ensure
+    ctx.destroy
+  end
+
+  def test_receive_socket
+    ctx = ZMQ::Context.new
+    pull = ctx.socket(:PULL)
+    assert_raises ZMQ::Error do
+      pull.send("message")
+    end
+  ensure
+    ctx.destroy
+  end
+
+  def test_recv_timeout
+    ctx = ZMQ::Context.new
+    sock = ctx.socket(:REP)
+    assert_nil sock.recv_timeout
+    sock.recv_timeout = 10
+    assert_equal 10, sock.recv_timeout
+    assert_raises TypeError do
+      sock.recv_timeout = :x
+    end
+  ensure
+    ctx.destroy
+  end
+
+  def test_send_timeout
+    ctx = ZMQ::Context.new
+    sock = ctx.socket(:REP)
+    assert_nil sock.send_timeout
+    sock.send_timeout = 10
+    assert_equal 10, sock.send_timeout
+    assert_raises TypeError do
+      sock.send_timeout = :x
+    end
+  ensure
+    ctx.destroy
+  end
+
+  def test_gc_context_reaped
+    pub = ZMQ::Context.new.socket(:PUB)
+    GC.start
+    pub.bind("inproc://test.socket-gc_context_reaped")
+    GC.start
+    pub.send("test")
+    GC.start
+    pub.close
+  ensure
+    ZMQ.context.destroy
+  end
+
+  def test_bind
+    ctx = ZMQ::Context.new
+    sock = ctx.socket(:REP)
+    assert(sock.state & ZMQ::Socket::PENDING)
+    port = sock.bind("tcp://127.0.0.1:*")
+    assert sock.fd != -1
+    assert(sock.state & ZMQ::Socket::BOUND)
+    tcp_sock = nil
+    assert_nothing_raised do
+      tcp_sock = TCPSocket.new("127.0.0.1", port)
+    end
+  ensure
+    ctx.destroy
+    tcp_sock.close if tcp_sock
+  end
+
+  def test_connect
+    ctx = ZMQ::Context.new
+    rep = ctx.socket(:PAIR)
+    port = rep.bind("inproc://test.socket-connect")
+    req = ctx.socket(:PAIR)
+    assert(req.state & ZMQ::Socket::PENDING)
+    req.connect("inproc://test.socket-connect")
+    assert req.fd != -1
+    assert(req.state & ZMQ::Socket::CONNECTED)
+  ensure
+    ctx.destroy
+  end
+
+  def test_to_s
+    ctx = ZMQ::Context.new
+    sock = ctx.socket(:PAIR)
+    rep = ctx.socket(:REP)
+    port = rep.bind("tcp://127.0.0.1:*")
+    req = ctx.socket(:REQ)
+    assert(req.state & ZMQ::Socket::PENDING)
+    req.connect("tcp://127.0.0.1:#{port}")
+    assert_equal "PAIR socket", sock.to_s
+    assert_equal "REP socket bound to tcp://127.0.0.1:*", rep.to_s
+    assert_equal "REQ socket connected to tcp://127.0.0.1:#{port}", req.to_s
+  ensure
+    ctx.destroy
+  end
+
+  def test_endpoint
+    ctx = ZMQ::Context.new
+    rep = ctx.socket(:REP)
+    port = rep.bind("tcp://127.0.0.1:*")
+    req = ctx.socket(:REQ)
+    req.connect("tcp://127.0.0.1:#{port}")
+    assert_equal "tcp://127.0.0.1:*", rep.endpoint
+    assert_equal "tcp://127.0.0.1:#{port}", req.endpoint
+  ensure
+    ctx.destroy
+  end
+
+  def test_close
+    ctx = ZMQ::Context.new
+    sock = ctx.socket(:REP)
+    port = sock.bind("tcp://127.0.0.1:*")
+    assert sock.fd != -1
+    other = ctx.socket(:REQ)
+    other.connect("tcp://127.0.0.1:#{port}")
+    other.send("test")
+    assert_equal "test", sock.recv
+    sock.close
+    other.close
+    # zsocket_destroy in libczmq recycles the socket instance. libzmq don't support / expose underlying
+    # connection state or teardown through public API, thus we can't assert a PENDING socket state on close
+    # through the Ruby API as the socket instance has already been recycled.
+    begin
+      assert_equal ZMQ::Socket::PENDING, sock.state
+    rescue => e
+      assert_instance_of ZMQ::Error, e
+      assert_match(/ZMQ::Socket instance \w* has been destroyed by the ZMQ framework/, e.message)
+    end
+    sleep 0.2
+    assert_raises Errno::ECONNREFUSED do
+      TCPSocket.new("127.0.0.1", port)
+    end
+  ensure
+    ctx.destroy
+  end
+
+  def test_send_receive
+    ctx = ZMQ::Context.new
+    rep = ctx.socket(:PAIR)
+    rep.bind("inproc://test.socket-send_receive")
+    req = ctx.socket(:PAIR)
+    req.connect("inproc://test.socket-send_receive")
+    assert req.send("ping")
+    assert_equal "ping", rep.recv
+  ensure
+    ctx.destroy
+  end
+
+  def test_verbose
+    ctx = ZMQ::Context.new
+    rep = ctx.socket(:PAIR)
+    rep.verbose = true
+    rep.bind("inproc://test.socket-verbose")
+    req = ctx.socket(:PAIR)
+    req.verbose = true
+    req.connect("inproc://test.socket-verbose")
+    assert req.send("ping")
+    assert_equal "ping", rep.recv
+    req.send_frame(ZMQ::Frame("frame"))
+    assert_equal ZMQ::Frame("frame"), rep.recv_frame
+  ensure
+    ctx.destroy
+  end
+
+  def test_receive_nonblock
+    ctx = ZMQ::Context.new
+    rep = ctx.socket(:REP)
+    port = rep.bind("tcp://127.0.0.1:*")
+    req = ctx.socket(:REQ)
+    req.connect("tcp://127.0.0.1:#{port}")
+    assert req.send("ping")
+    assert_equal nil, rep.recv_nonblock
+    sleep 0.2
+    assert_equal "ping", rep.recv_nonblock
+  ensure
+    ctx.destroy
+  end
+
+  def test_send_multi
+    ctx = ZMQ::Context.new
+    rep = ctx.socket(:PAIR)
+    rep.bind("inproc://test.socket-send_multi")
+    req = ctx.socket(:PAIR)
+    req.connect("inproc://test.socket-send_multi")
+    assert req.sendm("batch")
+    req.sendm("of")
+    req.send("messages")
+    assert_equal "batch", rep.recv
+    assert_equal "of", rep.recv
+    assert_equal "messages", rep.recv
+  ensure
+    ctx.destroy
+  end
+
+  def test_send_receive_frame
+    ctx = ZMQ::Context.new
+    rep = ctx.socket(:REP)
+    port = rep.bind("tcp://127.0.0.1:*")
+    req = ctx.socket(:REQ)
+    req.connect("tcp://127.0.0.1:#{port}")
+    ping = ZMQ::Frame("ping")
+    assert req.send_frame(ping)
+    assert_equal ZMQ::Frame("ping"), rep.recv_frame
+    assert rep.send_frame(ZMQ::Frame("pong"))
+    assert_equal ZMQ::Frame("pong"), req.recv_frame
+    assert req.send_frame(ZMQ::Frame("pong"))
+    frame = rep.recv_frame_nonblock
+    if frame
+      assert_equal ZMQ::Frame("pong"), frame
+    else
+      sleep 0.3
+      assert_equal ZMQ::Frame("pong"), rep.recv_frame_nonblock
+    end
+  ensure
+    ctx.destroy
+  end
+
+  def test_send_frame_more
+    ctx = ZMQ::Context.new
+    rep = ctx.socket(:PAIR)
+    rep.bind("inproc://test.socket-send_frame_more")
+    req = ctx.socket(:PAIR)
+    req.connect("inproc://test.socket-send_frame_more")
+    5.times do |i|
+      frame = ZMQ::Frame("m#{i}")
+      req.send_frame(frame, ZMQ::Frame::MORE)
+    end
+    req.send_frame(ZMQ::Frame("m6"))
+    expected, frames = %w(m0 m1 m2 m3 m4), []
+    5.times do
+      frames << rep.recv_frame.data
+    end
+    assert_equal expected, frames
+  ensure
+    ctx.destroy
+  end
+
+  def test_send_frame_reuse
+    ctx = ZMQ::Context.new
+    rep = ctx.socket(:PAIR)
+    rep.bind("inproc://test.socket-send_frame_reuse")
+    req = ctx.socket(:PAIR)
+    req.connect("inproc://test.socket-send_frame_reuse")
+    frame = ZMQ::Frame("reused_frame")
+    5.times do |i|
+      req.send_frame(frame, :REUSE)
+    end
+    expected, frames = ( %w(reused_frame) * 5), []
+    5.times do
+      frames << rep.recv_frame.data
+    end
+    assert_equal expected, frames
+  ensure
+    ctx.destroy
+  end
+
+  def test_send_receive_message
+    ctx = ZMQ::Context.new
+    rep = ctx.socket(:PAIR)
+    rep.verbose = true
+    rep.bind("inproc://test.socket-send_receive_message")
+    req = ctx.socket(:PAIR)
+    req.verbose = true
+    req.connect("inproc://test.socket-send_receive_message")
+
+    msg = ZMQ::Message.new
+    msg.push ZMQ::Frame("header")
+
+    assert_nil req.send_message(msg)
+
+    recvd_msg = rep.recv_message
+    assert_instance_of ZMQ::Message, recvd_msg
+    assert_equal ZMQ::Frame("header"), recvd_msg.pop
+  ensure
+    ctx.destroy
+  end
+
+  def test_type_str
+    ctx = ZMQ::Context.new
+    sock = ctx.socket(:PAIR)
+    assert_equal "PAIR", sock.type_str
+  ensure
+    ctx.destroy
+  end
+
+  def test_sock_options
+    ctx = ZMQ::Context.new
+    sock = ctx.socket(:PAIR)
+    sock.verbose = true
+    assert_equal 0, sock.hwm
+    sock.hwm = 1000
+    assert_equal 1000, sock.hwm
+
+    assert_equal 0, sock.swap
+    sock.swap = 1000
+    assert_equal 1000, sock.swap
+
+    assert_equal 0, sock.affinity
+    sock.affinity = 1
+    assert_equal 1, sock.affinity
+
+    assert_equal 40000, sock.rate
+    sock.rate = 50000
+    assert_equal 50000, sock.rate
+
+    assert_equal 10, sock.recovery_ivl
+    sock.recovery_ivl = 20
+    assert_equal 20, sock.recovery_ivl
+
+    assert_equal(-1, sock.recovery_ivl_msec)
+    sock.recovery_ivl_msec = 20
+    assert_equal 20, sock.recovery_ivl_msec
+
+    assert_equal true, sock.mcast_loop?
+    sock.mcast_loop = false
+    assert !sock.mcast_loop?
+
+    assert_equal 0, sock.sndbuf
+    sock.sndbuf = 1000
+    assert_equal 1000, sock.sndbuf
+
+    assert_equal 0, sock.rcvbuf
+    sock.rcvbuf = 1000
+    assert_equal 1000, sock.rcvbuf
+
+    assert_equal(-1, sock.linger)
+    sock.linger = 10
+    assert_equal 10, sock.linger
+
+    assert_equal 100, sock.backlog
+    sock.backlog = 200
+    assert_equal 200, sock.backlog
+
+    assert_equal 100, sock.reconnect_ivl
+    sock.reconnect_ivl = 200
+    assert_equal 200, sock.reconnect_ivl
+
+    assert_equal 0, sock.reconnect_ivl_max
+    sock.reconnect_ivl_max = 5
+    assert_equal 5, sock.reconnect_ivl_max
+
+    sock.identity = "anonymous"
+    assert_raises ZMQ::Error do
+      sock.identity = ""
+    end
+    assert_raises ZMQ::Error do
+      sock.identity = ("*" * 256)
+    end
+
+    assert !sock.rcvmore?
+
+    assert_equal 0, sock.events
+
+    sub_sock = ctx.socket(:SUB)
+    sub_sock.verbose = true
+    sub_sock.subscribe("ruby")
+    sub_sock.unsubscribe("ruby")
+  ensure
+    ctx.destroy
+  end
+end