From be1c7e50e1e8809ea56f2c9d472eccd8ffd73a97 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 04:57:58 +0200 Subject: Adding upstream version 1.44.3. Signed-off-by: Daniel Baumann --- web/server/h2o/libh2o/deps/mruby-io/test/file.rb | 108 ++++++ .../h2o/libh2o/deps/mruby-io/test/file_test.rb | 95 +++++ .../h2o/libh2o/deps/mruby-io/test/gc_filedes.sh | 4 + web/server/h2o/libh2o/deps/mruby-io/test/io.rb | 416 +++++++++++++++++++++ .../h2o/libh2o/deps/mruby-io/test/mruby_io_test.c | 141 +++++++ 5 files changed, 764 insertions(+) create mode 100644 web/server/h2o/libh2o/deps/mruby-io/test/file.rb create mode 100644 web/server/h2o/libh2o/deps/mruby-io/test/file_test.rb create mode 100644 web/server/h2o/libh2o/deps/mruby-io/test/gc_filedes.sh create mode 100644 web/server/h2o/libh2o/deps/mruby-io/test/io.rb create mode 100644 web/server/h2o/libh2o/deps/mruby-io/test/mruby_io_test.c (limited to 'web/server/h2o/libh2o/deps/mruby-io/test') diff --git a/web/server/h2o/libh2o/deps/mruby-io/test/file.rb b/web/server/h2o/libh2o/deps/mruby-io/test/file.rb new file mode 100644 index 00000000..d6f39ceb --- /dev/null +++ b/web/server/h2o/libh2o/deps/mruby-io/test/file.rb @@ -0,0 +1,108 @@ +## +# IO Test + +assert('File', '15.2.21') do + File.class == Class +end + +assert('File', '15.2.21.2') do + File.superclass == IO +end + +assert('File TEST SETUP') do + MRubyIOTestUtil.io_test_setup +end + +assert('File#initialize', '15.2.21.4.1') do + io = File.open($mrbtest_io_rfname, "r") + assert_nil io.close + assert_raise IOError do + io.close + end +end + +assert('File#path', '15.2.21.4.2') do + io = File.open($mrbtest_io_rfname, "r") + assert_equal $mrbtest_io_msg, io.read + assert_equal $mrbtest_io_rfname, io.path + io.close + assert_equal $mrbtest_io_rfname, io.path + io.closed? +end + +assert('File.basename') do + assert_equal '/', File.basename('//') + assert_equal 'a', File.basename('/a/') + assert_equal 'b', File.basename('/a/b') + assert_equal 'b', File.basename('../a/b') +end + +assert('File.dirname') do + assert_equal '.', File.dirname('') + assert_equal '.', File.dirname('a') + assert_equal '/', File.dirname('/a') + assert_equal 'a', File.dirname('a/b') + assert_equal '/a', File.dirname('/a/b') +end + +assert('File.extname') do + assert_equal '.txt', File.extname('foo/foo.txt') + assert_equal '.gz', File.extname('foo/foo.tar.gz') + assert_equal '', File.extname('foo/bar') + assert_equal '', File.extname('foo/.bar') + assert_equal '', File.extname('foo.txt/bar') + assert_equal '', File.extname('.foo') +end + +assert('IO#flock') do + f = File.open $mrbtest_io_rfname + assert_equal(f.flock(File::LOCK_SH), 0) + assert_equal(f.flock(File::LOCK_UN), 0) + assert_equal(f.flock(File::LOCK_EX | File::LOCK_NB), 0) + assert_equal(f.flock(File::LOCK_UN), 0) + f.close + true +end + +assert('File.join') do + File.join() == "" and + File.join("a") == "a" and + File.join("/a") == "/a" and + File.join("a/") == "a/" and + File.join("a", "b", "c") == "a/b/c" and + File.join("/a", "b", "c") == "/a/b/c" and + File.join("a", "b", "c/") == "a/b/c/" and + File.join("a/", "/b/", "/c") == "a/b/c" +end + +assert('File.realpath') do + usrbin = IO.popen("cd bin; /bin/pwd -P") { |f| f.read.chomp } + assert_equal usrbin, File.realpath("bin") +end + +assert('File TEST CLEANUP') do + assert_nil MRubyIOTestUtil.io_test_cleanup +end + +assert('File.expand_path') do + assert_equal "/", File.expand_path("..", "/tmp"), "parent path with base_dir (1)" + assert_equal "/tmp", File.expand_path("..", "/tmp/mruby"), "parent path with base_dir (2)" + + assert_equal "/home", File.expand_path("/home"), "absolute" + assert_equal "/home", File.expand_path("/home", "."), "absolute with base_dir" + + assert_equal "/hoge", File.expand_path("/tmp/..//hoge") + assert_equal "/hoge", File.expand_path("////tmp/..///////hoge") + + assert_equal "/", File.expand_path("../../../..", "/") + assert_equal "/", File.expand_path(([".."] * 100).join("/")) +end + +assert('File.expand_path (with ENV)') do + skip unless Object.const_defined?(:ENV) && ENV['HOME'] + + assert_equal ENV['HOME'], File.expand_path("~/"), "home" + assert_equal ENV['HOME'], File.expand_path("~/", "/"), "home with base_dir" + + assert_equal "#{ENV['HOME']}/user", File.expand_path("user", ENV['HOME']), "relative with base_dir" +end diff --git a/web/server/h2o/libh2o/deps/mruby-io/test/file_test.rb b/web/server/h2o/libh2o/deps/mruby-io/test/file_test.rb new file mode 100644 index 00000000..11742f2d --- /dev/null +++ b/web/server/h2o/libh2o/deps/mruby-io/test/file_test.rb @@ -0,0 +1,95 @@ +## +# FileTest + +assert('FileTest TEST SETUP') do + MRubyIOTestUtil.io_test_setup +end + +assert("FileTest.directory?") do + assert_equal true, FileTest.directory?("/tmp") + assert_equal false, FileTest.directory?("/bin/sh") +end + +assert("FileTest.exist?") do + assert_equal true, FileTest.exist?($mrbtest_io_rfname), "filename - exist" + assert_equal false, FileTest.exist?($mrbtest_io_rfname + "-"), "filename - not exist" + io = IO.new(IO.sysopen($mrbtest_io_rfname)) + assert_equal true, FileTest.exist?(io), "io obj - exist" + io.close + assert_equal true, io.closed? + assert_raise IOError do + FileTest.exist?(io) + end +end + +assert("FileTest.file?") do + assert_equal false, FileTest.file?("/tmp") + assert_equal true, FileTest.file?("/bin/sh") +end + +assert("FileTest.pipe?") do + io = IO.popen("ls") + assert_equal true, FileTest.pipe?(io) + assert_equal false, FileTest.pipe?("/tmp") +end + +assert('FileTest.size') do + assert_equal FileTest.size($mrbtest_io_rfname), $mrbtest_io_msg.size + assert_equal FileTest.size($mrbtest_io_wfname), 0 +end + +assert("FileTest.size?") do + assert_equal $mrbtest_io_msg.size, FileTest.size?($mrbtest_io_rfname) + assert_equal nil, FileTest.size?($mrbtest_io_wfname) + assert_equal nil, FileTest.size?("not-exist-test-target-file") + + fp1 = File.open($mrbtest_io_rfname) + fp2 = File.open($mrbtest_io_wfname) + assert_equal $mrbtest_io_msg.size, FileTest.size?(fp1) + assert_equal nil, FileTest.size?(fp2) + fp1.close + fp2.close + + assert_raise IOError do + FileTest.size?(fp1) + end + assert_raise IOError do + FileTest.size?(fp2) + end + + fp1.closed? && fp2.closed? +end + +assert("FileTest.socket?") do + assert_true FileTest.socket?($mrbtest_io_socketname) +end + +assert("FileTest.symlink?") do + assert_true FileTest.symlink?($mrbtest_io_symlinkname) +end + +assert("FileTest.zero?") do + assert_equal false, FileTest.zero?($mrbtest_io_rfname) + assert_equal true, FileTest.zero?($mrbtest_io_wfname) + assert_equal false, FileTest.zero?("not-exist-test-target-file") + + fp1 = File.open($mrbtest_io_rfname) + fp2 = File.open($mrbtest_io_wfname) + assert_equal false, FileTest.zero?(fp1) + assert_equal true, FileTest.zero?(fp2) + fp1.close + fp2.close + + assert_raise IOError do + FileTest.zero?(fp1) + end + assert_raise IOError do + FileTest.zero?(fp2) + end + + fp1.closed? && fp2.closed? +end + +assert('FileTest TEST CLEANUP') do + assert_nil MRubyIOTestUtil.io_test_cleanup +end diff --git a/web/server/h2o/libh2o/deps/mruby-io/test/gc_filedes.sh b/web/server/h2o/libh2o/deps/mruby-io/test/gc_filedes.sh new file mode 100644 index 00000000..6e5d1bbf --- /dev/null +++ b/web/server/h2o/libh2o/deps/mruby-io/test/gc_filedes.sh @@ -0,0 +1,4 @@ +#!/bin/sh + +ulimit -n 20 +mruby -e '100.times { File.open "'$0'" }' diff --git a/web/server/h2o/libh2o/deps/mruby-io/test/io.rb b/web/server/h2o/libh2o/deps/mruby-io/test/io.rb new file mode 100644 index 00000000..b828fef4 --- /dev/null +++ b/web/server/h2o/libh2o/deps/mruby-io/test/io.rb @@ -0,0 +1,416 @@ +## +# IO Test + +assert('IO TEST SETUP') do + MRubyIOTestUtil.io_test_setup +end + +assert('IO', '15.2.20') do + assert_equal(Class, IO.class) +end + +assert('IO', '15.2.20.2') do + assert_equal(Object, IO.superclass) +end + +assert('IO', '15.2.20.3') do + assert_include(IO.included_modules, Enumerable) +end + +assert('IO.open', '15.2.20.4.1') do + fd = IO.sysopen $mrbtest_io_rfname + assert_equal Fixnum, fd.class + io = IO.open fd + assert_equal IO, io.class + assert_equal $mrbtest_io_msg, io.read + io.close + + fd = IO.sysopen $mrbtest_io_rfname + IO.open(fd) do |io| + assert_equal $mrbtest_io_msg, io.read + end + + true +end + +assert('IO#close', '15.2.20.5.1') do + io = IO.new(IO.sysopen($mrbtest_io_rfname)) + assert_nil io.close +end + +assert('IO#closed?', '15.2.20.5.2') do + io = IO.new(IO.sysopen($mrbtest_io_rfname)) + assert_false io.closed? + io.close + assert_true io.closed? +end + +#assert('IO#each', '15.2.20.5.3') do +#assert('IO#each_byte', '15.2.20.5.4') do +#assert('IO#each_line', '15.2.20.5.5') do + +assert('IO#eof?', '15.2.20.5.6') do + io = IO.new(IO.sysopen($mrbtest_io_rfname)) + $mrbtest_io_msg.each_char { |ch| + # XXX + #assert_false io.eof? + io.getc + } + assert_true io.eof? + io.close + true +end + +assert('IO#flush', '15.2.20.5.7') do + # Note: mruby-io does not have any buffer to be flushed now. + io = IO.new(IO.sysopen($mrbtest_io_wfname)) + assert_equal io, io.flush + io.close + assert_raise(IOError) do + io.flush + end +end + +assert('IO#getc', '15.2.20.5.8') do + io = IO.new(IO.sysopen($mrbtest_io_rfname)) + $mrbtest_io_msg.each_char { |ch| + assert_equal ch, io.getc + } + assert_equal nil, io.getc + io.close + true +end + +#assert('IO#gets', '15.2.20.5.9') do +#assert('IO#initialize_copy', '15.2.20.5.10') do +#assert('IO#print', '15.2.20.5.11') do +#assert('IO#putc', '15.2.20.5.12') do +#assert('IO#puts', '15.2.20.5.13') do + +assert('IO#read', '15.2.20.5.14') do + IO.open(IO.sysopen($mrbtest_io_rfname)) do |io| + assert_raise(ArgumentError) { io.read(-5) } + assert_raise(TypeError) { io.read("str") } + + len = $mrbtest_io_msg.length + assert_equal '', io.read(0) + assert_equal 'mruby', io.read(5) + assert_equal $mrbtest_io_msg[5,len], io.read(len) + + assert_equal "", io.read + assert_nil io.read(1) + end + + IO.open(IO.sysopen($mrbtest_io_rfname)) do |io| + assert_equal $mrbtest_io_msg, io.read + end +end + +assert('IO#readchar', '15.2.20.5.15') do + # almost same as IO#getc + IO.open(IO.sysopen($mrbtest_io_rfname)) do |io| + $mrbtest_io_msg.each_char { |ch| + assert_equal ch, io.readchar + } + assert_raise(EOFError) do + io.readchar + end + end +end + +#assert('IO#readline', '15.2.20.5.16') do +#assert('IO#readlines', '15.2.20.5.17') do + +assert('IO#sync', '15.2.20.5.18') do + io = IO.new(IO.sysopen($mrbtest_io_rfname)) + s = io.sync + assert_true(s == true || s == false) + io.close + assert_raise(IOError) do + io.sync + end +end + +assert('IO#sync=', '15.2.20.5.19') do + io = IO.new(IO.sysopen($mrbtest_io_rfname)) + io.sync = true + assert_true io.sync + io.sync = false + assert_false io.sync + io.close + assert_raise(IOError) do + io.sync = true + end +end + +assert('IO#write', '15.2.20.5.20') do + io = IO.open(IO.sysopen($mrbtest_io_wfname)) + assert_equal 0, io.write("") + io.close + true +end + +assert('IO.for_fd') do + fd = IO.sysopen($mrbtest_io_rfname) + io = IO.for_fd(fd) + assert_equal $mrbtest_io_msg, io.read + io.close + true +end + +assert('IO.new') do + io = IO.new(0) + io.close + true +end + +assert('IO gc check') do + 100.times { IO.new(0) } +end + +assert('IO.sysopen("./nonexistent")') do + if Object.const_defined? :Errno + eclass = Errno::ENOENT + else + eclass = RuntimeError + end + assert_raise eclass do + fd = IO.sysopen "./nonexistent" + IO._sysclose fd + end +end + +assert('IO.sysopen, IO#sysread') do + fd = IO.sysopen $mrbtest_io_rfname + io = IO.new fd + str1 = " " + str2 = io.sysread(5, str1) + assert_equal $mrbtest_io_msg[0,5], str1 + assert_equal $mrbtest_io_msg[0,5], str2 + assert_raise EOFError do + io.sysread(10000) + io.sysread(10000) + end + io.close + io.closed? +end + +assert('IO.sysopen, IO#syswrite') do + fd = IO.sysopen $mrbtest_io_wfname, "w" + io = IO.new fd, "w" + str = "abcdefg" + len = io.syswrite(str) + assert_equal str.size, len + io.close + + io = IO.new(IO.sysopen($mrbtest_io_rfname), "r") + assert_raise(IOError) { io.syswrite("a") } + io.close + + true +end + +assert('IO#_read_buf') do + fd = IO.sysopen $mrbtest_io_rfname + io = IO.new fd + def io._buf + @buf + end + msg_len = $mrbtest_io_msg.size + assert_equal '', io._buf + assert_equal $mrbtest_io_msg, io._read_buf + assert_equal $mrbtest_io_msg, io._buf + assert_equal 'mruby', io.read(5) + assert_equal 5, io.pos + assert_equal msg_len - 5, io._buf.size + assert_equal $mrbtest_io_msg[5,100], io.read + assert_equal 0, io._buf.size + assert_raise EOFError do + io._read_buf + end + assert_equal true, io.eof + assert_equal true, io.eof? + io.close + io.closed? +end + +assert('IO#pos=, IO#seek') do + fd = IO.sysopen $mrbtest_io_rfname + io = IO.new fd + def io._buf + @buf + end + assert_equal 'm', io.getc + assert_equal 1, io.pos + assert_equal 0, io.seek(0) + assert_equal 0, io.pos + io.close + io.closed? +end + +assert('IO#gets') do + fd = IO.sysopen $mrbtest_io_rfname + io = IO.new fd + + # gets without arguments + assert_equal $mrbtest_io_msg, io.gets, "gets without arguments" + assert_equal nil, io.gets, "gets returns nil, when EOF" + + # gets with limit + io.pos = 0 + assert_equal $mrbtest_io_msg[0, 5], io.gets(5), "gets with limit" + + # gets with rs + io.pos = 0 + assert_equal $mrbtest_io_msg[0, 6], io.gets(' '), "gets with rs" + + # gets with rs, limit + io.pos = 0 + assert_equal $mrbtest_io_msg[0, 5], io.gets(' ', 5), "gets with rs, limit" + io.close + assert_equal true, io.closed?, "close success" + + # reading many-lines file. + fd = IO.sysopen $mrbtest_io_wfname, "w" + io = IO.new fd, "w" + io.write "0123456789" * 2 + "\na" + assert_equal 22, io.pos + io.close + assert_equal true, io.closed? + + fd = IO.sysopen $mrbtest_io_wfname + io = IO.new fd + line = io.gets + + # gets first line + assert_equal "0123456789" * 2 + "\n", line, "gets first line" + assert_equal 21, line.size + assert_equal 21, io.pos + + # gets second line + assert_equal "a", io.gets, "gets second line" + + # gets third line + assert_equal nil, io.gets, "gets third line; returns nil" + + io.close + io.closed? +end + +assert('IO#gets - paragraph mode') do + fd = IO.sysopen $mrbtest_io_wfname, "w" + io = IO.new fd, "w" + io.write "0" * 10 + "\n" + io.write "1" * 10 + "\n\n" + io.write "2" * 10 + "\n" + assert_equal 34, io.pos + io.close + assert_equal true, io.closed? + + fd = IO.sysopen $mrbtest_io_wfname + io = IO.new fd + para1 = "#{'0' * 10}\n#{'1' * 10}\n\n" + text1 = io.gets("") + assert_equal para1, text1 + para2 = "#{'2' * 10}\n" + text2 = io.gets("") + assert_equal para2, text2 + io.close + io.closed? +end + +assert('IO.popen') do + io = IO.popen("ls") + assert_true io.close_on_exec? + assert_equal Fixnum, io.pid.class + ls = io.read + assert_equal ls.class, String + assert_include ls, 'AUTHORS' + assert_include ls, 'mrblib' + io.close + io.closed? +end + +assert('IO.read') do + # empty file + fd = IO.sysopen $mrbtest_io_wfname, "w" + io = IO.new fd, "w" + io.close + assert_equal "", IO.read($mrbtest_io_wfname) + assert_equal nil, IO.read($mrbtest_io_wfname, 1) + + # one byte file + fd = IO.sysopen $mrbtest_io_wfname, "w" + io = IO.new fd, "w" + io.write "123" + io.close + assert_equal "123", IO.read($mrbtest_io_wfname) + assert_equal "", IO.read($mrbtest_io_wfname, 0) + assert_equal "1", IO.read($mrbtest_io_wfname, 1) + assert_equal "", IO.read($mrbtest_io_wfname, 0, 10) + assert_equal "23", IO.read($mrbtest_io_wfname, 2, 1) + assert_equal "23", IO.read($mrbtest_io_wfname, 10, 1) + assert_equal "", IO.read($mrbtest_io_wfname, nil, 10) + assert_equal nil, IO.read($mrbtest_io_wfname, 1, 10) +end + +assert('IO#fileno') do + fd = IO.sysopen $mrbtest_io_rfname + io = IO.new fd + assert_equal io.fileno, fd + assert_equal io.to_i, fd + io.close + io.closed? +end + +assert('IO#close_on_exec') do + fd = IO.sysopen $mrbtest_io_wfname, "w" + io = IO.new fd, "w" + begin + # IO.sysopen opens a file descripter with O_CLOEXEC flag. + assert_true io.close_on_exec? + rescue ScriptError + skip "IO\#close_on_exec is not implemented." + end + + io.close_on_exec = false + assert_equal(false, io.close_on_exec?) + io.close_on_exec = true + assert_equal(true, io.close_on_exec?) + io.close_on_exec = false + assert_equal(false, io.close_on_exec?) + + io.close + io.closed? + + # # Use below when IO.pipe is implemented. + # begin + # r, w = IO.pipe + # assert_equal(false, r.close_on_exec?) + # r.close_on_exec = true + # assert_equal(true, r.close_on_exec?) + # r.close_on_exec = false + # assert_equal(false, r.close_on_exec?) + # r.close_on_exec = true + # assert_equal(true, r.close_on_exec?) + + # assert_equal(false, w.close_on_exec?) + # w.close_on_exec = true + # assert_equal(true, w.close_on_exec?) + # w.close_on_exec = false + # assert_equal(false, w.close_on_exec?) + # w.close_on_exec = true + # assert_equal(true, w.close_on_exec?) + # ensure + # r.close unless r.closed? + # w.close unless w.closed? + # end +end + +assert('`cmd`') do + assert_equal `echo foo`, "foo\n" +end + +assert('IO TEST CLEANUP') do + assert_nil MRubyIOTestUtil.io_test_cleanup +end diff --git a/web/server/h2o/libh2o/deps/mruby-io/test/mruby_io_test.c b/web/server/h2o/libh2o/deps/mruby-io/test/mruby_io_test.c new file mode 100644 index 00000000..f58f9ff8 --- /dev/null +++ b/web/server/h2o/libh2o/deps/mruby-io/test/mruby_io_test.c @@ -0,0 +1,141 @@ +#include +#include +#include +#include +#include +#include +#include + +#include "mruby.h" +#include "mruby/array.h" +#include "mruby/string.h" +#include "mruby/variable.h" + +static mrb_value +mrb_io_test_io_setup(mrb_state *mrb, mrb_value self) +{ + char rfname[] = "tmp.mruby-io-test.XXXXXXXX"; + char wfname[] = "tmp.mruby-io-test.XXXXXXXX"; + char symlinkname[] = "tmp.mruby-io-test.XXXXXXXX"; + char socketname[] = "tmp.mruby-io-test.XXXXXXXX"; + char msg[] = "mruby io test\n"; + mode_t mask; + int fd0, fd1, fd2, fd3; + FILE *fp; + struct sockaddr_un sun0; + + mask = umask(077); + fd0 = mkstemp(rfname); + fd1 = mkstemp(wfname); + fd2 = mkstemp(symlinkname); + fd3 = mkstemp(socketname); + if (fd0 == -1 || fd1 == -1 || fd2 == -1 || fd3 == -1) { + mrb_raise(mrb, E_RUNTIME_ERROR, "can't create temporary file"); + return mrb_nil_value(); + } + umask(mask); + + mrb_gv_set(mrb, mrb_intern_cstr(mrb, "$mrbtest_io_rfname"), mrb_str_new_cstr(mrb, rfname)); + mrb_gv_set(mrb, mrb_intern_cstr(mrb, "$mrbtest_io_wfname"), mrb_str_new_cstr(mrb, wfname)); + mrb_gv_set(mrb, mrb_intern_cstr(mrb, "$mrbtest_io_symlinkname"), mrb_str_new_cstr(mrb, symlinkname)); + mrb_gv_set(mrb, mrb_intern_cstr(mrb, "$mrbtest_io_socketname"), mrb_str_new_cstr(mrb, socketname)); + mrb_gv_set(mrb, mrb_intern_cstr(mrb, "$mrbtest_io_msg"), mrb_str_new_cstr(mrb, msg)); + + fp = fopen(rfname, "w"); + if (fp == NULL) { + mrb_raise(mrb, E_RUNTIME_ERROR, "can't open temporary file"); + return mrb_nil_value(); + } + fputs(msg, fp); + fclose(fp); + + fp = fopen(wfname, "w"); + if (fp == NULL) { + mrb_raise(mrb, E_RUNTIME_ERROR, "can't open temporary file"); + return mrb_nil_value(); + } + fclose(fp); + + unlink(symlinkname); + close(fd2); + if (symlink("hoge", symlinkname) == -1) { + mrb_raise(mrb, E_RUNTIME_ERROR, "can't make a symbolic link"); + } + + unlink(socketname); + close(fd3); + fd3 = socket(AF_UNIX, SOCK_STREAM, 0); + if (fd3 == -1) { + mrb_raise(mrb, E_RUNTIME_ERROR, "can't make a socket"); + } + sun0.sun_family = AF_UNIX; + snprintf(sun0.sun_path, sizeof(sun0.sun_path), "%s", socketname); + if (bind(fd3, (struct sockaddr *)&sun0, sizeof(sun0)) == -1) { + mrb_raise(mrb, E_RUNTIME_ERROR, "can't make a socket bi"); + } + close(fd3); + + return mrb_true_value(); +} + +static mrb_value +mrb_io_test_io_cleanup(mrb_state *mrb, mrb_value self) +{ + mrb_value rfname = mrb_gv_get(mrb, mrb_intern_cstr(mrb, "$mrbtest_io_rfname")); + mrb_value wfname = mrb_gv_get(mrb, mrb_intern_cstr(mrb, "$mrbtest_io_wfname")); + mrb_value symlinkname = mrb_gv_get(mrb, mrb_intern_cstr(mrb, "$mrbtest_io_symlinkname")); + mrb_value socketname = mrb_gv_get(mrb, mrb_intern_cstr(mrb, "$mrbtest_io_socketname")); + + if (mrb_type(rfname) == MRB_TT_STRING) { + remove(RSTRING_PTR(rfname)); + } + if (mrb_type(wfname) == MRB_TT_STRING) { + remove(RSTRING_PTR(wfname)); + } + if (mrb_type(symlinkname) == MRB_TT_STRING) { + remove(RSTRING_PTR(symlinkname)); + } + if (mrb_type(socketname) == MRB_TT_STRING) { + remove(RSTRING_PTR(socketname)); + } + + mrb_gv_set(mrb, mrb_intern_cstr(mrb, "$mrbtest_io_rfname"), mrb_nil_value()); + mrb_gv_set(mrb, mrb_intern_cstr(mrb, "$mrbtest_io_wfname"), mrb_nil_value()); + mrb_gv_set(mrb, mrb_intern_cstr(mrb, "$mrbtest_io_symlinkname"), mrb_nil_value()); + mrb_gv_set(mrb, mrb_intern_cstr(mrb, "$mrbtest_io_socketname"), mrb_nil_value()); + mrb_gv_set(mrb, mrb_intern_cstr(mrb, "$mrbtest_io_msg"), mrb_nil_value()); + + return mrb_nil_value(); +} + +static mrb_value +mrb_io_test_file_setup(mrb_state *mrb, mrb_value self) +{ + mrb_value ary = mrb_io_test_io_setup(mrb, self); + if (symlink("/usr/bin", "test-bin") == -1) { + mrb_raise(mrb, E_RUNTIME_ERROR, "can't make a symbolic link"); + } + + return ary; +} + +static mrb_value +mrb_io_test_file_cleanup(mrb_state *mrb, mrb_value self) +{ + mrb_io_test_io_cleanup(mrb, self); + remove("test-bin"); + + return mrb_nil_value(); +} + +void +mrb_mruby_io_gem_test(mrb_state* mrb) +{ + struct RClass *io_test = mrb_define_module(mrb, "MRubyIOTestUtil"); + mrb_define_class_method(mrb, io_test, "io_test_setup", mrb_io_test_io_setup, MRB_ARGS_NONE()); + mrb_define_class_method(mrb, io_test, "io_test_cleanup", mrb_io_test_io_cleanup, MRB_ARGS_NONE()); + + mrb_define_class_method(mrb, io_test, "file_test_setup", mrb_io_test_file_setup, MRB_ARGS_NONE()); + mrb_define_class_method(mrb, io_test, "file_test_cleanup", mrb_io_test_file_cleanup, MRB_ARGS_NONE()); + +} -- cgit v1.2.3