diff options
Diffstat (limited to 'test/stringio')
| -rw-r--r-- | test/stringio/test_stringio.rb | 314 |
1 files changed, 314 insertions, 0 deletions
diff --git a/test/stringio/test_stringio.rb b/test/stringio/test_stringio.rb index 5f8067e696..d022c10fad 100644 --- a/test/stringio/test_stringio.rb +++ b/test/stringio/test_stringio.rb @@ -21,6 +21,9 @@ class TestStringIO < Test::Unit::TestCase io.truncate(0) io.puts "def" assert_equal("\0\0\0\0def\n", io.string, "[ruby-dev:24190]") + assert_raise(Errno::EINVAL) { io.truncate(-1) } + io.truncate(10) + assert_equal("\0\0\0\0def\n\0\0", io.string) end def test_seek_beyond_eof @@ -65,4 +68,315 @@ class TestStringIO < Test::Unit::TestCase assert_equal(["abc\n\n", "def\n"], StringIO.new("abc\n\ndef\n").readlines("")) end + def test_write + s = "" + f = StringIO.new(s, "w") + f.print("foo") + f.close + assert_equal("foo", s) + + f = StringIO.new(s, File::WRONLY) + f.print("bar") + f.close + assert_equal("bar", s) + + f = StringIO.new(s, "a") + o = Object.new + def o.to_s; "baz"; end + f.print(o) + f.close + assert_equal("barbaz", s) + ensure + f.close unless f.closed? + end + + def test_mode_error + f = StringIO.new("", "r") + assert_raise(IOError) { f.write("foo") } + + f = StringIO.new("", "w") + assert_raise(IOError) { f.read } + + assert_raise(Errno::EACCES) { StringIO.new("".freeze, "w") } + s = "" + f = StringIO.new(s, "w") + s.freeze + assert_raise(IOError) { f.write("foo") } + + assert_raise(IOError) { StringIO.allocate.read } + ensure + f.close unless f.closed? + end + + def test_open + s = "" + StringIO.open("foo") {|f| s = f.read } + assert_equal("foo", s) + end + + def test_isatty + assert_equal(false, StringIO.new("").isatty) + end + + def test_path + assert_equal(nil, StringIO.new("").path) + end + + def test_fsync + assert_equal(0, StringIO.new("").fsync) + end + + def test_sync + assert_equal(true, StringIO.new("").sync) + assert_equal(false, StringIO.new("").sync = false) + end + + def test_set_fcntl + assert_raise(NotImplementedError) { StringIO.new("").fcntl } + end + + def test_close + f = StringIO.new("") + f.close + assert_raise(IOError) { f.close } + + f = StringIO.new("") + f.close_read + f.close_write + assert_raise(IOError) { f.close } + ensure + f.close unless f.closed? + end + + def test_close_read + f = StringIO.new("") + f.close_read + assert_raise(IOError) { f.read } + assert_raise(IOError) { f.close_read } + f.close + + f = StringIO.new("", "w") + assert_raise(IOError) { f.close_read } + f.close + ensure + f.close unless f.closed? + end + + def test_close_write + f = StringIO.new("") + f.close_write + assert_raise(IOError) { f.write("foo") } + assert_raise(IOError) { f.close_write } + f.close + + f = StringIO.new("", "r") + assert_raise(IOError) { f.close_write } + f.close + ensure + f.close unless f.closed? + end + + def test_closed + f = StringIO.new("") + assert_equal(false, f.closed?) + f.close + assert_equal(true, f.closed?) + ensure + f.close unless f.closed? + end + + def test_closed_read + f = StringIO.new("") + assert_equal(false, f.closed_read?) + f.close_write + assert_equal(false, f.closed_read?) + f.close_read + assert_equal(true, f.closed_read?) + ensure + f.close unless f.closed? + end + + def test_closed_write + f = StringIO.new("") + assert_equal(false, f.closed_write?) + f.close_read + assert_equal(false, f.closed_write?) + f.close_write + assert_equal(true, f.closed_write?) + ensure + f.close unless f.closed? + end + + def test_dup + f1 = StringIO.new("1234") + assert_equal("1", f1.getc) + f2 = f1.dup + assert_equal("2", f2.getc) + assert_equal("3", f1.getc) + assert_equal("4", f2.getc) + assert_equal(nil, f1.getc) + assert_equal(true, f2.eof?) + f1.close + assert_equal(true, f2.closed?) + ensure + f1.close unless f1.closed? + f2.close unless f2.closed? + end + + def test_lineno + f = StringIO.new("foo\nbar\nbaz\n") + assert_equal([0, "foo\n"], [f.lineno, f.gets]) + assert_equal([1, "bar\n"], [f.lineno, f.gets]) + f.lineno = 1000 + assert_equal([1000, "baz\n"], [f.lineno, f.gets]) + assert_equal([1001, nil], [f.lineno, f.gets]) + ensure + f.close unless f.closed? + end + + def test_pos + f = StringIO.new("foo\nbar\nbaz\n") + assert_equal([0, "foo\n"], [f.pos, f.gets]) + assert_equal([4, "bar\n"], [f.pos, f.gets]) + assert_raise(Errno::EINVAL) { f.pos = -1 } + f.pos = 1 + assert_equal([1, "oo\n"], [f.pos, f.gets]) + assert_equal([4, "bar\n"], [f.pos, f.gets]) + assert_equal([8, "baz\n"], [f.pos, f.gets]) + assert_equal([12, nil], [f.pos, f.gets]) + ensure + f.close unless f.closed? + end + + def test_reopen + f = StringIO.new("foo\nbar\nbaz\n") + assert_equal("foo\n", f.gets) + f.reopen("qux\nquux\nquuux\n") + assert_equal("quux\n", f.gets) + + f2 = StringIO.new("") + f2.reopen(f) + assert_equal("quuux\n", f2.gets) + ensure + f.close unless f.closed? + end + + def test_seek + f = StringIO.new("1234") + assert_raise(Errno::EINVAL) { f.seek(-1) } + f.seek(-1, 2) + assert_equal("4", f.getc) + assert_raise(Errno::EINVAL) { f.seek(1, 3) } + f.close + assert_raise(IOError) { f.seek(0) } + ensure + f.close unless f.closed? + end + + def test_each_byte + f = StringIO.new("1234") + a = [] + f.each_byte {|c| a << c } + assert_equal(%w(1 2 3 4).map {|c| c.ord }, a) + ensure + f.close unless f.closed? + end + + def test_getbyte + f = StringIO.new("1234") + assert_equal("1".ord, f.getbyte) + assert_equal("2".ord, f.getbyte) + assert_equal("3".ord, f.getbyte) + assert_equal("4".ord, f.getbyte) + assert_equal(nil, f.getbyte) + ensure + f.close unless f.closed? + end + + def test_ungetc + s = "1234" + f = StringIO.new(s, "r") + assert_nothing_raised { f.ungetc("x") } + assert_equal("x", f.getc) # bug? + assert_equal("1", f.getc) + + s = "1234" + f = StringIO.new(s, "r") + assert_equal("1", f.getc) + f.ungetc("y".ord) + assert_equal("y", f.getc) + assert_equal("2", f.getc) + ensure + f.close unless f.closed? + end + + def test_readchar + f = StringIO.new("1234") + a = "" + assert_raise(EOFError) { loop { a << f.readchar } } + assert_equal("1234", a) + end + + def test_readbyte + f = StringIO.new("1234") + a = [] + assert_raise(EOFError) { loop { a << f.readbyte } } + assert_equal("1234".unpack("C*"), a) + end + + def test_each_char + f = StringIO.new("1234") + assert_equal(%w(1 2 3 4), f.each_char.to_a) + end + + def test_gets2 + f = StringIO.new("foo\nbar\nbaz\n") + assert_equal("fo", f.gets(2)) + + o = Object.new + def o.to_str; "z"; end + assert_equal("o\nbar\nbaz", f.gets(o)) + + f = StringIO.new("foo\nbar\nbaz\n") + assert_equal("foo\nbar\nbaz", f.gets("az")) + f = StringIO.new("a" * 10000 + "zz!") + assert_equal("a" * 10000 + "zz", f.gets("zz")) + f = StringIO.new("a" * 10000 + "zz!") + assert_equal("a" * 10000 + "zz!", f.gets("zzz")) + end + + def test_each + f = StringIO.new("foo\nbar\nbaz\n") + assert_equal(["foo\n", "bar\n", "baz\n"], f.each.to_a) + end + + def test_putc + s = "" + f = StringIO.new(s, "w") + f.putc("1") + f.putc("2") + f.putc("3") + f.close + assert_equal("123", s) + + s = "foo" + f = StringIO.new(s, "a") + f.putc("1") + f.putc("2") + f.putc("3") + f.close + assert_equal("foo123", s) + end + + def test_read + f = StringIO.new("1234") + assert_raise(ArgumentError) { f.read(-1) } + assert_raise(ArgumentError) { f.read(1, 2, 3) } + end + + def test_size + f = StringIO.new("1234") + assert_equal(4, f.size) + end + end |