From fcbf63e62c627deae76c1b8cb8c0876c536ed811 Mon Sep 17 00:00:00 2001
From: Jari Vetoniemi <jari.vetoniemi@indooratlas.com>
Date: Mon, 16 Mar 2020 18:49:26 +0900
Subject: Fresh start

---
 jni/ruby/test/stringio/test_stringio.rb | 589 ++++++++++++++++++++++++++++++++
 1 file changed, 589 insertions(+)
 create mode 100644 jni/ruby/test/stringio/test_stringio.rb

(limited to 'jni/ruby/test/stringio/test_stringio.rb')

diff --git a/jni/ruby/test/stringio/test_stringio.rb b/jni/ruby/test/stringio/test_stringio.rb
new file mode 100644
index 0000000..07d89d1
--- /dev/null
+++ b/jni/ruby/test/stringio/test_stringio.rb
@@ -0,0 +1,589 @@
+require 'test/unit'
+require 'stringio'
+require_relative '../ruby/ut_eof'
+
+class TestStringIO < Test::Unit::TestCase
+  include TestEOF
+  def open_file(content)
+    f = StringIO.new(content)
+    yield f
+  end
+  alias open_file_rw open_file
+
+  include TestEOF::Seek
+
+  def test_truncate
+    io = StringIO.new("")
+    io.puts "abc"
+    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
+    io = StringIO.new
+    n = 100
+    io.seek(n)
+    io.print "last"
+    assert_equal("\0" * n + "last", io.string, "[ruby-dev:24194]")
+  end
+
+  def test_overwrite
+    stringio = StringIO.new
+    responses = ['', 'just another ruby', 'hacker']
+    responses.each do |resp|
+      stringio.puts(resp)
+      stringio.rewind
+    end
+    assert_equal("hacker\nother ruby\n", stringio.string, "[ruby-core:3836]")
+  end
+
+  def test_gets
+    assert_equal(nil, StringIO.new("").gets)
+    assert_equal("\n", StringIO.new("\n").gets)
+    assert_equal("a\n", StringIO.new("a\n").gets)
+    assert_equal("a\n", StringIO.new("a\nb\n").gets)
+    assert_equal("a", StringIO.new("a").gets)
+    assert_equal("a\n", StringIO.new("a\nb").gets)
+    assert_equal("abc\n", StringIO.new("abc\n\ndef\n").gets)
+    assert_equal("abc\n\ndef\n", StringIO.new("abc\n\ndef\n").gets(nil))
+    assert_equal("abc\n\n", StringIO.new("abc\n\ndef\n").gets(""))
+    assert_raise(TypeError){StringIO.new("").gets(1, 1)}
+    assert_nothing_raised {StringIO.new("").gets(nil, nil)}
+  end
+
+  def test_readlines
+    assert_equal([], StringIO.new("").readlines)
+    assert_equal(["\n"], StringIO.new("\n").readlines)
+    assert_equal(["a\n"], StringIO.new("a\n").readlines)
+    assert_equal(["a\n", "b\n"], StringIO.new("a\nb\n").readlines)
+    assert_equal(["a"], StringIO.new("a").readlines)
+    assert_equal(["a\n", "b"], StringIO.new("a\nb").readlines)
+    assert_equal(["abc\n", "\n", "def\n"], StringIO.new("abc\n\ndef\n").readlines)
+    assert_equal(["abc\n\ndef\n"], StringIO.new("abc\n\ndef\n").readlines(nil), "[ruby-dev:34591]")
+    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_write_nonblock_no_exceptions
+    s = ""
+    f = StringIO.new(s, "w")
+    f.write_nonblock("foo", exception: false)
+    f.close
+    assert_equal("foo", s)
+  end
+
+  def test_write_nonblock
+    s = ""
+    f = StringIO.new(s, "w")
+    f.write_nonblock("foo")
+    f.close
+    assert_equal("foo", s)
+
+    f = StringIO.new(s, File::WRONLY)
+    f.write_nonblock("bar")
+    f.close
+    assert_equal("bar", s)
+
+    f = StringIO.new(s, "a")
+    o = Object.new
+    def o.to_s; "baz"; end
+    f.write_nonblock(o)
+    f.close
+    assert_equal("barbaz", s)
+  ensure
+    f.close unless f.closed?
+  end
+
+  def test_write_infection
+    bug9769 = '[ruby-dev:48118] [Bug #9769]'
+    s = "".untaint
+    f = StringIO.new(s, "w")
+    f.print("bar".taint)
+    f.close
+    assert_predicate(s, :tainted?, bug9769)
+  ensure
+    f.close unless f.closed?
+  end
+
+  def test_write_encoding
+    s = "".force_encoding(Encoding::UTF_8)
+    f = StringIO.new(s)
+    f.print("\u{3053 3093 306b 3061 306f ff01}".b)
+    assert_equal(Encoding::UTF_8, s.encoding, "honor the original encoding over ASCII-8BIT")
+  end
+
+  def test_set_encoding
+    bug10285 = '[ruby-core:65240] [Bug #10285]'
+    f = StringIO.new()
+    f.set_encoding(Encoding::ASCII_8BIT)
+    f.write("quz \x83 mat".b)
+    s = "foo \x97 bar".force_encoding(Encoding::WINDOWS_1252)
+    assert_nothing_raised(Encoding::CompatibilityError, bug10285) {
+      f.write(s)
+    }
+    assert_equal(Encoding::ASCII_8BIT, f.string.encoding, bug10285)
+  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_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(false, f2.closed?, '[ruby-core:48443]')
+  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("qux\n", f.gets)
+
+    f2 = StringIO.new("")
+    f2.reopen(f)
+    assert_equal("quux\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_ungetbyte
+    s = "foo\nbar\n"
+    t = StringIO.new(s, "r")
+    t.ungetbyte(0x41)
+    assert_equal(0x41, t.getbyte)
+    t.ungetbyte("qux")
+    assert_equal("quxfoo\n", t.gets)
+    t.set_encoding("utf-8")
+    t.ungetbyte(0x89)
+    t.ungetbyte(0x8e)
+    t.ungetbyte("\xe7")
+    t.ungetbyte("\xe7\xb4\x85")
+    assert_equal("\u7d05\u7389bar\n", t.gets)
+  end
+
+  def test_ungetc
+    s = "1234"
+    f = StringIO.new(s, "r")
+    assert_nothing_raised { f.ungetc("x") }
+    assert_equal("x", f.getc) # bug? -> it's a feature from 1.9.
+    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_each_codepoint
+    f = StringIO.new("1234")
+    assert_equal([49, 50, 51, 52], f.each_codepoint.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"))
+
+    bug4112 = '[ruby-dev:42674]'
+    ["a".encode("utf-16be"), "\u3042"].each do |s|
+      assert_equal(s, StringIO.new(s).gets(1), bug4112)
+      assert_equal(s, StringIO.new(s).gets(nil, 1), bug4112)
+    end
+  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_putc_nonascii
+    s = ""
+    f = StringIO.new(s, "w")
+    f.putc("\u{3042}")
+    f.putc(0x3044)
+    f.close
+    assert_equal("\u{3042}D", s)
+
+    s = "foo"
+    f = StringIO.new(s, "a")
+    f.putc("\u{3042}")
+    f.putc(0x3044)
+    f.close
+    assert_equal("foo\u{3042}D", s)
+  end
+
+  def test_read
+    f = StringIO.new("\u3042\u3044")
+    assert_raise(ArgumentError) { f.read(-1) }
+    assert_raise(ArgumentError) { f.read(1, 2, 3) }
+    assert_equal("\u3042\u3044", f.read)
+    f.rewind
+    assert_equal("\u3042\u3044".force_encoding(Encoding::ASCII_8BIT), f.read(f.size))
+
+    bug5207 = '[ruby-core:39026]'
+    f.rewind
+    assert_equal("\u3042\u3044", f.read(nil, nil), bug5207)
+    f.rewind
+    s = ""
+    f.read(nil, s)
+    assert_equal("\u3042\u3044", s, bug5207)
+    f.rewind
+    # not empty buffer
+    s = "0123456789"
+    f.read(nil, s)
+    assert_equal("\u3042\u3044", s)
+  end
+
+  def test_readpartial
+    f = StringIO.new("\u3042\u3044")
+    assert_raise(ArgumentError) { f.readpartial(-1) }
+    assert_raise(ArgumentError) { f.readpartial(1, 2, 3) }
+    assert_equal("\u3042\u3044".force_encoding(Encoding::ASCII_8BIT), f.readpartial(100))
+    f.rewind
+    assert_equal("\u3042\u3044".force_encoding(Encoding::ASCII_8BIT), f.readpartial(f.size))
+    f.rewind
+    # not empty buffer
+    s = '0123456789'
+    assert_equal("\u3042\u3044".force_encoding(Encoding::ASCII_8BIT), f.readpartial(f.size, s))
+  end
+
+  def test_read_nonblock
+    f = StringIO.new("\u3042\u3044")
+    assert_raise(ArgumentError) { f.read_nonblock(-1) }
+    assert_raise(ArgumentError) { f.read_nonblock(1, 2, 3) }
+    assert_equal("\u3042\u3044".force_encoding("BINARY"), f.read_nonblock(100))
+    assert_raise(EOFError) { f.read_nonblock(10) }
+    f.rewind
+    assert_equal("\u3042\u3044".force_encoding(Encoding::ASCII_8BIT), f.read_nonblock(f.size))
+  end
+
+  def test_read_nonblock_no_exceptions
+    f = StringIO.new("\u3042\u3044")
+    assert_raise(ArgumentError) { f.read_nonblock(-1, exception: false) }
+    assert_raise(ArgumentError) { f.read_nonblock(1, 2, 3, exception: false) }
+    assert_raise(ArgumentError) { f.read_nonblock }
+    assert_equal("\u3042\u3044".force_encoding(Encoding::ASCII_8BIT), f.read_nonblock(100, exception: false))
+    assert_equal(nil, f.read_nonblock(10, exception: false))
+    f.rewind
+    assert_equal("\u3042\u3044".force_encoding(Encoding::ASCII_8BIT), f.read_nonblock(f.size))
+    f.rewind
+    # not empty buffer
+    s = '0123456789'
+    assert_equal("\u3042\u3044".force_encoding(Encoding::ASCII_8BIT), f.read_nonblock(f.size, s))
+  end
+
+  def test_size
+    f = StringIO.new("1234")
+    assert_equal(4, f.size)
+  end
+
+  # This test is should in ruby/test_method.rb
+  # However this test depends on stringio library,
+  # we write it here.
+  class C < StringIO
+    alias old_init initialize
+    attr_reader :foo
+    def initialize
+      @foo = :ok
+      old_init
+    end
+  end
+
+  def test_method
+    assert_equal(:ok, C.new.foo, 'Bug #632 [ruby-core:19282]')
+  end
+
+  def test_ungetc_pos
+    b = '\\b00010001 \\B00010001 \\b1 \\B1 \\b000100011'
+    s = StringIO.new( b )
+    expected_pos = 0
+    while n = s.getc
+      assert_equal( expected_pos + 1, s.pos )
+
+      s.ungetc( n )
+      assert_equal( expected_pos, s.pos )
+      assert_equal( n, s.getc )
+
+      expected_pos += 1
+    end
+  end
+
+  def test_frozen
+    s = StringIO.new
+    s.freeze
+    bug = '[ruby-core:33648]'
+    assert_raise(RuntimeError, bug) {s.puts("foo")}
+    assert_raise(RuntimeError, bug) {s.string = "foo"}
+    assert_raise(RuntimeError, bug) {s.reopen("")}
+  end
+
+  def test_frozen_string
+    s = StringIO.new("".freeze)
+    bug = '[ruby-core:48530]'
+    assert_raise(IOError, bug) {s.write("foo")}
+    assert_raise(IOError, bug) {s.ungetc("a")}
+    assert_raise(IOError, bug) {s.ungetbyte("a")}
+  end
+
+  def test_readlines_limit_0
+    assert_raise(ArgumentError, "[ruby-dev:43392]") { StringIO.new.readlines(0) }
+  end
+
+  def test_each_line_limit_0
+    assert_raise(ArgumentError, "[ruby-dev:43392]") { StringIO.new.each_line(0){} }
+    assert_raise(ArgumentError, "[ruby-dev:43392]") { StringIO.new.each_line("a",0){} }
+  end
+end
-- 
cgit v1.2.3