diff options
Diffstat (limited to 'ruby_1_8_6/test/csv/test_csv.rb')
| -rw-r--r-- | ruby_1_8_6/test/csv/test_csv.rb | 1753 |
1 files changed, 1753 insertions, 0 deletions
diff --git a/ruby_1_8_6/test/csv/test_csv.rb b/ruby_1_8_6/test/csv/test_csv.rb new file mode 100644 index 0000000000..1db540921b --- /dev/null +++ b/ruby_1_8_6/test/csv/test_csv.rb @@ -0,0 +1,1753 @@ +require 'test/unit' +require 'tempfile' +require 'fileutils' + +require 'csv' + +class CSV + class StreamBuf + # Let buffer work hard. + remove_const("BufSize") + BufSize = 2 + end +end + + +module CSVTestSupport + def d(data) + data + end +end + + +class TestCSV < Test::Unit::TestCase + file = Tempfile.new("crlf") + file << "\n" + file.open + file.binmode + RSEP = file.read + file.close + + include CSVTestSupport + + class << self + include CSVTestSupport + end + + @@simpleCSVData = { + [nil] => '', + [''] => '""', + [nil, nil] => ',', + [nil, nil, nil] => ',,', + ['foo'] => 'foo', + [','] => '","', + [',', ','] => '",",","', + [';'] => ';', + [';', ';'] => ';,;', + ["\"\r", "\"\r"] => "\"\"\"\r\",\"\"\"\r\"", + ["\"\n", "\"\n"] => "\"\"\"\n\",\"\"\"\n\"", + ["\t"] => "\t", + ["\t", "\t"] => "\t,\t", + ['foo', 'bar'] => 'foo,bar', + ['foo', '"bar"', 'baz'] => 'foo,"""bar""",baz', + ['foo', 'foo,bar', 'baz'] => 'foo,"foo,bar",baz', + ['foo', '""', 'baz'] => 'foo,"""""",baz', + ['foo', '', 'baz'] => 'foo,"",baz', + ['foo', nil, 'baz'] => 'foo,,baz', + [nil, 'foo', 'bar'] => ',foo,bar', + ['foo', 'bar', nil] => 'foo,bar,', + ['foo', "\r", 'baz'] => "foo,\"\r\",baz", + ['foo', "\n", 'baz'] => "foo,\"\n\",baz", + ['foo', "\r\n\r", 'baz'] => "foo,\"\r\n\r\",baz", + ['foo', "\r\n", 'baz'] => "foo,\"\r\n\",baz", + ['foo', "\r.\n", 'baz'] => "foo,\"\r.\n\",baz", + ['foo', "\r\n\n", 'baz'] => "foo,\"\r\n\n\",baz", + ['foo', '"', 'baz'] => 'foo,"""",baz', + } + + @@fullCSVData = { + [d(nil)] => '', + [d('')] => '""', + [d(nil), d(nil)] => ',', + [d(nil), d(nil), d(nil)] => ',,', + [d('foo')] => 'foo', + [d('foo'), d('bar')] => 'foo,bar', + [d('foo'), d('"bar"'), d('baz')] => 'foo,"""bar""",baz', + [d('foo'), d('foo,bar'), d('baz')] => 'foo,"foo,bar",baz', + [d('foo'), d('""'), d('baz')] => 'foo,"""""",baz', + [d('foo'), d(''), d('baz')] => 'foo,"",baz', + [d('foo'), d(nil), d('baz')] => 'foo,,baz', + [d('foo'), d("\r"), d('baz')] => "foo,\"\r\",baz", + [d('foo'), d("\n"), d('baz')] => "foo,\"\n\",baz", + [d('foo'), d("\r\n"), d('baz')] => "foo,\"\r\n\",baz", + [d('foo'), d("\r.\n"), d('baz')] => "foo,\"\r.\n\",baz", + [d('foo'), d("\r\n\n"), d('baz')] => "foo,\"\r\n\n\",baz", + [d('foo'), d('"'), d('baz')] => 'foo,"""",baz', + } + + @@fullCSVDataArray = @@fullCSVData.collect { |key, value| key } + + def ssv2csv(ssvStr, row_sep = nil) + sepConv(ssvStr, ?;, ?,, row_sep) + end + + def csv2ssv(csvStr, row_sep = nil) + sepConv(csvStr, ?,, ?;, row_sep) + end + + def tsv2csv(tsvStr, row_sep = nil) + sepConv(tsvStr, ?\t, ?,, row_sep) + end + + def csv2tsv(csvStr, row_sep = nil) + sepConv(csvStr, ?,, ?\t, row_sep) + end + + def sepConv(srcStr, srcSep, destSep, row_sep = nil) + rows = [] + cols, idx = CSV.parse_row(srcStr, 0, rows, srcSep, row_sep) + destStr = '' + cols = CSV.generate_row(rows, rows.size, destStr, destSep, row_sep) + destStr + end + +public + + def setup + @tmpdir = File.join(Dir.tmpdir, "ruby_test_csv_tmp_#{$$}") + Dir.mkdir(@tmpdir) + @infile = File.join(@tmpdir, 'in.csv') + @infiletsv = File.join(@tmpdir, 'in.tsv') + @emptyfile = File.join(@tmpdir, 'empty.csv') + @outfile = File.join(@tmpdir, 'out.csv') + @bomfile = File.join(@tmpdir, "bom.csv") + @macfile = File.join(@tmpdir, "mac.csv") + + CSV.open(@infile, "wb") do |writer| + @@fullCSVDataArray.each do |row| + writer.add_row(row) + end + end + + CSV.open(@infiletsv, "wb", ?\t) do |writer| + @@fullCSVDataArray.each do |row| + writer.add_row(row) + end + end + + CSV.generate(@emptyfile) do |writer| + # Create empty file. + end + + File.open(@bomfile, "wb") do |f| + f.write("\357\273\277\"foo\"\r\n\"bar\"\r\n") + end + + File.open(@macfile, "wb") do |f| + f.write("\"Avenches\",\"aus Umgebung\"\r\"Bad Hersfeld\",\"Ausgrabung\"") + end + end + + def teardown + FileUtils.rm_rf(@tmpdir) + end + + #### CSV::Reader unit test + + def test_Reader_each + file = File.open(@infile, "rb") + begin + reader = CSV::Reader.create(file) + expectedArray = @@fullCSVDataArray.dup + first = true + ret = reader.each { |row| + if first + assert_instance_of(Array, row) + first = false + end + expected = expectedArray.shift + assert_equal(expected, row) + } + assert_nil(ret, "Return is nil") + assert(expectedArray.empty?) + ensure + file.close + end + + # Illegal format. + reader = CSV::Reader.create("a,b\r\na,b,\"c\"\ra") + assert_raises(CSV::IllegalFormatError) do + reader.each do |row| + end + end + + reader = CSV::Reader.create("a,b\r\n\"") + assert_raises(CSV::IllegalFormatError) do + reader.each do |row| + end + end + end + + def test_Reader_shift + file = File.open(@infile, "rb") + begin + reader = CSV::Reader.create(file) + first = true + checked = 0 + @@fullCSVDataArray.each do |expected| + actual = reader.shift + if first + assert_instance_of(Array, actual) + first = false + end + assert_equal(expected, actual) + checked += 1 + end + assert(checked == @@fullCSVDataArray.size) + ensure + file.close + end + + # Illegal format. + reader = CSV::Reader.create("a,b\r\na,b,\"c\"\ra") + assert_raises(CSV::IllegalFormatError) do + reader.shift + reader.shift + end + + reader = CSV::Reader.create("a,b\r\na,b,\"c\"\ra") + assert_raises(CSV::IllegalFormatError) do + reader.shift + reader.shift + end + end + + def test_Reader_getRow + if CSV::Reader.respond_to?(:allocate) + obj = CSV::Reader.allocate + assert_raises(NotImplementedError) do + row = [] + obj.shift + end + end + end + + def test_IOReader_close_on_terminate + f = File.open(@infile, "r") + reader = CSV::IOReader.create(f) + reader.close + assert(!f.closed?) + f.close + + f = File.open(@infile, "r") + writer = CSV::IOReader.create(f) + writer.close_on_terminate + writer.close + assert(f.closed?) + end + + def test_Reader_close + f = File.open(@infile, "r") + reader = CSV::IOReader.create(f) + reader.close_on_terminate + reader.close + assert(f.closed?) + end + + def test_Reader_s_new + assert_raises(RuntimeError) do + CSV::Reader.new(nil) + end + end + + def test_Reader_s_create + reader = CSV::Reader.create("abc") + assert_instance_of(CSV::StringReader, reader, "With a String") + + file = File.open(@infile, "rb") + reader = CSV::Reader.create(file) + assert_instance_of(CSV::IOReader, reader, 'With an IO') + + obj = Object.new + def obj.sysread(size) + "abc" + end + def obj.read(size) + "abc" + end + reader = CSV::Reader.create(obj) + assert_instance_of(CSV::IOReader, reader, "With not an IO or String") + + # No need to test Tempfile because it's a pseudo IO. I test this here + # fors other tests. + reader = CSV::Reader.create(Tempfile.new("in.csv")) + assert_instance_of(CSV::IOReader, reader, "With an pseudo IO.") + file.close + end + + def test_IOReader_s_create_binmode + file = File.open(@outfile, "wb") + file << "\"\r\n\",\"\r\",\"\n\"\r1,2,3" + file.close + + file = File.open(@outfile, "rb") + begin + reader = CSV::IOReader.new(file, ?,, ?\r) + assert_equal(["\r\n", "\r", "\n"], reader.shift.to_a) + assert_equal(["1", "2", "3"], reader.shift.to_a) + reader.close + ensure + file.close + end + + file = File.open(@outfile, "r") # not "rb" + begin + lfincell = (RSEP == "\n" ? "\r\n" : "\n") + reader = CSV::IOReader.new(file, ?,, ?\r) + assert_equal([lfincell, "\r", "\n"], reader.shift.to_a) + assert_equal(["1", "2", "3"], reader.shift.to_a) + reader.close + ensure + file.close + end + end + + def test_Reader_s_parse + ret = CSV::Reader.parse("a,b,c") { |row| + assert_instance_of(Array, row, "Block parameter") + } + assert_nil(ret, "Return is nil") + + ret = CSV::Reader.parse("a;b;c", ?;) { |row| + assert_instance_of(Array, row, "Block parameter") + } + + file = Tempfile.new("in.csv") + file << "a,b,c" + file.open + ret = CSV::Reader.parse(file) { |row| + assert_instance_of(Array, row, "Block parameter") + } + assert_nil(ret, "Return is nil") + + file = Tempfile.new("in.csv") + file << "a,b,c" + file.open + ret = CSV::Reader.parse(file, ?,) { |row| + assert_instance_of(Array, row, "Block parameter") + } + + # Illegal format. + assert_raises(CSV::IllegalFormatError) do + CSV::Reader.parse("a,b\r\na,b,\"c\"\ra") do |row| + end + end + + assert_raises(CSV::IllegalFormatError) do + CSV::Reader.parse("a,b\r\na,b\"") do |row| + end + end + end + + + #### CSV::Writer unit test + + def test_Writer_s_new + assert_raises(RuntimeError) do + CSV::Writer.new(nil) + end + end + + def test_Writer_s_generate + ret = CSV::Writer.generate(STDOUT) { |writer| + assert_instance_of(CSV::BasicWriter, writer, "Block parameter") + } + + ret = CSV::Writer.generate(STDOUT, ?;) { |writer| + assert_instance_of(CSV::BasicWriter, writer, "Block parameter") + } + + assert_nil(ret, "Return is nil") + end + + def test_Writer_s_create + writer = CSV::Writer.create(STDERR) + assert_instance_of(CSV::BasicWriter, writer, "String") + + writer = CSV::Writer.create(STDERR, ?;) + assert_instance_of(CSV::BasicWriter, writer, "String") + + writer = CSV::Writer.create(Tempfile.new("out.csv")) + assert_instance_of(CSV::BasicWriter, writer, "IO") + end + + def test_Writer_LSHIFT # '<<' + file = Tempfile.new("out.csv") + CSV::Writer.generate(file) do |writer| + ret = writer << ['a', 'b', 'c'] + assert_instance_of(CSV::BasicWriter, ret, 'Return is self') + + writer << [nil, 'e', 'f'] << [nil, nil, ''] + end + file.open + file.binmode + str = file.read + assert_equal("a,b,c#{RSEP},e,f#{RSEP},,\"\"#{RSEP}", str, 'Normal') + + file = Tempfile.new("out2.csv") + CSV::Writer.generate(file) do |writer| + ret = writer << [d('a'), d('b'), d('c')] + assert_instance_of(CSV::BasicWriter, ret, 'Return is self') + + writer << [d(nil), d('e'), d('f')] << [d(nil), d(nil), d('')] + end + file.open + file.binmode + str = file.read + assert_equal("a,b,c#{RSEP},e,f#{RSEP},,\"\"#{RSEP}", str, 'Normal') + end + + def test_Writer_add_row + file = Tempfile.new("out.csv") + CSV::Writer.generate(file) do |writer| + ret = writer.add_row( + [d('a'), d('b'), d('c')]) + assert_instance_of(CSV::BasicWriter, ret, 'Return is self') + + writer.add_row( + [d(nil), d('e'), d('f')] + ).add_row( + [d(nil), d(nil), d('')] + ) + end + file.open + file.binmode + str = file.read + assert_equal("a,b,c#{RSEP},e,f#{RSEP},,\"\"#{RSEP}", str, 'Normal') + end + + def test_Writer_close + f = File.open(@outfile, "w") + writer = CSV::BasicWriter.create(f) + writer.close_on_terminate + writer.close + assert(f.closed?) + end + + def test_BasicWriter_close_on_terminate + f = File.open(@outfile, "w") + writer = CSV::BasicWriter.create(f) + writer.close + assert(!f.closed?) + f.close + + f = File.open(@outfile, "w") + writer = CSV::BasicWriter.new(f) + writer.close_on_terminate + writer.close + assert(f.closed?) + end + + def test_BasicWriter_s_create_binmode + file = File.open(@outfile, "w") # not "wb" + begin + writer = CSV::BasicWriter.new(file, ?,, ?\r) + writer << ["\r\n", "\r", "\n"] + writer << ["1", "2", "3"] + writer.close + ensure + file.close + end + + file = File.open(@outfile, "rb") + str = file.read + file.close + assert_equal("\"\r#{RSEP}\",\"\r\",\"#{RSEP}\"\r1,2,3\r", str) + end + + #### CSV unit test + + def test_s_open_reader + assert_raises(ArgumentError, 'Illegal mode') do + CSV.open("temp", "a") + end + + assert_raises(ArgumentError, 'Illegal mode') do + CSV.open("temp", "a", ?;) + end + + reader = CSV.open(@infile, "r") + assert_instance_of(CSV::IOReader, reader) + reader.close + + reader = CSV.open(@infile, "rb") + assert_instance_of(CSV::IOReader, reader) + reader.close + + reader = CSV.open(@infile, "r", ?;) + assert_instance_of(CSV::IOReader, reader) + reader.close + + CSV.open(@infile, "r") do |row| + assert_instance_of(Array, row) + break + end + + CSV.open(@infiletsv, "r", ?\t) do |row| + assert_instance_of(Array, row) + break + end + + assert_raises(Errno::ENOENT) do + CSV.open("NoSuchFileOrDirectory", "r") + end + + assert_raises(Errno::ENOENT) do + CSV.open("NoSuchFileOrDirectory", "r", ?;) + end + + # Illegal format. + File.open(@outfile, "wb") do |f| + f << "a,b\r\na,b,\"c\"\ra" + end + assert_raises(CSV::IllegalFormatError) do + CSV.open(@outfile, "r") do |row| + end + end + + File.open(@outfile, "wb") do |f| + f << "a,b\r\na,b\"" + end + assert_raises(CSV::IllegalFormatError) do + CSV.open(@outfile, "r") do |row| + end + end + + CSV.open(@emptyfile, "r") do |row| + assert_fail("Must not reach here") + end + end + + def test_s_parse + result = CSV.parse(File.read(@infile)) + assert_instance_of(Array, result) + assert_instance_of(Array, result[0]) + + result = CSV.parse(File.read(@infile)) + assert_instance_of(Array, result) + assert_instance_of(Array, result[0]) + + assert_equal([], CSV.parse("")) + assert_equal([[nil]], CSV.parse("\n")) + + CSV.parse(File.read(@infile)) do |row| + assert_instance_of(Array, row) + break + end + + CSV.parse(File.read(@infiletsv), ?\t) do |row| + assert_instance_of(Array, row) + break + end + + CSV.parse("") do |row| + assert(false) + end + + count = 0 + CSV.parse("\n") do |row| + assert_equal([nil], row) + count += 1 + end + assert_equal(1, count) + + assert_equal([["a|b-c|d"]], CSV.parse("a|b-c|d")) + assert_equal([["a", "b"], ["c", "d"]], CSV.parse("a|b-c|d", "|", "-")) + end + + def test_s_open_writer + writer = CSV.open(@outfile, "w") + assert_instance_of(CSV::BasicWriter, writer) + writer.close + + writer = CSV.open(@outfile, "wb") + assert_instance_of(CSV::BasicWriter, writer) + writer.close + + writer = CSV.open(@outfile, "wb", ?;) + assert_instance_of(CSV::BasicWriter, writer) + writer.close + + CSV.open(@outfile, "w") do |writer| + assert_instance_of(CSV::BasicWriter, writer) + end + + CSV.open(@outfile, "w", ?;) do |writer| + assert_instance_of(CSV::BasicWriter, writer) + end + + begin + CSV.open(@tmpdir, "w") + assert(false) + rescue Exception => ex + assert(ex.is_a?(Errno::EEXIST) || ex.is_a?(Errno::EISDIR) || ex.is_a?(Errno::EACCES)) + end + end + + def test_s_generate + writer = CSV.generate(@outfile) + assert_instance_of(CSV::BasicWriter, writer) + writer.close + + writer = CSV.generate(@outfile, ?;) + assert_instance_of(CSV::BasicWriter, writer) + writer.close + + CSV.generate(@outfile) do |writer| + assert_instance_of(CSV::BasicWriter, writer) + end + + CSV.generate(@outfile, ?;) do |writer| + assert_instance_of(CSV::BasicWriter, writer) + end + + begin + CSV.generate(@tmpdir) + assert(false) + rescue Exception => ex + assert(ex.is_a?(Errno::EEXIST) || ex.is_a?(Errno::EISDIR) || ex.is_a?(Errno::EACCES)) + end + end + + def test_s_generate_line + str = CSV.generate_line([]) + assert_equal('', str, "Extra boundary check.") + + str = CSV.generate_line([], ?;) + assert_equal('', str, "Extra boundary check.") + + @@simpleCSVData.each do |col, str| + buf = CSV.generate_line(col) + assert_equal(str, buf) + end + + @@simpleCSVData.each do |col, str| + buf = CSV.generate_line(col, ?;) + assert_equal(str + "\n", ssv2csv(buf)) + end + + @@simpleCSVData.each do |col, str| + buf = CSV.generate_line(col, ?\t) + assert_equal(str + "\n", tsv2csv(buf)) + end + + str = CSV.generate_line(['a', 'b'], nil, ?|) + assert_equal('a,b', str) + + str = CSV.generate_line(['a', 'b'], nil, "a") + assert_equal('"a",b', str) + end + + def test_s_generate_row + buf = '' + cols = CSV.generate_row([], 0, buf) + assert_equal(0, cols) + assert_equal("\n", buf, "Extra boundary check.") + + buf = '' + cols = CSV.generate_row([], 0, buf, ?;) + assert_equal(0, cols) + assert_equal("\n", buf, "Extra boundary check.") + + buf = '' + cols = CSV.generate_row([], 0, buf, ?\t) + assert_equal(0, cols) + assert_equal("\n", buf, "Extra boundary check.") + + buf = '' + cols = CSV.generate_row([], 0, buf, ?\t, ?|) + assert_equal(0, cols) + assert_equal("|", buf, "Extra boundary check.") + + buf = '' + cols = CSV.generate_row([d('1')], 2, buf) + assert_equal('1,', buf) + + buf = '' + cols = CSV.generate_row([d('1')], 2, buf, ?;) + assert_equal('1;', buf) + + buf = '' + cols = CSV.generate_row([d('1')], 2, buf, ?\t) + assert_equal("1\t", buf) + + buf = '' + cols = CSV.generate_row([d('1')], 2, buf, ?\t, ?|) + assert_equal("1\t", buf) + + buf = '' + cols = CSV.generate_row([d('1'), d('2')], 1, buf) + assert_equal("1\n", buf) + + buf = '' + cols = CSV.generate_row([d('1'), d('2')], 1, buf, ?;) + assert_equal("1\n", buf) + + buf = '' + cols = CSV.generate_row([d('1'), d('2')], 1, buf, ?\t) + assert_equal("1\n", buf) + + buf = '' + cols = CSV.generate_row([d('1'), d('2')], 1, buf, ?\t, ?\n) + assert_equal("1\n", buf) + + buf = '' + cols = CSV.generate_row([d('1'), d('2')], 1, buf, ?\t, ?\r) + assert_equal("1\r", buf) + + buf = '' + cols = CSV.generate_row([d('1'), d('2')], 1, buf, ?\t, ?|) + assert_equal("1|", buf) + + @@fullCSVData.each do |col, str| + buf = '' + cols = CSV.generate_row(col, col.size, buf) + assert_equal(col.size, cols) + assert_equal(str + "\n", buf) + end + + @@fullCSVData.each do |col, str| + buf = '' + cols = CSV.generate_row(col, col.size, buf, ?;) + assert_equal(col.size, cols) + assert_equal(str + "\n", ssv2csv(buf)) + end + + @@fullCSVData.each do |col, str| + buf = '' + cols = CSV.generate_row(col, col.size, buf, ?\t) + assert_equal(col.size, cols) + assert_equal(str + "\n", tsv2csv(buf)) + end + + # row separator + @@fullCSVData.each do |col, str| + buf = '' + cols = CSV.generate_row(col, col.size, buf, ?,, ?|) + assert_equal(col.size, cols) + assert_equal(str + "|", buf) + end + + # col and row separator + @@fullCSVData.each do |col, str| + buf = '' + cols = CSV.generate_row(col, col.size, buf, ?\t, ?|) + assert_equal(col.size, cols) + assert_equal(str + "|", tsv2csv(buf, ?|)) + end + + buf = '' + toBe = '' + cols = 0 + colsToBe = 0 + @@fullCSVData.each do |col, str| + cols += CSV.generate_row(col, col.size, buf) + toBe << str << "\n" + colsToBe += col.size + end + assert_equal(colsToBe, cols) + assert_equal(toBe, buf) + + buf = '' + toBe = '' + cols = 0 + colsToBe = 0 + @@fullCSVData.each do |col, str| + lineBuf = '' + cols += CSV.generate_row(col, col.size, lineBuf, ?;) + buf << ssv2csv(lineBuf) << "\n" + toBe << ssv2csv(lineBuf) << "\n" + colsToBe += col.size + end + assert_equal(colsToBe, cols) + assert_equal(toBe, buf) + + buf = '' + toBe = '' + cols = 0 + colsToBe = 0 + @@fullCSVData.each do |col, str| + lineBuf = '' + cols += CSV.generate_row(col, col.size, lineBuf, ?\t) + buf << tsv2csv(lineBuf) << "\n" + toBe << tsv2csv(lineBuf) << "\n" + colsToBe += col.size + end + assert_equal(colsToBe, cols) + assert_equal(toBe, buf) + + buf = '' + toBe = '' + cols = 0 + colsToBe = 0 + @@fullCSVData.each do |col, str| + lineBuf = '' + cols += CSV.generate_row(col, col.size, lineBuf, ?|) + buf << tsv2csv(lineBuf, ?|) + toBe << tsv2csv(lineBuf, ?|) + colsToBe += col.size + end + assert_equal(colsToBe, cols) + assert_equal(toBe, buf) + end + + def test_s_parse_line + @@simpleCSVData.each do |col, str| + row = CSV.parse_line(str) + assert_instance_of(Array, row) + assert_equal(col.size, row.size) + assert_equal(col, row) + end + + @@simpleCSVData.each do |col, str| + str = csv2ssv(str) + row = CSV.parse_line(str, ?;) + assert_instance_of(Array, row) + assert_equal(col.size, row.size, str.inspect) + assert_equal(col, row, str.inspect) + end + + @@simpleCSVData.each do |col, str| + str = csv2tsv(str) + row = CSV.parse_line(str, ?\t) + assert_instance_of(Array, row) + assert_equal(col.size, row.size) + assert_equal(col, row) + end + + assert_equal(['a', 'b', 'c'], CSV.parse_line("a,b,c", nil, nil)) + assert_equal(['a', nil], CSV.parse_line("a,b,c", nil, ?b)) + assert_equal(['a', 'b', nil], CSV.parse_line("a,b,c", nil, "c")) + assert_equal([nil], CSV.parse_line("")) + assert_equal([nil], CSV.parse_line("\n")) + assert_equal([""], CSV.parse_line("\"\"\n")) + + # Illegal format. + buf = [] + row = CSV.parse_line("a,b,\"c\"\ra") + assert_instance_of(Array, row) + assert_equal(0, row.size) + + buf = Array.new + row = CSV.parse_line("a;b;\"c\"\ra", ?;) + assert_instance_of(Array, row) + assert_equal(0, row.size) + + buf = Array.new + row = CSV.parse_line("a\tb\t\"c\"\ra", ?\t) + assert_instance_of(Array, row) + assert_equal(0, row.size) + + row = CSV.parse_line("a,b\"") + assert_instance_of(Array, row) + assert_equal(0, row.size) + + row = CSV.parse_line("a;b\"", ?;) + assert_instance_of(Array, row) + assert_equal(0, row.size) + + row = CSV.parse_line("a\tb\"", ?\t) + assert_instance_of(Array, row) + assert_equal(0, row.size) + + row = CSV.parse_line("\"a,b\"\r,") + assert_instance_of(Array, row) + assert_equal(0, row.size) + + row = CSV.parse_line("\"a;b\"\r;", ?;) + assert_instance_of(Array, row) + assert_equal(0, row.size) + + row = CSV.parse_line("\"a\tb\"\r\t", ?\t) + assert_instance_of(Array, row) + assert_equal(0, row.size) + + row = CSV.parse_line("\"a,b\"\r\"") + assert_instance_of(Array, row) + assert_equal(0, row.size) + + row = CSV.parse_line("\"a;b\"\r\"", ?;) + assert_instance_of(Array, row) + assert_equal(0, row.size) + + row = CSV.parse_line("\"a\tb\"\r\"", ?\t) + assert_instance_of(Array, row) + assert_equal(0, row.size) + end + + def test_s_parse_row + @@fullCSVData.each do |col, str| + buf = Array.new + cols, idx = CSV.parse_row(str + "\r\n", 0, buf) + assert_equal(cols, buf.size, "Reported size.") + assert_equal(col.size, buf.size, "Size.") + assert_equal(col, buf, str.inspect) + + buf = Array.new + cols, idx = CSV.parse_row(str + "\n", 0, buf, ?,, ?\n) + assert_equal(cols, buf.size, "Reported size.") + assert_equal(col.size, buf.size, "Size.") + assert_equal(col, buf, str.inspect) + + # separator: | + buf = Array.new + cols, idx = CSV.parse_row(str + "|", 0, buf, ?,) + assert_not_equal(col, buf) + buf = Array.new + cols, idx = CSV.parse_row(str + "|", 0, buf, ?,, ?|) + assert_equal(cols, buf.size, "Reported size.") + assert_equal(col.size, buf.size, "Size.") + assert_equal(col, buf, str.inspect) + end + + @@fullCSVData.each do |col, str| + str = csv2ssv(str) + buf = Array.new + cols, idx = CSV.parse_row(str + "\r\n", 0, buf, ?;) + assert_equal(cols, buf.size, "Reported size.") + assert_equal(col.size, buf.size, "Size.") + assert_equal(col, buf, str) + end + + @@fullCSVData.each do |col, str| + str = csv2tsv(str) + buf = Array.new + cols, idx = CSV.parse_row(str + "\r\n", 0, buf, ?\t) + assert_equal(cols, buf.size, "Reported size.") + assert_equal(col.size, buf.size, "Size.") + assert_equal(col, buf, str) + end + + @@fullCSVData.each do |col, str| + str = csv2tsv(str, ?|) + buf = Array.new + cols, idx = CSV.parse_row(str + "|", 0, buf, ?\t, ?|) + assert_equal(cols, buf.size, "Reported size.") + assert_equal(col.size, buf.size, "Size.") + assert_equal(col, buf, str) + end + + buf = [] + CSV.parse_row("a,b,c", 0, buf, nil, nil) + assert_equal(['a', 'b', 'c'], buf) + + buf = [] + CSV.parse_row("a,b,c", 0, buf, nil, ?b) + assert_equal(['a', nil], buf) + + buf = [] + CSV.parse_row("a,b,c", 0, buf, nil, "c") + assert_equal(['a', 'b', nil], buf) + + buf = Array.new + cols, idx = CSV.parse_row("a,b,\"c\r\"", 0, buf) + assert_equal(["a", "b", "c\r"], buf.to_a) + + buf = Array.new + cols, idx = CSV.parse_row("a;b;\"c\r\"", 0, buf, ?;) + assert_equal(["a", "b", "c\r"], buf.to_a) + + buf = Array.new + cols, idx = CSV.parse_row("a\tb\t\"c\r\"", 0, buf, ?\t) + assert_equal(["a", "b", "c\r"], buf.to_a) + + buf = Array.new + cols, idx = CSV.parse_row("a,b,c\n", 0, buf, ?,, ?\n) + assert_equal(["a", "b", "c"], buf.to_a) + + buf = Array.new + cols, idx = CSV.parse_row("a\tb\tc\n", 0, buf, ?\t, ?\n) + assert_equal(["a", "b", "c"], buf.to_a) + + # Illegal format. + buf = Array.new + cols, idx = CSV.parse_row("a,b,c\"", 0, buf) + assert_equal(0, cols, "Illegal format; unbalanced double-quote.") + + buf = Array.new + cols, idx = CSV.parse_row("a;b;c\"", 0, buf, ?;) + assert_equal(0, cols, "Illegal format; unbalanced double-quote.") + + buf = Array.new + cols, idx = CSV.parse_row("a,b,\"c\"\ra", 0, buf) + assert_equal(0, cols) + assert_equal(0, idx) + + buf = Array.new + cols, idx = CSV.parse_row("a,b,\"c\"\ra", 0, buf, ?;) + assert_equal(0, cols) + assert_equal(0, idx) + + buf = Array.new + cols, idx = CSV.parse_row("a,b\"", 0, buf) + assert_equal(0, cols) + assert_equal(0, idx) + + buf = Array.new + cols, idx = CSV.parse_row("a;b\"", 0, buf, ?;) + assert_equal(0, cols) + assert_equal(0, idx) + + buf = Array.new + cols, idx = CSV.parse_row("\"a,b\"\r,", 0, buf) + assert_equal(0, cols) + assert_equal(0, idx) + + buf = Array.new + cols, idx = CSV.parse_row("a\r,", 0, buf) + assert_equal(0, cols) + assert_equal(0, idx) + + buf = Array.new + cols, idx = CSV.parse_row("a\r", 0, buf) + assert_equal(0, cols) + assert_equal(0, idx) + + buf = Array.new + cols, idx = CSV.parse_row("a\rbc", 0, buf) + assert_equal(0, cols) + assert_equal(0, idx) + + buf = Array.new + cols, idx = CSV.parse_row("a\r\"\"", 0, buf) + assert_equal(0, cols) + assert_equal(0, idx) + + buf = Array.new + cols, idx = CSV.parse_row("a\r\rabc,", 0, buf) + assert_equal(0, cols) + assert_equal(0, idx) + + buf = Array.new + cols, idx = CSV.parse_row("\"a;b\"\r;", 0, buf, ?;) + assert_equal(0, cols) + assert_equal(0, idx) + + buf = Array.new + cols, idx = CSV.parse_row("\"a,b\"\r\"", 0, buf) + assert_equal(0, cols) + assert_equal(0, idx) + + buf = Array.new + cols, idx = CSV.parse_row("\"a;b\"\r\"", 0, buf, ?;) + assert_equal(0, cols) + assert_equal(0, idx) + end + + def test_s_parse_rowEOF + @@fullCSVData.each do |col, str| + if str == '' + # String "" is not allowed. + next + end + buf = Array.new + cols, idx = CSV.parse_row(str, 0, buf) + assert_equal(col.size, cols, "Reported size.") + assert_equal(col.size, buf.size, "Size.") + assert_equal(col, buf) + end + end + + def test_s_parse_rowConcat + buf = '' + toBe = [] + @@fullCSVData.each do |col, str| + buf << str << "\r\n" + toBe.concat(col) + end + idx = 0 + cols = 0 + parsed = Array.new + parsedCols = 0 + begin + cols, idx = CSV.parse_row(buf, idx, parsed) + parsedCols += cols + end while cols > 0 + assert_equal(toBe.size, parsedCols) + assert_equal(toBe.size, parsed.size) + assert_equal(toBe, parsed) + + buf = '' + toBe = [] + @@fullCSVData.each do |col, str| + buf << str << "\n" + toBe.concat(col) + end + idx = 0 + cols = 0 + parsed = Array.new + parsedCols = 0 + begin + cols, idx = CSV.parse_row(buf, idx, parsed, ?,, ?\n) + parsedCols += cols + end while cols > 0 + assert_equal(toBe.size, parsedCols) + assert_equal(toBe.size, parsed.size) + assert_equal(toBe, parsed) + + buf = '' + toBe = [] + @@fullCSVData.sort { |a, b| + a[0].length <=> b[0].length + }.each do |col, str| + buf << str << "\n" + toBe.concat(col) + end + idx = 0 + cols = 0 + parsed = Array.new + parsedCols = 0 + begin + cols, idx = CSV.parse_row(buf, idx, parsed, ?,, ?\n) + parsedCols += cols + end while cols > 0 + assert_equal(toBe.size, parsedCols) + assert_equal(toBe.size, parsed.size) + assert_equal(toBe, parsed) + + buf = '' + toBe = [] + @@fullCSVData.each do |col, str| + buf << str << "|" + toBe.concat(col) + end + idx = 0 + cols = 0 + parsed = [] + parsedCols = 0 + begin + cols, idx = CSV.parse_row(buf, idx, parsed, ?,, ?|) + parsedCols += cols + end while cols > 0 + assert_equal(toBe.size, parsedCols) + assert_equal(toBe.size, parsed.size) + assert_equal(toBe, parsed) + end + + def test_utf8 + rows = [] + CSV.open(@bomfile, "r") do |row| + rows << row.to_a + end + assert_equal([["foo"], ["bar"]], rows) + + rows = [] + file = File.open(@bomfile) + CSV::Reader.parse(file) do |row| + rows << row.to_a + end + assert_equal([["foo"], ["bar"]], rows) + file.close + end + + def test_macCR + rows = [] + CSV.open(@macfile, "r", ?,, ?\r) do |row| + rows << row.to_a + end + assert_equal([["Avenches", "aus Umgebung"], ["Bad Hersfeld", "Ausgrabung"]], rows) + + rows = [] + assert_raises(CSV::IllegalFormatError) do + CSV.open(@macfile, "r") do |row| + rows << row.to_a + end + assert_equal([["Avenches", "aus Umgebung\r\"Bad Hersfeld", "Ausgrabung"]], rows) + end + + rows = [] + file = File.open(@macfile) + begin + CSV::Reader.parse(file, ?,, ?\r) do |row| + rows << row.to_a + end + assert_equal([["Avenches", "aus Umgebung"], ["Bad Hersfeld", "Ausgrabung"]], rows) + ensure + file.close + end + + rows = [] + file = File.open(@macfile) + begin + assert_raises(CSV::IllegalFormatError) do + CSV::Reader.parse(file, ?,) do |row| + rows << row.to_a + end + assert_equal([["Avenches", "aus Umgebung\r\"Bad Hersfeld", "Ausgrabung"]], rows) + end + ensure + file.close + end + end + + + #### CSV unit test + + InputStreamPattern = '0123456789' + InputStreamPatternSize = InputStreamPattern.size + def expChar(idx) + InputStreamPattern[idx % InputStreamPatternSize] + end + + def expStr(idx, n) + if n > InputStreamPatternSize + InputStreamPattern + expStr(0, n - InputStreamPatternSize) + else + InputStreamPattern[idx % InputStreamPatternSize, n] + end + end + + def setupInputStream(size, bufSize = nil) + setBufSize(bufSize) if bufSize + m = ((size / InputStreamPatternSize) + 1).to_i + File.open(@outfile, "wb") do |f| + f << (InputStreamPattern * m)[0, size] + end + file = File.open(@outfile, "rb") + buf = CSV::IOBuf.new(file) + if block_given? + yield(buf) + file.close + nil + else + buf + end + end + + def setBufSize(size) + CSV::StreamBuf.module_eval('remove_const("BufSize")') + CSV::StreamBuf.module_eval("BufSize = #{ size }") + end + + class StrBuf < CSV::StreamBuf + private + def initialize(string) + @str = string + @idx = 0 + super() + end + + def read(size) + str = @str[@idx, size] + if str.empty? + nil + else + @idx += str.size + str + end + end + end + + class ErrBuf < CSV::StreamBuf + class Error < RuntimeError; end + private + def initialize + @first = true + super() + end + + def read(size) + if @first + @first = false + "a" * size + else + raise ErrBuf::Error.new + end + end + end + + def test_StreamBuf_MyBuf + # At first, check ruby's behaviour. + s = "abc" + assert_equal(?a, s[0]) + assert_equal(?b, s[1]) + assert_equal(?c, s[2]) + assert_equal(nil, s[3]) + assert_equal("a", s[0, 1]) + assert_equal("b", s[1, 1]) + assert_equal("c", s[2, 1]) + assert_equal("", s[3, 1]) + assert_equal(nil, s[4, 1]) + + s = StrBuf.new("abc") + assert_equal(?a, s[0]) + assert_equal(?b, s.get(1)) + assert_equal(?c, s[2]) + assert_equal(nil, s.get(3)) + assert_equal("a", s[0, 1]) + assert_equal("b", s.get(1, 1)) + assert_equal("c", s[2, 1]) + assert_equal("", s.get(3, 1)) + assert_equal(nil, s[4, 1]) + + dropped = s.drop(1) + assert_equal(1, dropped) + assert_equal(?b, s[0]) + assert(!s.is_eos?) + dropped = s.drop(1) + assert_equal(1, dropped) + assert_equal(?c, s[0]) + assert(!s.is_eos?) + dropped = s.drop(1) + assert_equal(1, dropped) + assert_equal(nil, s[0]) + assert(s.is_eos?) + dropped = s.drop(1) + assert_equal(0, dropped) + assert_equal(nil, s[0]) + assert(s.is_eos?) + + s = StrBuf.new("") + assert_equal(nil, s[0]) + + s = StrBuf.new("") + dropped = s.drop(1) + assert_equal(0, dropped) + + assert_raises(TestCSV::ErrBuf::Error) do + s = ErrBuf.new + s[1024] + end + + assert_raises(TestCSV::ErrBuf::Error) do + s = ErrBuf.new + s.drop(1024) + end + end + + def test_StreamBuf_AREF # '[idx]' + setupInputStream(22, 1024) do |s| + [0, 1, 9, 10, 19, 20, 21].each do |idx| + assert_equal(expChar(idx), s[idx], idx.to_s) + end + [22, 23].each do |idx| + assert_equal(nil, s[idx], idx.to_s) + end + assert_equal(nil, s[-1]) + end + + setupInputStream(22, 1) do |s| + [0, 1, 9, 10, 19, 20, 21].each do |idx| + assert_equal(expChar(idx), s[idx], idx.to_s) + end + [22, 23].each do |idx| + assert_equal(nil, s[idx], idx.to_s) + end + end + + setupInputStream(1024, 1) do |s| + [1023, 0].each do |idx| + assert_equal(expChar(idx), s[idx], idx.to_s) + end + [1024, 1025].each do |idx| + assert_equal(nil, s[idx], idx.to_s) + end + end + + setupInputStream(1, 1) do |s| + [0].each do |idx| + assert_equal(expChar(idx), s[idx], idx.to_s) + end + [1, 2].each do |idx| + assert_equal(nil, s[idx], idx.to_s) + end + end + end + + def test_StreamBuf_AREF_n # '[idx, n]' + # At first, check ruby's behaviour. + assert_equal("", "abc"[3, 1]) + assert_equal(nil, "abc"[4, 1]) + + setupInputStream(22, 1024) do |s| + [0, 1, 9, 10, 19, 20, 21].each do |idx| + assert_equal(expStr(idx, 1), s[idx, 1], idx.to_s) + end + assert_equal("", s[22, 1]) + assert_equal(nil, s[23, 1]) + end + + setupInputStream(22, 1) do |s| + [0, 1, 9, 10, 19, 20, 21].each do |idx| + assert_equal(expStr(idx, 1), s[idx, 1], idx.to_s) + end + assert_equal("", s[22, 1]) + assert_equal(nil, s[23, 1]) + end + + setupInputStream(1024, 1) do |s| + [1023, 0].each do |idx| + assert_equal(expStr(idx, 1), s[idx, 1], idx.to_s) + end + assert_equal("", s[1024, 1]) + assert_equal(nil, s[1025, 1]) + end + + setupInputStream(1, 1) do |s| + [0].each do |idx| + assert_equal(expStr(idx, 1), s[idx, 1], idx.to_s) + end + assert_equal("", s[1, 1]) + assert_equal(nil, s[2, 1]) + end + + setupInputStream(22, 11) do |s| + [0, 1, 10, 11, 20].each do |idx| + assert_equal(expStr(idx, 2), s[idx, 2], idx.to_s) + end + assert_equal(expStr(21, 1), s[21, 2]) + + assert_equal(expStr(0, 12), s[0, 12]) + assert_equal(expStr(10, 12), s[10, 12]) + assert_equal(expStr(10, 12), s[10, 13]) + assert_equal(expStr(10, 12), s[10, 14]) + assert_equal(expStr(10, 12), s[10, 1024]) + + assert_equal(nil, s[0, -1]) + assert_equal(nil, s[21, -1]) + + assert_equal(nil, s[-1, 10]) + assert_equal(nil, s[-1, -1]) + end + end + + def test_StreamBuf_get + setupInputStream(22, 1024) do |s| + [0, 1, 9, 10, 19, 20, 21].each do |idx| + assert_equal(expChar(idx), s.get(idx), idx.to_s) + end + [22, 23].each do |idx| + assert_equal(nil, s.get(idx), idx.to_s) + end + assert_equal(nil, s.get(-1)) + end + end + + def test_StreamBuf_get_n + setupInputStream(22, 1024) do |s| + [0, 1, 9, 10, 19, 20, 21].each do |idx| + assert_equal(expStr(idx, 1), s.get(idx, 1), idx.to_s) + end + assert_equal("", s.get(22, 1)) + assert_equal(nil, s.get(23, 1)) + + assert_equal(nil, s.get(-1, 1)) + assert_equal(nil, s.get(-1, -1)) + end + end + + def test_StreamBuf_drop + setupInputStream(22, 1024) do |s| + assert_equal(expChar(0), s[0]) + assert_equal(expChar(21), s[21]) + assert_equal(nil, s[22]) + + dropped = s.drop(-1) + assert_equal(0, dropped) + assert_equal(expChar(0), s[0]) + + dropped = s.drop(0) + assert_equal(0, dropped) + assert_equal(expChar(0), s[0]) + + dropped = s.drop(1) + assert_equal(1, dropped) + assert_equal(expChar(1), s[0]) + assert_equal(expChar(2), s[1]) + + dropped = s.drop(1) + assert_equal(1, dropped) + assert_equal(expChar(2), s[0]) + assert_equal(expChar(3), s[1]) + end + + setupInputStream(4, 2) do |s| + dropped = s.drop(2) + assert_equal(2, dropped) + assert_equal(expChar(2), s[0]) + assert_equal(expChar(3), s[1]) + dropped = s.drop(1) + assert_equal(1, dropped) + assert_equal(expChar(3), s[0]) + assert_equal(nil, s[1]) + dropped = s.drop(1) + assert_equal(1, dropped) + assert_equal(nil, s[0]) + assert_equal(nil, s[1]) + dropped = s.drop(0) + assert_equal(0, dropped) + assert_equal(nil, s[0]) + assert_equal(nil, s[1]) + end + + setupInputStream(6, 3) do |s| + dropped = s.drop(2) + assert_equal(2, dropped) + dropped = s.drop(2) + assert_equal(2, dropped) + assert_equal(expChar(4), s[0]) + assert_equal(expChar(5), s[1]) + dropped = s.drop(3) + assert_equal(2, dropped) + assert_equal(nil, s[0]) + assert_equal(nil, s[1]) + end + end + + def test_StreamBuf_is_eos? + setupInputStream(3, 1024) do |s| + assert(!s.is_eos?) + s.drop(1) + assert(!s.is_eos?) + s.drop(1) + assert(!s.is_eos?) + s.drop(1) + assert(s.is_eos?) + s.drop(1) + assert(s.is_eos?) + end + + setupInputStream(3, 2) do |s| + assert(!s.is_eos?) + s.drop(1) + assert(!s.is_eos?) + s.drop(1) + assert(!s.is_eos?) + s.drop(1) + assert(s.is_eos?) + s.drop(1) + assert(s.is_eos?) + end + end + + def test_StreamBuf_s_new + # NotImplementedError should be raised from StreamBuf#read. + assert_raises(NotImplementedError) do + CSV::StreamBuf.new + end + end + + def test_IOBuf_close + f = File.open(@outfile, "wb") + f << "tst" + f.close + + f = File.open(@outfile, "rb") + iobuf = CSV::IOBuf.new(f) + iobuf.close + assert(true) # iobuf.close does not raise any exception. + f.close + end + + def test_IOBuf_s_new + iobuf = CSV::IOBuf.new(Tempfile.new("in.csv")) + assert_instance_of(CSV::IOBuf, iobuf) + end + + + #### CSV functional test + + # sample data + # + # 1 2 3 4 5 6 7 8 + # +------+-------+---------+-------+--------+------+----+------+ + # | foo | "foo" | foo,bar | "" |(empty) |(null)| \r | \r\n | + # +------+-------+---------+-------+--------+------+----+------+ + # | NaHi | "Na" | Na,Hi | \r.\n | \r\n\n | " | \n | \r\n | + # +------+-------+---------+-------+--------+------+----+------+ + # + def test_s_parseAndCreate + colSize = 8 + csvStr = "foo,!!!foo!!!,!foo,bar!,!!!!!!,!!,,!\r!,!\r\n!\nNaHi,!!!Na!!!,!Na,Hi!,!\r.\n!,!\r\n\n!,!!!!,!\n!,!\r\n!".gsub!('!', '"') + csvStrTerminated = csvStr + "\n" + + myStr = csvStr.dup + res1 = []; res2 = [] + idx = 0 + col, idx = CSV::parse_row(myStr, 0, res1) + col, idx = CSV::parse_row(myStr, idx, res2) + + buf = '' + col = CSV::generate_row(res1, colSize, buf) + col = CSV::generate_row(res2, colSize, buf) + assert_equal(csvStrTerminated, buf) + + parsed = [] + CSV::Reader.parse(csvStrTerminated) do |row| + parsed << row + end + + buf = '' + CSV::Writer.generate(buf) do |writer| + parsed.each do |row| + writer.add_row(row) + end + end + assert_equal(csvStrTerminated, buf) + + buf = '' + CSV::Writer.generate(buf) do |writer| + parsed.each do |row| + writer << row + end + end + assert_equal(csvStrTerminated, buf) + end + + def test_writer_fs_rs_generate + buf = '' + CSV::Writer.generate(buf, ",,") do |writer| + writer << [] + end + assert_equal("\n", buf) + + buf = '' + CSV::Writer.generate(buf, ",,") do |writer| + writer << [] << [] + end + assert_equal("\n\n", buf) + + buf = '' + CSV::Writer.generate(buf, ",,") do |writer| + writer << [1] + end + assert_equal("1\n", buf) + + buf = '' + CSV::Writer.generate(buf, ",,") do |writer| + writer << [1, 2, 3] + writer << [4, ",,", 5] + end + assert_equal("1,,2,,3\n4,,\",,\",,5\n", buf) + + buf = '' + CSV::Writer.generate(buf, ",,:", ",,;") do |writer| + writer << [nil, nil, nil] + writer << [nil, ",,", nil] + end + assert_equal(",,:,,:,,;,,:,,,,:,,;", buf) + + buf = '' + CSV::Writer.generate(buf, "---") do |writer| + writer << [1, 2, 3] + writer << [4, "---\"---", 5] + end + assert_equal("1---2---3\n4---\"---\"\"---\"---5\n", buf) + + buf = '' + CSV::Writer.generate(buf, nil) do |writer| + writer << [1, 2, 3] + writer << [4, ",\",", 5] + end + assert_equal("1,2,3\n4,\",\"\",\",5\n", buf) + end + + def test_writer_fs_rs_parse + reader = CSV::Reader.create('a||b--c||d', '||', '--') + assert_equal(['a', 'b'], reader.shift) + assert_equal(['c', 'd'], reader.shift) + + reader = CSV::Reader.create("a@|b@-c@|d", "@|", "@-") + assert_equal(['a', 'b'], reader.shift) + assert_equal(['c', 'd'], reader.shift) + + reader = CSV::Reader.create("ababfsababrs", "abfs", "abrs") + assert_equal(['ab', 'ab'], reader.shift) + + reader = CSV::Reader.create('"ab"abfsababrs', "abfs", "abrs") + assert_equal(['ab', 'ab'], reader.shift) + + reader = CSV::Reader.create('"ab"aabfsababrs', "abfs", "abrs") + assert_raises(CSV::IllegalFormatError) do + reader.shift + end + + # fs match while matching rs progress + reader = CSV::Reader.create("ab,ababrs", nil, "abrs") + assert_equal(['ab', 'ab'], reader.shift) + + reader = CSV::Reader.create(',ababrs', nil, "abrs") + assert_equal([nil, 'ab'], reader.shift) + + reader = CSV::Reader.create('"",ababrs', nil, "abrs") + assert_equal(['', 'ab'], reader.shift) + + reader = CSV::Reader.create('ab,"ab"abrs', nil, "abrs") + assert_equal(['ab', 'ab'], reader.shift) + + reader = CSV::Reader.create('ab,"ab"aabrs', nil, "abrs") + assert_raises(CSV::IllegalFormatError) do + reader.shift + end + + # rs match while matching fs progress + reader = CSV::Reader.create("ab|abc", 'ab-', "ab|") + assert_equal([nil], reader.shift) + assert_equal(['abc'], reader.shift) + + reader = CSV::Reader.create("ab\ncdabcef", "abc", "\n") + assert_equal(['ab'], reader.shift) + assert_equal(['cd', "ef"], reader.shift) + + # EOF while fs/rs matching + reader = CSV::Reader.create("ab", 'ab-', "xyz") + assert_equal(['ab'], reader.shift) + + reader = CSV::Reader.create("ab", 'xyz', "ab|") + assert_equal(['ab'], reader.shift) + + reader = CSV::Reader.create("ab", 'ab-', "ab|") + assert_equal(['ab'], reader.shift) + + reader = CSV::Reader.create(",,:,,:,,;,,:,,,,:,,;", ",,:", ",,;") + assert_equal([nil, nil, nil], reader.shift) + assert_equal([nil, ",,", nil], reader.shift) + end + + def test_s_foreach + File.open(@outfile, "w") do |f| + f << "1,2,3\n4,5,6" + end + row = [] + CSV.foreach(@outfile) { |line| + row << line + } + assert_equal([['1', '2', '3'], ['4', '5', '6']], row) + + File.open(@outfile, "w") do |f| + f << "1,2,3\r4,5,6" + end + row = [] + CSV.foreach(@outfile, "\r") { |line| + row << line + } + assert_equal([['1', '2', '3'], ['4', '5', '6']], row) + end + + def test_s_readlines + File.open(@outfile, "w") do |f| + f << "1,2,3\n4,5,6" + end + assert_equal([["1", "2", "3"], ["4", "5", "6"]], CSV.readlines(@outfile)) + assert_equal([["1", "2", nil], [nil, "5", "6"]], CSV.readlines(@outfile, "3\n4")) + end + + def test_s_read + File.open(@outfile, "w") do |f| + f << "1,2,3\n4,5,6" + end + assert_equal([["1", "2", "3"], ["4", "5", "6"]], CSV.read(@outfile)) + assert_equal([["1", "2"]], CSV.read(@outfile, 3)) + assert_equal([[nil], ["4", nil]], CSV.read(@outfile, 3, 5)) + end +end |