require 'test/unit'
require 'timeout'
require_relative '../lib/io/epoll'

class TestIOEpoll < Test::Unit::TestCase
  def test_initalize
    assert_instance_of(IO::Epoll, IO::Epoll.new);
    assert_instance_of(IO::Epoll, IO::Epoll.create);
  end

  def test_fileno
    assert { 0 < IO::Epoll.create.fileno }
  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) }
  end

  def test_add
    ep = IO::Epoll.create
    io = IO.new(1, 'w')
    assert_raise(IOError) { ep.add(io, 0) }
    assert { ep == ep.add(io, IO::Epoll::IN|IO::Epoll::PRI|IO::Epoll::RDHUP|IO::Epoll::ET|IO::Epoll::OUT) }
    ep.close
    assert_raise(Errno::EBADF) { ep.add(io, IO::Epoll::OUT) }
  end

  def test_mod
    ep = IO::Epoll.create
    io = IO.new(1, 'w')
    assert_raise(Errno::ENOENT) { ep.mod(io, IO::Epoll::IN) }
    ep == ep.add(io, IO::Epoll::OUT)
    assert { ep == ep.mod(io, IO::Epoll::IN) }
    ep.close
    assert_raise(Errno::EBADF) { ep.add(io, IO::Epoll::OUT) }
  end

  def test_del
    ep = IO::Epoll.create
    io = IO.new(1, 'w')
    assert_raise(Errno::ENOENT) { ep.del(io) }
    ep.add(io, IO::Epoll::OUT)
    assert { ep == ep.del(io) }
    ep.close
    assert_raise(Errno::EBADF) { ep.del(io) }
  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)
    assert { [IO::Epoll::Event.new(io, IO::Epoll::OUT)] == ep.wait }
    assert_raise(TypeError) { ep.wait(nil) }
    assert_raise(IOError) { IO::Epoll.create.wait }
  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) }
    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 }
  end

  def test_close_closed?
    ep = IO::Epoll.create
    assert { false == ep.closed? }
    assert { nil == ep.close }
    assert_raise(IOError){ ep.close }
    assert { true == ep.closed? }
  end

  def test_epoll
    r, w = IO.pipe
    fork {
      r.close
      w.write('ok')
    }
    w.close
    ret = []
    evs = IO.epoll([r], IO::Epoll::IN)
    assert { 'ok' == evs[0].data.read }
    assert { false == evs[0].data.closed? }
    assert_raise(IOError) { IO.epoll(nil, nil) }
    assert_raise(IOError) { IO.epoll([], nil) }
    assert_raise(TypeError) { IO.epoll([nil], nil) }
  end

  def test_epoll_with_block
    r, w = IO.pipe
    fork {
      r.close
      w.write('ok')
    }
    w.close
    ret = []
    IO.epoll([r], IO::Epoll::IN) do |ev|
      ret << ev
      assert { 'ok' == ev.data.read }
    end
    assert { true == ret[0].data.closed? }
  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 }
  end
end