third-party/mruby/mrbgems/mruby-io/test/io.rb

   1 ##
   2 # IO Test
   3
   4 assert('IO TEST SETUP') do
   5   MRubyIOTestUtil.io_test_setup
   6   $cr = MRubyIOTestUtil.win? ? 1 : 0  # "\n" include CR or not
   7 end
   8
   9 assert('IO', '15.2.20') do
  10   assert_equal(Class, IO.class)
  11 end
  12
  13 assert('IO', '15.2.20.2') do
  14   assert_equal(Object, IO.superclass)
  15 end
  16
  17 assert('IO', '15.2.20.3') do
  18   assert_include(IO.ancestors, Enumerable)
  19 end
  20
  21 assert('IO.open', '15.2.20.4.1') do
  22   fd = IO.sysopen $mrbtest_io_rfname
  23   assert_equal Fixnum, fd.class
  24   io = IO.open fd
  25   assert_equal IO, io.class
  26   assert_equal $mrbtest_io_msg, io.read
  27   io.close
  28
  29   fd = IO.sysopen $mrbtest_io_rfname
  30   IO.open(fd) do |io|
  31     assert_equal $mrbtest_io_msg, io.read
  32   end
  33 end
  34
  35 assert('IO#close', '15.2.20.5.1') do
  36   io = IO.new(IO.sysopen($mrbtest_io_rfname))
  37   assert_nil io.close
  38 end
  39
  40 assert('IO#closed?', '15.2.20.5.2') do
  41   io = IO.new(IO.sysopen($mrbtest_io_rfname))
  42   assert_false io.closed?
  43   io.close
  44   assert_true io.closed?
  45 end
  46
  47 #assert('IO#each', '15.2.20.5.3') do
  48 #assert('IO#each_byte', '15.2.20.5.4') do
  49 #assert('IO#each_line', '15.2.20.5.5') do
  50
  51 assert('IO#eof?', '15.2.20.5.6') do
  52   io = IO.new(IO.sysopen($mrbtest_io_wfname, 'w'), 'w')
  53   assert_raise(IOError) do
  54     io.eof?
  55   end
  56   io.close
  57
  58   # empty file
  59   io = IO.open(IO.sysopen($mrbtest_io_wfname, 'w'), 'w')
  60   io.close
  61   io = IO.open(IO.sysopen($mrbtest_io_wfname, 'r'), 'r')
  62   assert_true io.eof?
  63   io.close
  64
  65   # nonempty file
  66   io = IO.new(IO.sysopen($mrbtest_io_rfname))
  67   assert_false io.eof?
  68   io.readchar
  69   assert_false io.eof?
  70   io.read
  71   assert_true io.eof?
  72   io.close
  73 end
  74
  75 assert('IO#flush', '15.2.20.5.7') do
  76   # Note: mruby-io does not have any buffer to be flushed now.
  77   io = IO.new(IO.sysopen($mrbtest_io_wfname))
  78   assert_equal io, io.flush
  79   io.close
  80   assert_raise(IOError) do
  81     io.flush
  82   end
  83 end
  84
  85 assert('IO#getc', '15.2.20.5.8') do
  86   io = IO.new(IO.sysopen($mrbtest_io_rfname))
  87   $mrbtest_io_msg.each_char { |ch|
  88     assert_equal ch, io.getc
  89   }
  90   assert_equal nil, io.getc
  91   io.close
  92 end
  93
  94 #assert('IO#gets', '15.2.20.5.9') do
  95 #assert('IO#initialize_copy', '15.2.20.5.10') do
  96 #assert('IO#print', '15.2.20.5.11') do
  97 #assert('IO#putc', '15.2.20.5.12') do
  98 #assert('IO#puts', '15.2.20.5.13') do
  99
 100 assert('IO#read', '15.2.20.5.14') do
 101   IO.open(IO.sysopen($mrbtest_io_rfname)) do |io|
 102     assert_raise(ArgumentError) { io.read(-5) }
 103     assert_raise(TypeError) { io.read("str") }
 104
 105     len = $mrbtest_io_msg.length
 106     assert_equal '', io.read(0)
 107     assert_equal 'mruby', io.read(5)
 108     assert_equal $mrbtest_io_msg[5,len], io.read(len)
 109
 110     assert_equal "", io.read
 111     assert_nil io.read(1)
 112   end
 113
 114   IO.open(IO.sysopen($mrbtest_io_rfname)) do |io|
 115     assert_equal $mrbtest_io_msg, io.read
 116   end
 117 end
 118
 119 assert "IO#read(n) with n > IO::BUF_SIZE" do
 120   skip "pipe is not supported on this platform" if MRubyIOTestUtil.win?
 121   r,w = IO.pipe
 122   n = IO::BUF_SIZE+1
 123   w.write 'a'*n
 124   assert_equal r.read(n), 'a'*n
 125 end
 126
 127 assert('IO#readchar', '15.2.20.5.15') do
 128   # almost same as IO#getc
 129   IO.open(IO.sysopen($mrbtest_io_rfname)) do |io|
 130     $mrbtest_io_msg.each_char { |ch|
 131       assert_equal ch, io.readchar
 132     }
 133     assert_raise(EOFError) do
 134       io.readchar
 135     end
 136   end
 137 end
 138
 139 #assert('IO#readline', '15.2.20.5.16') do
 140 #assert('IO#readlines', '15.2.20.5.17') do
 141
 142 assert('IO#sync', '15.2.20.5.18') do
 143   io = IO.new(IO.sysopen($mrbtest_io_rfname))
 144   s = io.sync
 145   assert_true(s == true || s == false)
 146   io.close
 147   assert_raise(IOError) do
 148     io.sync
 149   end
 150 end
 151
 152 assert('IO#sync=', '15.2.20.5.19') do
 153   io = IO.new(IO.sysopen($mrbtest_io_rfname))
 154   io.sync = true
 155   assert_true io.sync
 156   io.sync = false
 157   assert_false io.sync
 158   io.close
 159   assert_raise(IOError) do
 160     io.sync = true
 161   end
 162 end
 163
 164 assert('IO#write', '15.2.20.5.20') do
 165   io = IO.open(IO.sysopen($mrbtest_io_wfname))
 166   assert_equal 0, io.write("")
 167   io.close
 168
 169   io = IO.open(IO.sysopen($mrbtest_io_wfname, "r+"), "r+")
 170   assert_equal 7, io.write("abcdefg")
 171   io.rewind
 172   assert_equal "ab", io.read(2)
 173   assert_equal 3, io.write("123")
 174   io.rewind
 175   assert_equal "ab123fg", io.read
 176   io.close
 177 end
 178
 179 assert('IO#<<') do
 180   io = IO.open(IO.sysopen($mrbtest_io_wfname))
 181   io << "" << ""
 182   assert_equal 0, io.pos
 183   io.close
 184 end
 185
 186 assert('IO#dup for readable') do
 187   io = IO.new(IO.sysopen($mrbtest_io_rfname))
 188   dup = io.dup
 189   assert_true io != dup
 190   assert_true io.fileno != dup.fileno
 191   begin
 192     assert_true dup.close_on_exec?
 193   rescue NotImplementedError
 194   end
 195   assert_equal 'm', dup.sysread(1)
 196   assert_equal 'r', io.sysread(1)
 197   assert_equal 'u', dup.sysread(1)
 198   assert_equal 'b', io.sysread(1)
 199   assert_equal 'y', dup.sysread(1)
 200   dup.close
 201   assert_false io.closed?
 202   io.close
 203 end
 204
 205 assert('IO#dup for writable') do
 206   io = IO.open(IO.sysopen($mrbtest_io_wfname, 'w+'), 'w+')
 207   dup = io.dup
 208   io.syswrite "mruby"
 209   assert_equal 5, dup.sysseek(0, IO::SEEK_CUR)
 210   io.sysseek 0, IO::SEEK_SET
 211   assert_equal 0, dup.sysseek(0, IO::SEEK_CUR)
 212   assert_equal "mruby", dup.sysread(5)
 213   dup.close
 214   io.close
 215 end
 216
 217 assert('IO.for_fd') do
 218   fd = IO.sysopen($mrbtest_io_rfname)
 219   io = IO.for_fd(fd)
 220     assert_equal $mrbtest_io_msg, io.read
 221   io.close
 222 end
 223
 224 assert('IO.new') do
 225   io = IO.new(0)
 226   io.close
 227 end
 228
 229 assert('IO gc check') do
 230   100.times { IO.new(0) }
 231 end
 232
 233 assert('IO.sysopen("./nonexistent")') do
 234   if Object.const_defined? :Errno
 235     eclass = Errno::ENOENT
 236   else
 237     eclass = RuntimeError
 238   end
 239   assert_raise eclass do
 240     fd = IO.sysopen "./nonexistent"
 241     IO._sysclose fd
 242   end
 243 end
 244
 245 assert('IO.sysopen, IO#sysread') do
 246   fd = IO.sysopen $mrbtest_io_rfname
 247   io = IO.new fd
 248   str1 = "     "
 249   str2 = io.sysread(5, str1)
 250   assert_equal $mrbtest_io_msg[0,5], str1
 251   assert_equal $mrbtest_io_msg[0,5], str2
 252   assert_raise EOFError do
 253     io.sysread(10000)
 254     io.sysread(10000)
 255   end
 256
 257   assert_raise RuntimeError do
 258     io.sysread(5, "abcde".freeze)
 259   end
 260
 261   io.close
 262   assert_equal "", io.sysread(0)
 263   assert_raise(IOError) { io.sysread(1) }
 264   assert_raise(ArgumentError) { io.sysread(-1) }
 265   io.closed?
 266
 267   fd = IO.sysopen $mrbtest_io_wfname, "w"
 268   io = IO.new fd, "w"
 269   assert_raise(IOError) { io.sysread(1) }
 270   io.close
 271 end
 272
 273 assert('IO.sysopen, IO#syswrite') do
 274   fd = IO.sysopen $mrbtest_io_wfname, "w"
 275   io = IO.new fd, "w"
 276   str = "abcdefg"
 277   len = io.syswrite(str)
 278   assert_equal str.size, len
 279   io.close
 280
 281   io = IO.new(IO.sysopen($mrbtest_io_rfname), "r")
 282   assert_raise(IOError) { io.syswrite("a") }
 283   io.close
 284 end
 285
 286 assert('IO#_read_buf') do
 287   fd = IO.sysopen $mrbtest_io_rfname
 288   io = IO.new fd
 289   def io._buf
 290     @buf
 291   end
 292   msg_len = $mrbtest_io_msg.size
 293   assert_equal '', io._buf
 294   assert_equal $mrbtest_io_msg, io._read_buf
 295   assert_equal $mrbtest_io_msg, io._buf
 296   assert_equal 'mruby', io.read(5)
 297   assert_equal 5, io.pos
 298   assert_equal msg_len - 5, io._buf.size
 299   assert_equal $mrbtest_io_msg[5,100], io.read
 300   assert_equal 0, io._buf.size
 301   assert_raise EOFError do
 302     io._read_buf
 303   end
 304   assert_equal true, io.eof
 305   assert_equal true, io.eof?
 306   io.close
 307 end
 308
 309 assert('IO#isatty') do
 310   skip "isatty is not supported on this platform" if MRubyIOTestUtil.win?
 311   begin
 312     f = File.open("/dev/tty")
 313   rescue RuntimeError => e
 314     skip e.message
 315   else
 316     assert_true f.isatty
 317   ensure
 318     f&.close
 319   end
 320   begin
 321     f = File.open($mrbtest_io_rfname)
 322     assert_false f.isatty
 323   ensure
 324     f&.close
 325   end
 326 end
 327
 328 assert('IO#pos=, IO#seek') do
 329   fd = IO.sysopen $mrbtest_io_rfname
 330   io = IO.new fd
 331   def io._buf
 332     @buf
 333   end
 334   assert_equal 'm', io.getc
 335   assert_equal 1, io.pos
 336   assert_equal 0, io.seek(0)
 337   assert_equal 0, io.pos
 338   io.close
 339 end
 340
 341 assert('IO#rewind') do
 342   fd = IO.sysopen $mrbtest_io_rfname
 343   io = IO.new fd
 344   assert_equal 'm', io.getc
 345   assert_equal 1, io.pos
 346   assert_equal 0, io.rewind
 347   assert_equal 0, io.pos
 348   io.close
 349 end
 350
 351 assert('IO#gets') do
 352   fd = IO.sysopen $mrbtest_io_rfname
 353   io = IO.new fd
 354
 355   # gets without arguments
 356   assert_equal $mrbtest_io_msg, io.gets, "gets without arguments"
 357   assert_equal nil, io.gets, "gets returns nil, when EOF"
 358
 359   # gets with limit
 360   io.pos = 0
 361   assert_equal $mrbtest_io_msg[0, 5], io.gets(5), "gets with limit"
 362
 363   # gets with rs
 364   io.pos = 0
 365   assert_equal $mrbtest_io_msg[0, 6], io.gets(' '), "gets with rs"
 366
 367   # gets with rs, limit
 368   io.pos = 0
 369   assert_equal $mrbtest_io_msg[0, 5], io.gets(' ', 5), "gets with rs, limit"
 370   io.close
 371   assert_equal true, io.closed?, "close success"
 372
 373   # reading many-lines file.
 374   fd = IO.sysopen $mrbtest_io_wfname, "w"
 375   io = IO.new fd, "w"
 376   io.write "0123456789" * 2 + "\na"
 377   assert_equal 22 + $cr, io.pos
 378   io.close
 379   assert_equal true, io.closed?
 380
 381   fd = IO.sysopen $mrbtest_io_wfname
 382   io = IO.new fd
 383   line = io.gets
 384
 385   # gets first line
 386   assert_equal "0123456789" * 2 + "\n", line, "gets first line"
 387   assert_equal 21, line.size
 388   assert_equal 21 + $cr, io.pos
 389
 390   # gets second line
 391   assert_equal "a", io.gets, "gets second line"
 392
 393   # gets third line
 394   assert_equal nil, io.gets, "gets third line; returns nil"
 395
 396   io.close
 397 end
 398
 399 assert('IO#gets - paragraph mode') do
 400   fd = IO.sysopen $mrbtest_io_wfname, "w"
 401   io = IO.new fd, "w"
 402   io.write "0" * 10 + "\n"
 403   io.write "1" * 10 + "\n\n"
 404   io.write "2" * 10 + "\n"
 405   assert_equal 34 + $cr * 4, io.pos
 406   io.close
 407
 408   fd = IO.sysopen $mrbtest_io_wfname
 409   io = IO.new fd
 410   para1 = "#{'0' * 10}\n#{'1' * 10}\n\n"
 411   text1 = io.gets("")
 412   assert_equal para1, text1
 413   para2 = "#{'2' * 10}\n"
 414   text2 = io.gets("")
 415   assert_equal para2, text2
 416   io.close
 417 end
 418
 419 assert('IO.popen') do
 420   begin
 421     $? = nil
 422     io = IO.popen("echo mruby-io")
 423     assert_true io.close_on_exec?
 424     assert_equal Fixnum, io.pid.class
 425
 426     out = io.read
 427     assert_equal out.class, String
 428     assert_include out, 'mruby-io'
 429
 430     io.close
 431     if Object.const_defined? :Process
 432       assert_true $?.success?
 433     else
 434       assert_equal 0, $?
 435     end
 436
 437     assert_true io.closed?
 438   rescue NotImplementedError => e
 439     skip e.message
 440   end
 441 end
 442
 443 assert('IO.popen with in option') do
 444   begin
 445     IO.pipe do |r, w|
 446       w.write 'hello'
 447       w.close
 448       assert_equal "hello", IO.popen("cat", "r", in: r) { |i| i.read }
 449       assert_equal "", r.read
 450     end
 451     assert_raise(ArgumentError) { IO.popen("hello", "r", in: Object.new) }
 452   rescue NotImplementedError => e
 453     skip e.message
 454   end
 455 end
 456
 457 assert('IO.popen with out option') do
 458   begin
 459     IO.pipe do |r, w|
 460       IO.popen("echo 'hello'", "w", out: w) {}
 461       w.close
 462       assert_equal "hello\n", r.read
 463     end
 464   rescue NotImplementedError => e
 465     skip e.message
 466   end
 467 end
 468
 469 assert('IO.popen with err option') do
 470   begin
 471     IO.pipe do |r, w|
 472       assert_equal "", IO.popen("echo 'hello' 1>&2", "r", err: w) { |i| i.read }
 473       w.close
 474       assert_equal "hello\n", r.read
 475     end
 476   rescue NotImplementedError => e
 477     skip e.message
 478   end
 479 end
 480
 481 assert('IO.read') do
 482   # empty file
 483   fd = IO.sysopen $mrbtest_io_wfname, "w"
 484   io = IO.new fd, "w"
 485   io.close
 486   assert_equal "",  IO.read($mrbtest_io_wfname)
 487   assert_equal nil, IO.read($mrbtest_io_wfname, 1)
 488
 489   # one byte file
 490   fd = IO.sysopen $mrbtest_io_wfname, "w"
 491   io = IO.new fd, "w"
 492   io.write "123"
 493   io.close
 494   assert_equal "123", IO.read($mrbtest_io_wfname)
 495   assert_equal "",    IO.read($mrbtest_io_wfname, 0)
 496   assert_equal "1",   IO.read($mrbtest_io_wfname, 1)
 497   assert_equal "",    IO.read($mrbtest_io_wfname, 0, 10)
 498   assert_equal "23",  IO.read($mrbtest_io_wfname, 2, 1)
 499   assert_equal "23",  IO.read($mrbtest_io_wfname, 10, 1)
 500   assert_equal "",    IO.read($mrbtest_io_wfname, nil, 10)
 501   assert_equal nil,   IO.read($mrbtest_io_wfname, 1, 10)
 502 end
 503
 504 assert('IO#fileno') do
 505   fd = IO.sysopen $mrbtest_io_rfname
 506   io = IO.new fd
 507   assert_equal io.fileno, fd
 508   assert_equal io.to_i, fd
 509   io.close
 510 end
 511
 512 assert('IO#close_on_exec') do
 513   fd = IO.sysopen $mrbtest_io_wfname, "w"
 514   io = IO.new fd, "w"
 515   begin
 516     # IO.sysopen opens a file descripter with O_CLOEXEC flag.
 517     assert_true io.close_on_exec?
 518   rescue ScriptError
 519     io.close
 520     skip "IO\#close_on_exec is not implemented."
 521   end
 522
 523   io.close_on_exec = false
 524   assert_equal(false, io.close_on_exec?)
 525   io.close_on_exec = true
 526   assert_equal(true, io.close_on_exec?)
 527   io.close_on_exec = false
 528   assert_equal(false, io.close_on_exec?)
 529
 530   io.close
 531
 532   begin
 533     r, w = IO.pipe
 534     assert_equal(true, r.close_on_exec?)
 535     r.close_on_exec = false
 536     assert_equal(false, r.close_on_exec?)
 537     r.close_on_exec = true
 538     assert_equal(true, r.close_on_exec?)
 539
 540     assert_equal(true, w.close_on_exec?)
 541     w.close_on_exec = false
 542     assert_equal(false, w.close_on_exec?)
 543     w.close_on_exec = true
 544     assert_equal(true, w.close_on_exec?)
 545   ensure
 546     r.close unless r.closed?
 547     w.close unless w.closed?
 548   end
 549 end
 550
 551 assert('IO#sysseek') do
 552   IO.open(IO.sysopen($mrbtest_io_rfname)) do |io|
 553     assert_equal 2, io.sysseek(2)
 554     assert_equal 5, io.sysseek(3, IO::SEEK_CUR) # 2 + 3 => 5
 555     assert_equal $mrbtest_io_msg.size - 4, io.sysseek(-4, IO::SEEK_END)
 556   end
 557 end
 558
 559 assert('IO.pipe') do
 560   begin
 561     called = false
 562     IO.pipe do |r, w|
 563       assert_true r.kind_of?(IO)
 564       assert_true w.kind_of?(IO)
 565       assert_false r.closed?
 566       assert_false w.closed?
 567       assert_true FileTest.pipe?(r)
 568       assert_true FileTest.pipe?(w)
 569       assert_nil r.pid
 570       assert_nil w.pid
 571       assert_true 2 < r.fileno
 572       assert_true 2 < w.fileno
 573       assert_true r.fileno != w.fileno
 574       assert_false r.sync
 575       assert_true w.sync
 576       assert_equal 8, w.write('test for')
 577       assert_equal 'test', r.read(4)
 578       assert_equal ' for', r.read(4)
 579       assert_equal 5, w.write(' pipe')
 580       assert_equal nil, w.close
 581       assert_equal ' pipe', r.read
 582       called = true
 583       assert_raise(IOError) { r.write 'test' }
 584       # TODO:
 585       # This assert expect raise IOError but got RuntimeError
 586       # Because mruby-io not have flag for I/O readable
 587       # assert_raise(IOError) { w.read }
 588     end
 589     assert_true called
 590
 591     assert_nothing_raised do
 592       IO.pipe { |r, w| r.close; w.close }
 593     end
 594   rescue NotImplementedError => e
 595     skip e.message
 596   end
 597 end
 598
 599 assert('`cmd`') do
 600   begin
 601     assert_equal `echo foo`, "foo\n"
 602   rescue NotImplementedError => e
 603     skip e.message
 604   end
 605 end
 606
 607 assert('IO TEST CLEANUP') do
 608   assert_nil MRubyIOTestUtil.io_test_cleanup
 609 end