From 437af4f46fdc54cd348779f65bc12d2c962f1b18 Mon Sep 17 00:00:00 2001
From: mame <mame@b2dd03c8-39d4-4d8f-98ff-823fe69b080e>
Date: Thu, 5 Jun 2008 14:33:01 +0000
Subject: * test/stringio/test_stringio.rb: add tests to achieve over 95% test 
  coverage of stringio.

* test/strscan/test_stringscanner.rb: ditto for strscan.


git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@16847 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
---
 test/stringio/test_stringio.rb | 314 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 314 insertions(+)

(limited to 'test/stringio')

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
-- 
cgit v1.2.3