test/lib_read_write.rb

   1 require 'test/unit'
   2 require 'io/nonblock'
   3 $-w = true
   4 require 'kgio'
   5
   6 module LibReadWriteTest
   7   def teardown
   8     assert_nothing_raised do
   9       @rd.close unless @rd.closed?
  10       @wr.close unless @wr.closed?
  11     end
  12     assert_nothing_raised do
  13       Kgio.wait_readable = Kgio.wait_writable = nil
  14     end
  15   end
  16
  17   def test_read_eof
  18     @wr.close
  19     assert_raises(EOFError) { @rd.kgio_read 5 }
  20   end
  21
  22   def test_write_closed
  23     @rd.close
  24     assert_raises(Errno::EPIPE) { loop { @wr.kgio_write "HI" } }
  25   end
  26
  27   def test_write_conv
  28     assert_equal nil, @wr.kgio_write(10)
  29     assert_equal "10", @rd.kgio_read(2)
  30   end
  31
  32   def test_read_empty
  33     assert_equal Kgio::WaitReadable, @rd.kgio_read(1)
  34   end
  35
  36   def test_read_too_much
  37     assert_equal nil, @wr.kgio_write("hi")
  38     assert_equal "hi", @rd.kgio_read(4)
  39   end
  40
  41   def test_read_short
  42     assert_equal nil, @wr.kgio_write("hi")
  43     assert_equal "h", @rd.kgio_read(1)
  44     assert_equal "i", @rd.kgio_read(1)
  45   end
  46
  47   def test_read_extra_buf
  48     tmp = ""
  49     tmp_object_id = tmp.object_id
  50     assert_equal nil, @wr.kgio_write("hi")
  51     rv = @rd.kgio_read(2, tmp)
  52     assert_equal "hi", rv
  53     assert_equal rv.object_id, tmp.object_id
  54     assert_equal tmp_object_id, rv.object_id
  55   end
  56
  57   def test_write_return_wait_writable
  58     tmp = []
  59     tmp << @wr.kgio_write("HI") until tmp[-1] == Kgio::WaitWritable
  60     assert_equal Kgio::WaitWritable, tmp.pop
  61     assert tmp.size > 0
  62     penultimate = tmp.pop
  63     assert(penultimate == "I" || penultimate == nil)
  64     assert tmp.size > 0
  65     tmp.each { |count| assert_equal nil, count }
  66   end
  67
  68   def test_monster_write
  69     buf = "." * 1024 * 1024 * 10
  70     rv = @wr.kgio_write(buf)
  71     assert_kind_of String, rv
  72     assert rv.size < buf.size
  73     assert_equal(buf, (rv + @rd.read(buf.size - rv.size)))
  74   end
  75
  76   def test_wait_readable_ruby_default
  77     def @rd.ruby
  78       raise RuntimeError, "Hello"
  79     end
  80     assert_nothing_raised { Kgio.wait_readable = :ruby }
  81     elapsed = 0
  82     foo = nil
  83     t0 = Time.now
  84     thr = Thread.new { sleep 1; @wr.write "HELLO" }
  85     assert_nothing_raised do
  86       foo = @rd.kgio_read(5)
  87       elapsed = Time.now - t0
  88     end
  89     assert elapsed >= 1.0, "elapsed: #{elapsed}"
  90     assert_equal "HELLO", foo
  91     thr.join
  92     assert_equal 5, thr.value
  93   end
  94
  95   def test_wait_writable_ruby_default
  96     def @wr.ruby
  97       raise RuntimeError, "Hello"
  98     end
  99     buf = "." * 512
 100     nr = 0
 101     begin
 102       nr += @wr.write_nonblock(buf)
 103     rescue Errno::EAGAIN
 104       break
 105     end while true
 106     assert_nothing_raised { Kgio.wait_writable = :ruby }
 107     elapsed = 0
 108     foo = nil
 109     t0 = Time.now
 110     thr = Thread.new { sleep 1; @rd.readpartial(nr) }
 111     assert_nothing_raised do
 112       foo = @wr.kgio_write("HELLO")
 113       elapsed = Time.now - t0
 114     end
 115     assert_nil foo
 116     if @wr.stat.pipe?
 117       assert elapsed >= 1.0, "elapsed: #{elapsed}"
 118     end
 119     assert(String === foo || foo == nil)
 120     assert_kind_of String, thr.value
 121   end
 122
 123   def test_wait_readable_method
 124     def @rd.moo
 125       defined?(@z) ? raise(RuntimeError, "Hello") : @z = "HI"
 126     end
 127     assert_nothing_raised { Kgio.wait_readable = :moo }
 128     foo = nil
 129     begin
 130       foo = @rd.kgio_read(5)
 131       assert false
 132     rescue RuntimeError => e
 133       assert_equal("Hello", e.message)
 134     end
 135     assert_equal "HI", @rd.instance_variable_get(:@z)
 136     assert_nil foo
 137   end
 138
 139   def test_wait_writable_method
 140     def @wr.moo
 141       defined?(@z) ? raise(RuntimeError, "Hello") : @z = "HI"
 142     end
 143     assert_nothing_raised { Kgio.wait_writable = :moo }
 144     n = []
 145     begin
 146       loop { n << @wr.kgio_write("HIHIHIHIHIHI") }
 147       assert false
 148     rescue RuntimeError => e
 149       assert_equal("Hello", e.message)
 150     end
 151     assert n.size > 0
 152     assert_equal "HI", @wr.instance_variable_get(:@z)
 153   end
 154 end