io-epoll 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 87c51dc70ed31c8d3a34012ce002a0c9c19c7982
-  data.tar.gz: 92e3c83055ba130342883cb1bb15f9d55bf6c6fd
+  metadata.gz: 97d310cf1317528f3b0d1315862f1365a9a3480b
+  data.tar.gz: 87e9317da46fa65ad67f9f3dd66a0589ca44adf6
 SHA512:
-  metadata.gz: bd0dd5bdd8e4085c8b6be91ba5ddd218d448981cd3365c498c4bd936196da3d9827d639ff1afeccc5c1ecad72f29de6a16933aab90f6c7bef1f5f678b931a857
-  data.tar.gz: 1eec9c05b0d6e9c6b22fe399992389b62dd92672e65255bcf34d0c1dc4acb8bb6ed46aad0f4a1c1df8424a4d5e567cbee5e226e2c8b2db8e4a4935053192061b
+  metadata.gz: c4c7b4cfbf7b113800d952650c8c49948e63ce0c4de8a80be3f2a90ebdfba0cb3b8a0672ed518e853550c13cf48907a31485731c70f494213ffb173c212d01c0
+  data.tar.gz: 4769b5237627dbff6621fae9bb9a8044d8560689f684b328ee50c51a90ab45a9a0a3dac1f234d0de73f66f80746141ccf55576085995121a2e35450b0718564d

data/.travis.yml

@@ -2,3 +2,5 @@ language: ruby
 rvm:
   - 2.1.4
   - 2.2.0
+os:
+  - linux

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    io-epoll (0.1.0)
+    io-epoll (0.2.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -32,8 +32,14 @@ epoll = Epoll.create
 epoll.ctl(Epoll::CTL_ADD, io, Epoll::IN)
 
 # and you can use short way
+
+# IO object add to interest list
 epoll.add(io, Epoll::IN)  # same way to epoll.ctl(Epoll::CTL_ADD, io, Epoll::IN)
-epoll.mod(io, Epoll::OUT) # same way to epoll.ctl(Epoll::CTL_MOD, io, Epoll::IN)
+
+# change waiting events
+epoll.mod(io, Epoll::OUT) # same way to epoll.ctl(Epoll::CTL_MOD, io, Epoll::OUT)
+
+# remove from interest list
 epoll.del(io)             # same way to epoll.ctl(Epoll::CTL_DEL, io)
 
 loop do
@@ -46,7 +52,7 @@ loop do
   evlist = epoll.wait
 
   # ev is instance of IO::Epoll::Event like `struct epoll_event`
-  # it's same as `class Event < Struct.new(:data, :events); end`
+  # it's instance of `class IO::Epoll::Event < Struct.new(:data, :events); end`
   evlist.each do |ev|
     # IO::Epoll::Event#events is event flag bits (Fixnum)
     if (ev.events & Epoll::IN) != 0
@@ -65,6 +71,12 @@ epoll.close #=> nil
 
 # and you can check closed
 epoll.closed? #=> true
+
+# and very useful way is that call `create` (or `new`) with block like Ruby IO.open
+# return: block result
+Epoll.create do |epoll|
+  # ensure automatic call `epoll.close` when out block
+end
 ```
 
 ## ctl options
@@ -84,7 +96,7 @@ event flags|ctl|wait|description
 **IO::Epoll::HUP**|o|o|peer socket was shutdown
 **IO::Epoll::OUT**|o|o|writable
 **IO::Epoll::ET**|o|x|use edge trigger
-**IO::Epoll:ONESHOT**|o|x|auto watching stop when notified(but stay in list)
+**IO::Epoll::ONESHOT**|o|x|auto watching stop when notified(but stay in list)
 **IO::Epoll::ERR**|x|o|raise error
 **IO::Epoll::HUP**|x|o|raise hang up
 
@@ -104,7 +116,13 @@ Or install it yourself as:
 
     $ gem install io-epoll
 
-# Fork me !
+# Pro Tips
+
+- Support call without GVL in CRuby (use rb\_thread\_call\_without\_gvl())
+- Close on exec flag set by default if you can use (use epoll_create1(EPOLL_CLOEXEC))
+- IO::Epoll#wait max return array size is 256 on one time (of course, overflowing and then carried next)
+
+# Fork Me !
 
 This is experimental implementation.
 I'm waiting for your idea and Pull Request !

data/examples/epoll_server.rb

@@ -4,6 +4,7 @@ require 'io/epoll'
 require 'socket'
 
 server = TCPServer.open(4000)
+puts "run http://127.0.0.1:4000/"
 
 response = [
   "HTTP/1.0 200 OK\r\n",
@@ -44,4 +45,3 @@ loop do
     end
   end
 end
-

data/ext/io/epoll/epoll.c

@@ -1,9 +1,16 @@
 #include "ruby.h"
 #include "ruby/io.h"
 #include "ruby/thread.h"
+
+#ifdef HAVE_SYS_EPOLL_H
+
 #include <sys/epoll.h>
+#include <fcntl.h>
+
+#define EPOLL_WAIT_MAX_EVENTS 256
 
 VALUE cIO_Epoll;
+VALUE cIO_Epoll_Constants;
 VALUE cIO_Epoll_Event;
 
 struct Epoll {
@@ -11,10 +18,15 @@ struct Epoll {
   int ev_len;
 };
 
-static void
+enum {
+  EPOLL_EVENT_DATA = 0,
+  EPOLL_EVENT_EVENTS = 1
+};
+
+inline static void
 epoll_fd_close(int epfd)
 {
-  rb_thread_fd_close(epfd);
+  close(epfd);
 }
 
 static void
@@ -79,6 +91,36 @@ rb_epoll_allocate(VALUE klass)
   return TypedData_Make_Struct(klass, struct Epoll, &epoll_data_type, ptr);
 }
 
+static VALUE
+rb_epoll_close(VALUE self)
+{
+  struct Epoll *ptr = get_epoll(self);
+  epoll_check_closed(ptr);
+  epoll_fd_close(ptr->epfd);
+  ptr->epfd = -1;
+  return Qnil;
+}
+
+static VALUE
+ensure_epoll_close(VALUE ep)
+{
+  VALUE closed = rb_check_funcall(ep, rb_intern("closed?"), 0, 0);
+  if (closed != Qundef && RTEST(closed)) return ep;
+  rb_epoll_close(ep);
+  return ep;
+}
+
+static VALUE
+rb_epoll_s_new(VALUE klass)
+{
+  VALUE ep = rb_class_new_instance(0, NULL, klass);
+
+  if (rb_block_given_p()) {
+    return rb_ensure(rb_yield, ep, ensure_epoll_close, ep);
+  }
+  return ep;
+}
+
 static VALUE
 rb_epoll_initialize(VALUE self)
 {
@@ -87,9 +129,15 @@ rb_epoll_initialize(VALUE self)
 
   TypedData_Get_Struct(self, struct Epoll, &epoll_data_type, ptr);
   if (ptr->epfd < 0) epoll_fd_close(ptr->epfd);
-  epfd = epoll_create(1);
+
+#if defined(HAVE_EPOLL_CREATE1) && defined(EPOLL_CLOEXEC)
+  epfd = epoll_create1(EPOLL_CLOEXEC);
+#else
+  epfd = epoll_create(1024);
+#endif
+
   if (epfd == -1) {
-    rb_sys_fail("epoll_create was failed");
+    rb_sys_fail("epoll_create() was failed");
   }
   ptr->epfd = epfd;
   ptr->ev_len = 0;
@@ -104,6 +152,42 @@ rb_epoll_initialize(VALUE self)
   return self;
 }
 
+static VALUE
+rb_epoll_initialize_copy(VALUE copy, VALUE orig)
+{
+  struct Epoll *orig_ptr = get_epoll(orig);
+  struct Epoll *copy_ptr;
+  int epfd;
+
+  if (!OBJ_INIT_COPY(copy, orig)) return copy;
+
+  TypedData_Get_Struct(copy, struct Epoll, &epoll_data_type, copy_ptr);
+  epfd = dup(orig_ptr->epfd);
+  if (epfd == -1)
+    rb_sys_fail("dup() was failed");
+  copy_ptr->epfd = epfd;
+  copy_ptr->ev_len = orig_ptr->ev_len;
+  rb_ivar_set(copy, rb_intern("evlist"), rb_ivar_get(orig, rb_intern("evlist")));
+  return copy;
+}
+
+static VALUE
+rb_epoll_inspect(VALUE self)
+{
+  struct Epoll *ptr = get_epoll(self);
+  VALUE result;
+
+  if (!ptr) return rb_any_to_s(self);
+  result = rb_str_new_cstr("#<");
+  rb_str_append(result, rb_class_name(CLASS_OF(self)));
+  rb_str_cat2(result, ":");
+  if (ptr->epfd < 0)
+    rb_str_cat(result, " (closed)", 9);
+  else
+    rb_str_catf(result, "fd %d", ptr->epfd);
+  return rb_str_cat2(result, ">");
+}
+
 static VALUE
 rb_epoll_fileno(VALUE self)
 {
@@ -115,9 +199,9 @@ rb_epoll_fileno(VALUE self)
 inline static void
 rb_epoll_evlist_add(VALUE self, VALUE io)
 {
-   VALUE evlist = rb_ivar_get(self, rb_intern("evlist"));
-   rb_ary_push(evlist, io);
-   rb_ivar_set(self, rb_intern("evlist"), evlist);
+  VALUE evlist = rb_ivar_get(self, rb_intern("evlist"));
+  rb_ary_push(evlist, io);
+  rb_ivar_set(self, rb_intern("evlist"), evlist);
 }
 
 inline static void
@@ -192,6 +276,7 @@ rb_epoll_ctl(int argc, VALUE *argv, VALUE self)
 struct epoll_wait_args {
   struct Epoll *ptr;
   struct epoll_event *evlist;
+  int ev_len;
   int timeout;
 };
 
@@ -199,30 +284,37 @@ static void *
 rb_epoll_wait_func(void *ptr)
 {
   const struct epoll_wait_args *data = ptr;
-  return (void*)(long)epoll_wait(data->ptr->epfd, data->evlist, data->ptr->ev_len, data->timeout);
+  return (void*)(long)epoll_wait(data->ptr->epfd, data->evlist, data->ev_len, data->timeout);
 }
 
 static VALUE
 rb_epoll_wait(int argc, VALUE *argv, VALUE self)
 {
   struct Epoll *ptr = get_epoll(self);
+  struct epoll_event evlist[EPOLL_WAIT_MAX_EVENTS];
+  struct epoll_wait_args data;
+  int i, ready, timeout;
   VALUE ready_evlist;
   VALUE event;
-  struct epoll_event *evlist;
-  int i, ready;
-  int timeout = -1;
-  struct epoll_wait_args data;
 
-  if (argc == 1)
+  switch (argc) {
+  case 0:
+    timeout = -1;
+    break;
+  case 1:
     timeout = FIX2INT(argv[0]);
+    break;
+  default:
+    rb_raise(rb_eArgError, "too many argument");
+    break;
+  }
 
   if (ptr->ev_len <= 0)
     rb_raise(rb_eIOError, "empty interest list");
 
-  evlist = ruby_xmalloc(ptr->ev_len * sizeof(struct epoll_event));
-
   data.ptr = ptr;
   data.evlist = evlist;
+  data.ev_len = EPOLL_WAIT_MAX_EVENTS < ptr->ev_len ? EPOLL_WAIT_MAX_EVENTS : ptr->ev_len;
   data.timeout = timeout;
 
 RETRY:
@@ -232,7 +324,6 @@ RETRY:
       goto RETRY;
     }
     else {
-      ruby_xfree(evlist);
       rb_sys_fail("epoll_wait() was failed");
     }
   }
@@ -240,62 +331,110 @@ RETRY:
   ready_evlist = rb_ary_new_capa(ready);
   for (i = 0; i < ready; i++) {
     event = rb_obj_alloc(cIO_Epoll_Event);
-    RSTRUCT_SET(event, 0, (VALUE) evlist[i].data.ptr);
-    RSTRUCT_SET(event, 1, LONG2FIX(evlist[i].events));
+    RSTRUCT_SET(event, EPOLL_EVENT_DATA, (VALUE) evlist[i].data.ptr);
+    RSTRUCT_SET(event, EPOLL_EVENT_EVENTS, LONG2FIX(evlist[i].events));
     rb_ary_store(ready_evlist, i, event);
   }
-  ruby_xfree(evlist);
   return ready_evlist;
 }
 
 static VALUE
-rb_epoll_close(VALUE self)
+rb_epoll_closed_p(VALUE self)
 {
   struct Epoll *ptr = get_epoll(self);
-  epoll_check_closed(ptr);
-  epoll_fd_close(ptr->epfd);
-  ptr->epfd = -1;
-  return Qnil;
+  return 0 <= ptr->epfd ? Qfalse : Qtrue;
 }
 
 static VALUE
-rb_epoll_closed_p(VALUE self)
+rb_epoll_size(VALUE self)
 {
   struct Epoll *ptr = get_epoll(self);
-  return 0 <= ptr->epfd ? Qfalse : Qtrue;
+  return INT2FIX(ptr->ev_len);
 }
 
+#if defined(HAVE_FCNTL) && defined(F_GETFD) && defined(FD_CLOEXEC)
+
 static VALUE
-rb_epoll_length(VALUE self)
+rb_epoll_close_on_exec_p(VALUE self)
 {
   struct Epoll *ptr = get_epoll(self);
-  return INT2FIX(ptr->ev_len);
+  int ret;
+
+  epoll_check_closed(ptr);
+
+  if ((ret = fcntl(ptr->epfd, F_GETFD)) == -1)
+    rb_sys_fail("fcntl");
+
+  if (ret & FD_CLOEXEC)
+    return Qtrue;
+  else
+    return Qfalse;
+}
+
+#else
+#define rb_epoll_close_on_exec_p rb_f_notimplement
+#endif
+
+#if defined(HAVE_FCNTL) && defined(F_GETFD) && defined(F_SETFD) && defined(FD_CLOEXEC)
+
+static VALUE
+rb_epoll_set_close_on_exec(VALUE self, VALUE b)
+{
+  struct Epoll *ptr = get_epoll(self);
+  int flag = RTEST(b) ? FD_CLOEXEC : 0;
+  int ret;
+
+  epoll_check_closed(ptr);
+
+  if ((ret = fcntl(ptr->epfd, F_GETFD)) == -1)
+    rb_sys_fail("fcntl");
+
+  if ((ret & FD_CLOEXEC) != flag) {
+    ret = (ret & ~FD_CLOEXEC) | flag;
+    if (fcntl(ptr->epfd, F_SETFD, ret) == -1)
+      rb_sys_fail("fcntl");
+  }
+  return Qnil;
 }
 
+#else
+#define rb_epoll_set_close_on_exec rb_f_notimplement
+#endif
+
+#endif // HAVE_SYS_EPOLL_H
+
 void
 Init_epoll()
 {
+#ifdef HAVE_SYS_EPOLL_H
   cIO_Epoll = rb_define_class_under(rb_cIO, "Epoll", rb_cObject);
-  cIO_Epoll_Event = rb_struct_define_under(cIO_Epoll, "Event", "data", "events", NULL);
   rb_define_alloc_func(cIO_Epoll, rb_epoll_allocate);
-
+  rb_define_singleton_method(cIO_Epoll, "new", rb_epoll_s_new, 0);
   rb_define_method(cIO_Epoll, "initialize", rb_epoll_initialize, 0);
+  rb_define_method(cIO_Epoll, "initialize_copy", rb_epoll_initialize_copy, 1);
+  rb_define_method(cIO_Epoll, "inspect", rb_epoll_inspect, 0);
   rb_define_method(cIO_Epoll, "ctl", rb_epoll_ctl, -1);
   rb_define_method(cIO_Epoll, "wait", rb_epoll_wait, -1);
   rb_define_method(cIO_Epoll, "fileno", rb_epoll_fileno, 0);
   rb_define_method(cIO_Epoll, "close", rb_epoll_close, 0);
   rb_define_method(cIO_Epoll, "closed?", rb_epoll_closed_p, 0);
-  rb_define_method(cIO_Epoll, "length", rb_epoll_length, 0);
-  rb_define_alias(cIO_Epoll, "size", "length");
-  rb_define_const(cIO_Epoll, "IN", INT2FIX(EPOLLIN));
-  rb_define_const(cIO_Epoll, "PRI", INT2FIX(EPOLLPRI));
-  rb_define_const(cIO_Epoll, "RDHUP", INT2FIX(EPOLLRDHUP));
-  rb_define_const(cIO_Epoll, "OUT", INT2FIX(EPOLLOUT));
-  rb_define_const(cIO_Epoll, "ET", INT2FIX(EPOLLET));
-  rb_define_const(cIO_Epoll, "ONESHOT", INT2FIX(EPOLLONESHOT));
-  rb_define_const(cIO_Epoll, "ERR", INT2FIX(EPOLLERR));
-  rb_define_const(cIO_Epoll, "HUP", INT2FIX(EPOLLHUP));
-  rb_define_const(cIO_Epoll, "CTL_ADD", INT2FIX(EPOLL_CTL_ADD));
-  rb_define_const(cIO_Epoll, "CTL_MOD", INT2FIX(EPOLL_CTL_MOD));
-  rb_define_const(cIO_Epoll, "CTL_DEL", INT2FIX(EPOLL_CTL_DEL));
+  rb_define_method(cIO_Epoll, "size", rb_epoll_size, 0);
+  rb_define_method(cIO_Epoll, "close_on_exec?", rb_epoll_close_on_exec_p, 0);
+  rb_define_method(cIO_Epoll, "close_on_exec=", rb_epoll_set_close_on_exec, 1);
+
+  cIO_Epoll_Constants = rb_define_module_under(cIO_Epoll, "Constants");
+  rb_define_const(cIO_Epoll_Constants, "IN", INT2FIX(EPOLLIN));
+  rb_define_const(cIO_Epoll_Constants, "PRI", INT2FIX(EPOLLPRI));
+  rb_define_const(cIO_Epoll_Constants, "RDHUP", INT2FIX(EPOLLRDHUP));
+  rb_define_const(cIO_Epoll_Constants, "OUT", INT2FIX(EPOLLOUT));
+  rb_define_const(cIO_Epoll_Constants, "ET", INT2FIX(EPOLLET));
+  rb_define_const(cIO_Epoll_Constants, "ONESHOT", INT2FIX(EPOLLONESHOT));
+  rb_define_const(cIO_Epoll_Constants, "ERR", INT2FIX(EPOLLERR));
+  rb_define_const(cIO_Epoll_Constants, "HUP", INT2FIX(EPOLLHUP));
+  rb_define_const(cIO_Epoll_Constants, "CTL_ADD", INT2FIX(EPOLL_CTL_ADD));
+  rb_define_const(cIO_Epoll_Constants, "CTL_MOD", INT2FIX(EPOLL_CTL_MOD));
+  rb_define_const(cIO_Epoll_Constants, "CTL_DEL", INT2FIX(EPOLL_CTL_DEL));
+
+  cIO_Epoll_Event = rb_struct_define_under(cIO_Epoll, "Event", "data", "events", NULL);
+#endif
 }

data/ext/io/epoll/extconf.rb

@@ -1,7 +1,8 @@
 require 'mkmf'
 
 if !have_header("sys/epoll.h")
-  puts "*** err: <sys/epoll.h> header must be installed ***"
-  exit 1
+  puts "*** complie error: gem 'io-epoll' must be installed <sys/epoll.h>. ***"
+  puts "*** you can require 'io/epoll'. But, you can not use IO::Epoll APIs. ***"
 end
+have_func("epoll_create1", "sys/epoll.h")
 create_makefile('io/epoll/epoll')

data/io-epoll.gemspec

@@ -1,10 +1,10 @@
 Gem::Specification.new do |spec|
   spec.name          = "io-epoll"
-  spec.version       = "0.1.0"
+  spec.version       = "0.2.0"
   spec.authors       = ["ksss"]
   spec.email         = ["co000ri@gmail.com"]
-  spec.summary       = %q{An experimental binding of epoll(7)}
-  spec.description   = %q{An experimental binding of epoll(7)}
+  spec.summary       = %q{A Ruby binding for epoll(7)}
+  spec.description   = %q{A Ruby binding for epoll(7)}
   spec.homepage      = "https://github.com/ksss/io-epoll"
   spec.license       = "MIT"
 

data/lib/io/epoll.rb

@@ -2,20 +2,24 @@ require 'io/epoll/epoll'
 
 class IO
   class Epoll
+    include Epoll::Constants
+
     class << self
       alias create new
     end
 
+    alias length size
+
     def add(io, events)
-      ctl(CTL_ADD, io, events)
+      ctl CTL_ADD, io, events
     end
 
     def mod(io, events)
-      ctl(CTL_MOD, io, events)
+      ctl CTL_MOD, io, events
     end
 
     def del(io)
-      ctl(CTL_DEL, io)
+      ctl CTL_DEL, io
     end
   end
 end

data/test/test_epoll.rb

@@ -8,6 +8,44 @@ class TestIOEpoll < Test::Unit::TestCase
     assert_instance_of(IO::Epoll, IO::Epoll.create);
   end
 
+  def test_create_with_block
+    instance = nil
+    ret_val = IO::Epoll.create do |ep|
+      instance = ep
+      assert { instance.closed? == false }
+      :block_end
+    end
+    assert { instance.kind_of?(IO::Epoll) == true }
+    assert { instance.closed? == true }
+    assert { ret_val == :block_end }
+  end
+
+  def test_create_with_block_ensure_close
+    instance = nil
+    catch do |ok|
+      IO::Epoll.create do |ep|
+        instance = ep
+        throw ok
+      end
+    end
+    assert { instance.closed? == true }
+
+    assert_nothing_raised do
+      IO::Epoll.create do |ep|
+        ep.close
+      end
+    end
+  end
+
+  def test_inspect
+    IO::Epoll.create do |ep|
+      fd = ep.fileno
+      assert { "#<IO::Epoll:fd #{fd}>" == ep.inspect }
+      ep.close
+      assert { "#<IO::Epoll: (closed)>" == ep.inspect }
+    end
+  end
+
   def test_fileno
     ep = IO::Epoll.create
     assert { 0 < ep.fileno }
@@ -16,14 +54,15 @@ class TestIOEpoll < Test::Unit::TestCase
   end
 
   def test_ctl
-    ep = IO::Epoll.create
-    io = IO.new(1, 'w')
-    assert { ep == ep.ctl(IO::Epoll::CTL_ADD, io , IO::Epoll::OUT) }
-    assert_raise(ArgumentError) { ep.ctl }
-    assert_raise(ArgumentError) { ep.ctl(IO::Epoll::CTL_ADD) }
-    assert_raise(ArgumentError) { ep.ctl(IO::Epoll::CTL_ADD, io) }
-    assert_raise(ArgumentError) { ep.ctl(-1, io) }
-    assert_raise(TypeError) { ep.ctl(nil, nil, nil) }
+    IO::Epoll.create do |ep|
+      io = IO.new(1, 'w')
+      assert { ep == ep.ctl(IO::Epoll::CTL_ADD, io , IO::Epoll::OUT) }
+      assert_raise(ArgumentError) { ep.ctl }
+      assert_raise(ArgumentError) { ep.ctl(IO::Epoll::CTL_ADD) }
+      assert_raise(ArgumentError) { ep.ctl(IO::Epoll::CTL_ADD, io) }
+      assert_raise(ArgumentError) { ep.ctl(-1, io) }
+      assert_raise(TypeError) { ep.ctl(nil, nil, nil) }
+    end
   end
 
   def test_add
@@ -56,38 +95,56 @@ class TestIOEpoll < Test::Unit::TestCase
   end
 
   def test_wait
-    ep = IO::Epoll.create
-    io = IO.new(1, 'w')
-    ep.add(io, IO::Epoll::IN|IO::Epoll::PRI|IO::Epoll::RDHUP|IO::Epoll::ET|IO::Epoll::OUT)
-    evlist = ep.wait
-    assert { [IO::Epoll::Event.new(io, IO::Epoll::OUT)] == evlist }
-    assert_instance_of(IO, evlist[0].data)
-    assert_instance_of(Fixnum, evlist[0].events)
-    assert_raise(TypeError) { ep.wait(nil) }
-    assert_raise(IOError) { IO::Epoll.create.wait }
+    IO::Epoll.create do |ep|
+      io = IO.new(1, 'w')
+      ep.add(io, IO::Epoll::IN|IO::Epoll::PRI|IO::Epoll::RDHUP|IO::Epoll::ET|IO::Epoll::OUT)
+      evlist = ep.wait
+      assert { [IO::Epoll::Event.new(io, IO::Epoll::OUT)] == evlist }
+      assert_instance_of(IO, evlist[0].data)
+      assert_instance_of(Fixnum, evlist[0].events)
+      assert_raise(TypeError) { ep.wait(nil) }
+      assert_raise(IOError) { IO::Epoll.create.wait }
+    end
   end
 
   def test_wait_with_timeout
-    ep = IO::Epoll.create
-    io = IO.new(1, 'w')
-    ep.add(io, IO::Epoll::IN)
-    assert { [] == ep.wait(0) }
-    assert { [] == ep.wait(1) }
-    assert_raise(TimeoutError) do
-      timeout(0.01) { ep.wait(-1) }
+    IO::Epoll.create do |ep|
+      io = IO.new(1, 'w')
+      ep.add(io, IO::Epoll::IN)
+      assert { [] == ep.wait(0) }
+      assert { [] == ep.wait(1) }
+      assert_raise(TimeoutError) do
+        timeout(0.01) { ep.wait(-1) }
+      end
     end
   end
 
   def test_size
-    ep = IO::Epoll.create
-    io = IO.new(0, 'r')
-    ep.add(io, IO::Epoll::IN)
-    assert { 1 == ep.size }
-    ep.del(io)
-    assert { 0 == ep.size }
+    IO::Epoll.create do |ep|
+      io = IO.new(0, 'r')
+      ep.add(io, IO::Epoll::IN)
+      assert { 1 == ep.size }
+      ep.del(io)
+      assert { 0 == ep.size }
+    end
   end
 
-  def test_close_closed?
+  def test_close
+    assert_nothing_raised do
+      fileno = nil
+      10.times do
+        ep = IO::Epoll.create
+        fileno = ep.fileno unless fileno
+        assert { fileno == ep.fileno }
+        ep.close
+
+        IO::Epoll.create do
+        end
+      end
+    end
+  end
+
+  def test_closed?
     ep = IO::Epoll.create
     assert { false == ep.closed? }
     assert { nil == ep.close }
@@ -95,14 +152,43 @@ class TestIOEpoll < Test::Unit::TestCase
     assert { true == ep.closed? }
   end
 
+  def test_dup
+    IO::Epoll.create do |ep|
+      io = IO.new(1, 'w')
+      ep.add(io, IO::Epoll::OUT)
+      dup = ep.dup
+      assert { ep != dup }
+      assert { ep.fileno != dup.fileno }
+      assert { ep.size == dup.size }
+      assert { [IO::Epoll::Event.new(io, IO::Epoll::OUT)] == dup.wait }
+    end
+  end
+
+  def test_close_on_exec
+    return unless defined? Fcntl::FD_CLOEXEC
+    IO::Epoll.create do |ep|
+      assert { true == ep.close_on_exec? }
+      ep.close_on_exec = false
+      assert { false == ep.close_on_exec? }
+      ep.close_on_exec = true
+      assert { true == ep.close_on_exec? }
+      ep.close_on_exec = false
+      assert { false == ep.close_on_exec? }
+      ep.close
+      assert_raise { ep.close_on_exec = true }
+      assert_raise { ep.close_on_exec? }
+    end
+  end
+
   def test_thread
-    ep = IO::Epoll.create
-    io = IO.new(1, 'w')
-    ep.add(io, IO::Epoll::OUT)
-    ret = nil
-    Thread.start {
-      ret = ep.wait
-    }.join
-    assert { io == ret[0].data }
+    IO::Epoll.create do |ep|
+      io = IO.new(1, 'w')
+      ep.add(io, IO::Epoll::OUT)
+      ret = nil
+      Thread.start {
+        ret = ep.wait
+      }.join
+      assert { io == ret[0].data }
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: io-epoll
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - ksss
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-02 00:00:00.000000000 Z
+date: 2014-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,7 +66,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: An experimental binding of epoll(7)
+description: A Ruby binding for epoll(7)
 email:
 - co000ri@gmail.com
 executables: []
@@ -110,6 +110,6 @@ rubyforge_project:
 rubygems_version: 2.4.1
 signing_key: 
 specification_version: 4
-summary: An experimental binding of epoll(7)
+summary: A Ruby binding for epoll(7)
 test_files:
 - test/test_epoll.rb