summaryrefslogtreecommitdiff
path: root/test/csv
diff options
context:
space:
mode:
authorkou <kou@b2dd03c8-39d4-4d8f-98ff-823fe69b080e>2019-04-14 21:01:51 +0000
committerkou <kou@b2dd03c8-39d4-4d8f-98ff-823fe69b080e>2019-04-14 21:01:51 +0000
commite3b6c7c7ebca1b051dbaa6f33494e92f5638fcc9 (patch)
treef98e60ecbeb320a9e9d8bdacfa3f9231cd55ddda /test/csv
parentfb96811d15f83c6b692e8e00d458eef32032af6a (diff)
Import CSV 3.0.8
This includes performance improvements and backward incompatibility fixes. git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@67560 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
Diffstat (limited to 'test/csv')
-rw-r--r--test/csv/helper.rb13
-rw-r--r--test/csv/interface/test_delegation.rb47
-rw-r--r--test/csv/interface/test_read.rb277
-rw-r--r--test/csv/interface/test_read_write.rb51
-rw-r--r--test/csv/interface/test_write.rb174
-rw-r--r--test/csv/parse/test_general.rb4
-rw-r--r--test/csv/parse/test_invalid.rb36
-rw-r--r--test/csv/parse/test_liberal_parsing.rb75
-rw-r--r--test/csv/parse/test_quote_char_nil.rb93
-rw-r--r--test/csv/parse/test_row_separator.rb16
-rw-r--r--test/csv/parse/test_skip_lines.rb105
-rw-r--r--test/csv/parse/test_strip.rb48
-rwxr-xr-xtest/csv/test_encodings.rb11
-rwxr-xr-xtest/csv/test_features.rb74
-rwxr-xr-xtest/csv/test_interface.rb450
-rw-r--r--test/csv/write/test_converters.rb53
16 files changed, 993 insertions, 534 deletions
diff --git a/test/csv/helper.rb b/test/csv/helper.rb
index 4f7b002..2542cc9 100644
--- a/test/csv/helper.rb
+++ b/test/csv/helper.rb
@@ -1,5 +1,18 @@
+require "tempfile"
require "test/unit"
require "csv"
require_relative "../lib/with_different_ofs.rb"
+
+module Helper
+ def with_chunk_size(chunk_size)
+ chunk_size_keep = ENV["CSV_PARSER_SCANNER_TEST_CHUNK_SIZE"]
+ begin
+ ENV["CSV_PARSER_SCANNER_TEST_CHUNK_SIZE"] = chunk_size
+ yield
+ ensure
+ ENV["CSV_PARSER_SCANNER_TEST_CHUNK_SIZE"] = chunk_size_keep
+ end
+ end
+end
diff --git a/test/csv/interface/test_delegation.rb b/test/csv/interface/test_delegation.rb
new file mode 100644
index 0000000..3492576
--- /dev/null
+++ b/test/csv/interface/test_delegation.rb
@@ -0,0 +1,47 @@
+# frozen_string_literal: false
+
+require_relative "../helper"
+
+class TestCSVInterfaceDelegation < Test::Unit::TestCase
+ class TestStringIO < self
+ def setup
+ @csv = CSV.new("h1,h2")
+ end
+
+ def test_flock
+ assert_raise(NotImplementedError) do
+ @csv.flock(File::LOCK_EX)
+ end
+ end
+
+ def test_ioctl
+ assert_raise(NotImplementedError) do
+ @csv.ioctl(0)
+ end
+ end
+
+ def test_stat
+ assert_raise(NotImplementedError) do
+ @csv.stat
+ end
+ end
+
+ def test_to_i
+ assert_raise(NotImplementedError) do
+ @csv.to_i
+ end
+ end
+
+ def test_binmode?
+ assert_equal(false, @csv.binmode?)
+ end
+
+ def test_path
+ assert_equal(nil, @csv.path)
+ end
+
+ def test_to_io
+ assert_instance_of(StringIO, @csv.to_io)
+ end
+ end
+end
diff --git a/test/csv/interface/test_read.rb b/test/csv/interface/test_read.rb
new file mode 100644
index 0000000..393619b
--- /dev/null
+++ b/test/csv/interface/test_read.rb
@@ -0,0 +1,277 @@
+# frozen_string_literal: false
+
+require_relative "../helper"
+
+class TestCSVInterfaceRead < Test::Unit::TestCase
+ extend DifferentOFS
+
+ def setup
+ super
+ @data = ""
+ @data << "1\t2\t3\r\n"
+ @data << "4\t5\r\n"
+ @input = Tempfile.new(["interface-read", ".csv"], options: {binmode: true})
+ @input << @data
+ @input.rewind
+ @rows = [
+ ["1", "2", "3"],
+ ["4", "5"],
+ ]
+ end
+
+ def teardown
+ @input.close(true)
+ super
+ end
+
+ def test_foreach
+ rows = []
+ CSV.foreach(@input.path, col_sep: "\t", row_sep: "\r\n").each do |row|
+ rows << row
+ end
+ assert_equal(@rows, rows)
+ end
+
+ def test_foreach_mode
+ rows = []
+ CSV.foreach(@input.path, "r", col_sep: "\t", row_sep: "\r\n").each do |row|
+ rows << row
+ end
+ assert_equal(@rows, rows)
+ end
+
+ def test_foreach_enumurator
+ rows = CSV.foreach(@input.path, col_sep: "\t", row_sep: "\r\n").to_a
+ assert_equal(@rows, rows)
+ end
+
+ def test_closed?
+ csv = CSV.open(@input.path, "r+", col_sep: "\t", row_sep: "\r\n")
+ assert_not_predicate(csv, :closed?)
+ csv.close
+ assert_predicate(csv, :closed?)
+ end
+
+ def test_open_auto_close
+ csv = nil
+ CSV.open(@input.path) do |_csv|
+ csv = _csv
+ end
+ assert_predicate(csv, :closed?)
+ end
+
+ def test_open_closed
+ csv = nil
+ CSV.open(@input.path) do |_csv|
+ csv = _csv
+ csv.close
+ end
+ assert_predicate(csv, :closed?)
+ end
+
+ def test_open_block_return_value
+ return_value = CSV.open(@input.path) do
+ "Return value."
+ end
+ assert_equal("Return value.", return_value)
+ end
+
+ def test_open_encoding_valid
+ # U+1F600 GRINNING FACE
+ # U+1F601 GRINNING FACE WITH SMILING EYES
+ File.open(@input.path, "w") do |file|
+ file << "\u{1F600},\u{1F601}"
+ end
+ CSV.open(@input.path, encoding: "utf-8") do |csv|
+ assert_equal([["\u{1F600}", "\u{1F601}"]],
+ csv.to_a)
+ end
+ end
+
+ def test_open_encoding_invalid
+ # U+1F600 GRINNING FACE
+ # U+1F601 GRINNING FACE WITH SMILING EYES
+ File.open(@input.path, "w") do |file|
+ file << "\u{1F600},\u{1F601}"
+ end
+ CSV.open(@input.path, encoding: "EUC-JP") do |csv|
+ error = assert_raise(CSV::MalformedCSVError) do
+ csv.shift
+ end
+ assert_equal("Invalid byte sequence in EUC-JP in line 1.",
+ error.message)
+ end
+ end
+
+ def test_open_encoding_nonexistent
+ _output, error = capture_io do
+ CSV.open(@input.path, encoding: "nonexistent") do
+ end
+ end
+ assert_equal("path:0: warning: Unsupported encoding nonexistent ignored\n",
+ error.gsub(/\A.+:\d+: /, "path:0: "))
+ end
+
+ def test_open_encoding_utf_8_with_bom
+ # U+FEFF ZERO WIDTH NO-BREAK SPACE, BOM
+ # U+1F600 GRINNING FACE
+ # U+1F601 GRINNING FACE WITH SMILING EYES
+ File.open(@input.path, "w") do |file|
+ file << "\u{FEFF}\u{1F600},\u{1F601}"
+ end
+ CSV.open(@input.path, encoding: "bom|utf-8") do |csv|
+ assert_equal([["\u{1F600}", "\u{1F601}"]],
+ csv.to_a)
+ end
+ end
+
+ def test_parse
+ assert_equal(@rows,
+ CSV.parse(@data, col_sep: "\t", row_sep: "\r\n"))
+ end
+
+ def test_parse_block
+ rows = []
+ CSV.parse(@data, col_sep: "\t", row_sep: "\r\n") do |row|
+ rows << row
+ end
+ assert_equal(@rows, rows)
+ end
+
+ def test_parse_enumerator
+ rows = CSV.parse(@data, col_sep: "\t", row_sep: "\r\n").to_a
+ assert_equal(@rows, rows)
+ end
+
+ def test_parse_headers_only
+ table = CSV.parse("a,b,c", headers: true)
+ assert_equal([
+ ["a", "b", "c"],
+ [],
+ ],
+ [
+ table.headers,
+ table.each.to_a,
+ ])
+ end
+
+ def test_parse_line
+ assert_equal(["1", "2", "3"],
+ CSV.parse_line("1;2;3", col_sep: ";"))
+ end
+
+ def test_parse_line_shortcut
+ assert_equal(["1", "2", "3"],
+ "1;2;3".parse_csv(col_sep: ";"))
+ end
+
+ def test_parse_line_empty
+ assert_equal(nil, CSV.parse_line("")) # to signal eof
+ end
+
+ def test_parse_line_empty_line
+ assert_equal([], CSV.parse_line("\n1,2,3"))
+ end
+
+ def test_read
+ assert_equal(@rows,
+ CSV.read(@input.path, col_sep: "\t", row_sep: "\r\n"))
+ end
+
+ def test_readlines
+ assert_equal(@rows,
+ CSV.readlines(@input.path, col_sep: "\t", row_sep: "\r\n"))
+ end
+
+ def test_open_read
+ rows = CSV.open(@input.path, col_sep: "\t", row_sep: "\r\n") do |csv|
+ csv.read
+ end
+ assert_equal(@rows, rows)
+ end
+
+ def test_open_readlines
+ rows = CSV.open(@input.path, col_sep: "\t", row_sep: "\r\n") do |csv|
+ csv.readlines
+ end
+ assert_equal(@rows, rows)
+ end
+
+ def test_table
+ table = CSV.table(@input.path, col_sep: "\t", row_sep: "\r\n")
+ assert_equal(CSV::Table.new([
+ CSV::Row.new([:"1", :"2", :"3"], [4, 5, nil]),
+ ]),
+ table)
+ end
+
+ def test_shift # aliased as gets() and readline()
+ CSV.open(@input.path, "rb+", col_sep: "\t", row_sep: "\r\n") do |csv|
+ rows = [
+ csv.shift,
+ csv.shift,
+ csv.shift,
+ ]
+ assert_equal(@rows + [nil],
+ rows)
+ end
+ end
+
+ def test_enumerator
+ CSV.open(@input.path, col_sep: "\t", row_sep: "\r\n") do |csv|
+ assert_equal(@rows, csv.each.to_a)
+ end
+ end
+
+ def test_shift_and_each
+ CSV.open(@input.path, col_sep: "\t", row_sep: "\r\n") do |csv|
+ rows = []
+ rows << csv.shift
+ rows.concat(csv.each.to_a)
+ assert_equal(@rows, rows)
+ end
+ end
+
+ def test_each_twice
+ CSV.open(@input.path, col_sep: "\t", row_sep: "\r\n") do |csv|
+ assert_equal([
+ @rows,
+ [],
+ ],
+ [
+ csv.each.to_a,
+ csv.each.to_a,
+ ])
+ end
+ end
+
+ def test_eof?
+ eofs = []
+ CSV.open(@input.path, col_sep: "\t", row_sep: "\r\n") do |csv|
+ eofs << csv.eof?
+ csv.shift
+ eofs << csv.eof?
+ csv.shift
+ eofs << csv.eof?
+ end
+ assert_equal([false, false, true],
+ eofs)
+ end
+
+ def test_new_nil
+ assert_raise_with_message ArgumentError, "Cannot parse nil as CSV" do
+ CSV.new(nil)
+ end
+ end
+
+ def test_options_not_modified
+ options = {}.freeze
+ CSV.foreach(@input.path, options)
+ CSV.open(@input.path, options) {}
+ CSV.parse("", options)
+ CSV.parse_line("", options)
+ CSV.read(@input.path, options)
+ CSV.readlines(@input.path, options)
+ CSV.table(@input.path, options)
+ end
+end
diff --git a/test/csv/interface/test_read_write.rb b/test/csv/interface/test_read_write.rb
new file mode 100644
index 0000000..9ce3553
--- /dev/null
+++ b/test/csv/interface/test_read_write.rb
@@ -0,0 +1,51 @@
+# frozen_string_literal: false
+
+require_relative "../helper"
+
+class TestCSVInterfaceReadWrite < Test::Unit::TestCase
+ extend DifferentOFS
+
+ def test_filter
+ rows = [[1, 2, 3], [4, 5]]
+ input = <<-CSV
+1;2;3
+4;5
+ CSV
+ output = ""
+ CSV.filter(input, output,
+ in_col_sep: ";",
+ out_col_sep: ",",
+ converters: :all) do |row|
+ row.map! {|n| n * 2}
+ row << "Added\r"
+ end
+ assert_equal(<<-CSV, output)
+2,4,6,"Added\r"
+8,10,"Added\r"
+ CSV
+ end
+
+ def test_instance_same
+ data = ""
+ assert_equal(CSV.instance(data, col_sep: ";").object_id,
+ CSV.instance(data, col_sep: ";").object_id)
+ end
+
+ def test_instance_append
+ output = ""
+ CSV.instance(output, col_sep: ";") << ["a", "b", "c"]
+ assert_equal(<<-CSV, output)
+a;b;c
+ CSV
+ CSV.instance(output, col_sep: ";") << [1, 2, 3]
+ assert_equal(<<-CSV, output)
+a;b;c
+1;2;3
+ CSV
+ end
+
+ def test_instance_shortcut
+ assert_equal(CSV.instance,
+ CSV {|csv| csv})
+ end
+end
diff --git a/test/csv/interface/test_write.rb b/test/csv/interface/test_write.rb
new file mode 100644
index 0000000..8511204
--- /dev/null
+++ b/test/csv/interface/test_write.rb
@@ -0,0 +1,174 @@
+# frozen_string_literal: false
+
+require_relative "../helper"
+
+class TestCSVInterfaceWrite < Test::Unit::TestCase
+ extend DifferentOFS
+
+ def setup
+ super
+ @output = Tempfile.new(["interface-write", ".csv"])
+ end
+
+ def teardown
+ @output.close(true)
+ super
+ end
+
+ def test_generate_default
+ csv_text = CSV.generate do |csv|
+ csv << [1, 2, 3] << [4, nil, 5]
+ end
+ assert_equal(<<-CSV, csv_text)
+1,2,3
+4,,5
+ CSV
+ end
+
+ def test_generate_append
+ csv_text = <<-CSV
+1,2,3
+4,,5
+ CSV
+ CSV.generate(csv_text) do |csv|
+ csv << ["last", %Q{"row"}]
+ end
+ assert_equal(<<-CSV, csv_text)
+1,2,3
+4,,5
+last,"""row"""
+ CSV
+ end
+
+ def test_generate_no_new_line
+ csv_text = CSV.generate("test") do |csv|
+ csv << ["row"]
+ end
+ assert_equal(<<-CSV, csv_text)
+testrow
+ CSV
+ end
+
+ def test_generate_line_col_sep
+ line = CSV.generate_line(["1", "2", "3"], col_sep: ";")
+ assert_equal(<<-LINE, line)
+1;2;3
+ LINE
+ end
+
+ def test_generate_line_row_sep
+ line = CSV.generate_line(["1", "2"], row_sep: nil)
+ assert_equal(<<-LINE.chomp, line)
+1,2
+ LINE
+ end
+
+ def test_generate_line_shortcut
+ line = ["1", "2", "3"].to_csv(col_sep: ";")
+ assert_equal(<<-LINE, line)
+1;2;3
+ LINE
+ end
+
+ def test_headers_detection
+ headers = ["a", "b", "c"]
+ CSV.open(@output.path, "w", headers: true) do |csv|
+ csv << headers
+ csv << ["1", "2", "3"]
+ assert_equal(headers, csv.headers)
+ end
+ end
+
+ def test_lineno
+ CSV.open(@output.path, "w") do |csv|
+ n_lines = 20
+ n_lines.times do
+ csv << ["a", "b", "c"]
+ end
+ assert_equal(n_lines, csv.lineno)
+ end
+ end
+
+ def test_append_row
+ CSV.open(@output.path, "wb") do |csv|
+ csv <<
+ CSV::Row.new([], ["1", "2", "3"]) <<
+ CSV::Row.new([], ["a", "b", "c"])
+ end
+ assert_equal(<<-CSV, File.read(@output.path, mode: "rb"))
+1,2,3
+a,b,c
+ CSV
+ end
+
+ def test_append_hash
+ CSV.open(@output.path, "wb", headers: true) do |csv|
+ csv << [:a, :b, :c]
+ csv << {a: 1, b: 2, c: 3}
+ csv << {a: 4, b: 5, c: 6}
+ end
+ assert_equal(<<-CSV, File.read(@output.path, mode: "rb"))
+a,b,c
+1,2,3
+4,5,6
+ CSV
+ end
+
+ def test_append_hash_headers_array
+ CSV.open(@output.path, "wb", headers: [:b, :a, :c]) do |csv|
+ csv << {a: 1, b: 2, c: 3}
+ csv << {a: 4, b: 5, c: 6}
+ end
+ assert_equal(<<-CSV, File.read(@output.path, mode: "rb"))
+2,1,3
+5,4,6
+ CSV
+ end
+
+ def test_append_hash_headers_string
+ CSV.open(@output.path, "wb", headers: "b|a|c", col_sep: "|") do |csv|
+ csv << {"a" => 1, "b" => 2, "c" => 3}
+ csv << {"a" => 4, "b" => 5, "c" => 6}
+ end
+ assert_equal(<<-CSV, File.read(@output.path, mode: "rb"))
+2|1|3
+5|4|6
+ CSV
+ end
+
+ def test_write_headers
+ CSV.open(@output.path,
+ "wb",
+ headers: "b|a|c",
+ write_headers: true,
+ col_sep: "|" ) do |csv|
+ csv << {"a" => 1, "b" => 2, "c" => 3}
+ csv << {"a" => 4, "b" => 5, "c" => 6}
+ end
+ assert_equal(<<-CSV, File.read(@output.path, mode: "rb"))
+b|a|c
+2|1|3
+5|4|6
+ CSV
+ end
+
+ def test_write_headers_empty
+ CSV.open(@output.path,
+ "wb",
+ headers: "b|a|c",
+ write_headers: true,
+ col_sep: "|" ) do |csv|
+ end
+ assert_equal(<<-CSV, File.read(@output.path, mode: "rb"))
+b|a|c
+ CSV
+ end
+
+ def test_options_not_modified
+ options = {}.freeze
+ CSV.generate(options) {}
+ CSV.generate_line([], options)
+ CSV.filter("", "", options)
+ CSV.instance("", options)
+ end
+end
diff --git a/test/csv/parse/test_general.rb b/test/csv/parse/test_general.rb
index 2f235f1..49222c7 100644
--- a/test/csv/parse/test_general.rb
+++ b/test/csv/parse/test_general.rb
@@ -142,7 +142,7 @@ class TestCSVParseGeneral < Test::Unit::TestCase
error = assert_raise(CSV::MalformedCSVError) do
CSV.parse_line("1,2\r,3", row_sep: "\n")
end
- assert_equal("Unquoted fields do not allow \\r or \\n in line 1.",
+ assert_equal("Unquoted fields do not allow new line <\"\\r\"> in line 1.",
error.message)
end
@@ -158,7 +158,7 @@ line,5,jkl
error = assert_raise(CSV::MalformedCSVError) do
CSV.parse(csv)
end
- assert_equal("Unquoted fields do not allow \\r or \\n in line 4.",
+ assert_equal("Unquoted fields do not allow new line <\"\\r\"> in line 4.",
error.message)
end
diff --git a/test/csv/parse/test_invalid.rb b/test/csv/parse/test_invalid.rb
new file mode 100644
index 0000000..b84707c
--- /dev/null
+++ b/test/csv/parse/test_invalid.rb
@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+# frozen_string_literal: false
+
+require_relative "../helper"
+
+class TestCSVParseInvalid < Test::Unit::TestCase
+ def test_no_column_mixed_new_lines
+ error = assert_raise(CSV::MalformedCSVError) do
+ CSV.parse("\n" +
+ "\r")
+ end
+ assert_equal("New line must be <\"\\n\"> not <\"\\r\"> in line 2.",
+ error.message)
+ end
+
+ def test_ignore_invalid_line
+ csv = CSV.new(<<-CSV, headers: true, return_headers: true)
+head1,head2,head3
+aaa,bbb,ccc
+ddd,ee"e.fff
+ggg,hhh,iii
+ CSV
+ headers = ["head1", "head2", "head3"]
+ assert_equal(CSV::Row.new(headers, headers),
+ csv.shift)
+ assert_equal(CSV::Row.new(headers, ["aaa", "bbb", "ccc"]),
+ csv.shift)
+ error = assert_raise(CSV::MalformedCSVError) do
+ csv.shift
+ end
+ assert_equal("Illegal quoting in line 3.",
+ error.message)
+ assert_equal(CSV::Row.new(headers, ["ggg", "hhh", "iii"]),
+ csv.shift)
+ end
+end
diff --git a/test/csv/parse/test_liberal_parsing.rb b/test/csv/parse/test_liberal_parsing.rb
index 22b1689..2f7b346 100644
--- a/test/csv/parse/test_liberal_parsing.rb
+++ b/test/csv/parse/test_liberal_parsing.rb
@@ -22,8 +22,7 @@ class TestCSVParseLiberalParsing < Test::Unit::TestCase
error = assert_raise(CSV::MalformedCSVError) do
CSV.parse_line(input)
end
- assert_equal("Do not allow except col_sep_split_separator " +
- "after quoted fields in line 1.",
+ assert_equal("Any value after quoted field isn't allowed in line 1.",
error.message)
assert_equal(['"quoted" field'],
CSV.parse_line(input, liberal_parsing: true))
@@ -75,8 +74,7 @@ class TestCSVParseLiberalParsing < Test::Unit::TestCase
error = assert_raise(CSV::MalformedCSVError) do
CSV.parse(data)
end
- assert_equal("Do not allow except col_sep_split_separator " +
- "after quoted fields in line 1.",
+ assert_equal("Any value after quoted field isn't allowed in line 1.",
error.message)
assert_equal([
[["a", %Q{""b""}]],
@@ -90,4 +88,73 @@ class TestCSVParseLiberalParsing < Test::Unit::TestCase
}),
])
end
+
+ class TestBackslashQuote < Test::Unit::TestCase
+ extend ::DifferentOFS
+
+ def test_double_quote_outside_quote
+ data = %Q{a,""b""}
+ assert_equal([
+ [["a", %Q{""b""}]],
+ [["a", %Q{"b"}]],
+ ],
+ [
+ CSV.parse(data,
+ liberal_parsing: {
+ backslash_quote: true
+ }),
+ CSV.parse(data,
+ liberal_parsing: {
+ backslash_quote: true,
+ double_quote_outside_quote: true
+ }),
+ ])
+ end
+
+ def test_unquoted_value
+ data = %q{\"\"a\"\"}
+ assert_equal([
+ [[%q{\"\"a\"\"}]],
+ [[%q{""a""}]],
+ ],
+ [
+ CSV.parse(data, liberal_parsing: true),
+ CSV.parse(data,
+ liberal_parsing: {
+ backslash_quote: true
+ }),
+ ])
+ end
+
+ def test_unquoted_value_multiple_characters_col_sep
+ data = %q{a<\\"b<=>x}
+ assert_equal([[%Q{a<"b}, "x"]],
+ CSV.parse(data,
+ col_sep: "<=>",
+ liberal_parsing: {
+ backslash_quote: true
+ }))
+ end
+
+ def test_quoted_value
+ data = %q{"\"\"a\"\""}
+ assert_equal([
+ [[%q{"\"\"a\"\""}]],
+ [[%q{""a""}]],
+ [[%q{""a""}]],
+ ],
+ [
+ CSV.parse(data, liberal_parsing: true),
+ CSV.parse(data,
+ liberal_parsing: {
+ backslash_quote: true
+ }),
+ CSV.parse(data,
+ liberal_parsing: {
+ backslash_quote: true,
+ double_quote_outside_quote: true
+ }),
+ ])
+ end
+ end
end
diff --git a/test/csv/parse/test_quote_char_nil.rb b/test/csv/parse/test_quote_char_nil.rb
new file mode 100644
index 0000000..fc3b646
--- /dev/null
+++ b/test/csv/parse/test_quote_char_nil.rb
@@ -0,0 +1,93 @@
+# -*- coding: utf-8 -*-
+# frozen_string_literal: false
+
+require_relative "../helper"
+
+class TestCSVParseQuoteCharNil < Test::Unit::TestCase
+ extend DifferentOFS
+
+ def test_full
+ assert_equal(["a", "b"], CSV.parse_line(%Q{a,b}, quote_char: nil))
+ end
+
+ def test_end_with_nil
+ assert_equal(["a", nil, nil, nil], CSV.parse_line(%Q{a,,,}, quote_char: nil))
+ end
+
+ def test_nil_nil
+ assert_equal([nil, nil], CSV.parse_line(%Q{,}, quote_char: nil))
+ end
+
+ def test_unquoted_value_multiple_characters_col_sep
+ data = %q{a<b<=>x}
+ assert_equal([[%Q{a<b}, "x"]], CSV.parse(data, col_sep: "<=>", quote_char: nil))
+ end
+
+ def test_csv_header_string
+ data = <<~DATA
+ first,second,third
+ A,B,C
+ 1,2,3
+ DATA
+ assert_equal(
+ CSV::Table.new([
+ CSV::Row.new(["my", "new", "headers"], ["first", "second", "third"]),
+ CSV::Row.new(["my", "new", "headers"], ["A", "B", "C"]),
+ CSV::Row.new(["my", "new", "headers"], ["1", "2", "3"])
+ ]),
+ CSV.parse(data, headers: "my,new,headers", quote_char: nil)
+ )
+ end
+
+ def test_comma
+ assert_equal([["a", "b", nil, "d"]],
+ CSV.parse("a,b,,d", col_sep: ",", quote_char: nil))
+ end
+
+ def test_space
+ assert_equal([["a", "b", nil, "d"]],
+ CSV.parse("a b d", col_sep: " ", quote_char: nil))
+ end
+
+ def encode_array(array, encoding)
+ array.collect do |element|
+ element ? element.encode(encoding) : element
+ end
+ end
+
+ def test_space_no_ascii
+ encoding = Encoding::UTF_16LE
+ assert_equal([encode_array(["a", "b", nil, "d"], encoding)],
+ CSV.parse("a b d".encode(encoding),
+ col_sep: " ".encode(encoding),
+ quote_char: nil))
+ end
+
+ def test_multiple_space
+ assert_equal([["a b", nil, "d"]],
+ CSV.parse("a b d", col_sep: " ", quote_char: nil))
+ end
+
+ def test_multiple_characters_leading_empty_fields
+ data = <<-CSV
+<=><=>A<=>B<=>C
+1<=>2<=>3
+ CSV
+ assert_equal([
+ [nil, nil, "A", "B", "C"],
+ ["1", "2", "3"],
+ ],
+ CSV.parse(data, col_sep: "<=>", quote_char: nil))
+ end
+
+ def test_line
+ lines = [
+ "abc,def\n",
+ ]
+ csv = CSV.new(lines.join(""), quote_char: nil)
+ lines.each do |line|
+ csv.shift
+ assert_equal(line, csv.line)
+ end
+ end
+end
diff --git a/test/csv/parse/test_row_separator.rb b/test/csv/parse/test_row_separator.rb
new file mode 100644
index 0000000..eaf6adc
--- /dev/null
+++ b/test/csv/parse/test_row_separator.rb
@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+# frozen_string_literal: false
+
+require_relative "../helper"
+
+class TestCSVParseRowSeparator < Test::Unit::TestCase
+ extend DifferentOFS
+ include Helper
+
+ def test_multiple_characters
+ with_chunk_size("1") do
+ assert_equal([["a"], ["b"]],
+ CSV.parse("a\r\nb\r\n", row_sep: "\r\n"))
+ end
+ end
+end
diff --git a/test/csv/parse/test_skip_lines.rb b/test/csv/parse/test_skip_lines.rb
new file mode 100644
index 0000000..196858f
--- /dev/null
+++ b/test/csv/parse/test_skip_lines.rb
@@ -0,0 +1,105 @@
+# frozen_string_literal: false
+
+require_relative "../helper"
+
+class TestCSVParseSkipLines < Test::Unit::TestCase
+ extend DifferentOFS
+ include Helper
+
+ def test_default
+ csv = CSV.new("a,b,c\n")
+ assert_nil(csv.skip_lines)
+ end
+
+ def test_regexp
+ csv = <<-CSV
+1
+#2
+ #3
+4
+ CSV
+ assert_equal([
+ ["1"],
+ ["4"],
+ ],
+ CSV.parse(csv, :skip_lines => /\A\s*#/))
+ end
+
+ def test_regexp_quoted
+ csv = <<-CSV
+1
+#2
+"#3"
+4
+ CSV
+ assert_equal([
+ ["1"],
+ ["#3"],
+ ["4"],
+ ],
+ CSV.parse(csv, :skip_lines => /\A\s*#/))
+ end
+
+ def test_string
+ csv = <<-CSV
+1
+.2
+3.
+4
+ CSV
+ assert_equal([
+ ["1"],
+ ["4"],
+ ],
+ CSV.parse(csv, :skip_lines => "."))
+ end
+
+ class RegexStub
+ end
+
+ def test_not_matchable
+ regex_stub = RegexStub.new
+ csv = CSV.new("1\n", :skip_lines => regex_stub)
+ error = assert_raise(ArgumentError) do
+ csv.shift
+ end
+ assert_equal(":skip_lines has to respond to #match: #{regex_stub.inspect}",
+ error.message)
+ end
+
+ class Matchable
+ def initialize(pattern)
+ @pattern = pattern
+ end
+
+ def match(line)
+ @pattern.match(line)
+ end
+ end
+
+ def test_matchable
+ csv = <<-CSV
+1
+# 2
+3
+# 4
+ CSV
+ assert_equal([
+ ["1"],
+ ["3"],
+ ],
+ CSV.parse(csv, :skip_lines => Matchable.new(/\A#/)))
+ end
+
+ def test_multibyte_data
+ # U+3042 HIRAGANA LETTER A
+ # U+3044 HIRAGANA LETTER I
+ # U+3046 HIRAGANA LETTER U
+ value = "\u3042\u3044\u3046"
+ with_chunk_size("5") do
+ assert_equal([[value], [value]],
+ CSV.parse("#{value}\n#{value}\n",
+ :skip_lines => /\A#/))
+ end
+ end
+end
diff --git a/test/csv/parse/test_strip.rb b/test/csv/parse/test_strip.rb
new file mode 100644
index 0000000..160407b
--- /dev/null
+++ b/test/csv/parse/test_strip.rb
@@ -0,0 +1,48 @@
+# -*- coding: utf-8 -*-
+# frozen_string_literal: false
+
+require_relative "../helper"
+
+class TestCSVParseStrip < Test::Unit::TestCase
+ extend DifferentOFS
+
+ def test_both
+ assert_equal(["a", "b"],
+ CSV.parse_line(%Q{ a , b }, strip: true))
+ end
+
+ def test_left
+ assert_equal(["a", "b"],
+ CSV.parse_line(%Q{ a, b}, strip: true))
+ end
+
+ def test_right
+ assert_equal(["a", "b"],
+ CSV.parse_line(%Q{a ,b }, strip: true))
+ end
+
+ def test_quoted
+ assert_equal([" a ", " b "],
+ CSV.parse_line(%Q{" a "," b "}, strip: true))
+ end
+
+ def test_liberal_parsing
+ assert_equal([" a ", "b", " c ", " d "],
+ CSV.parse_line(%Q{" a ", b , " c "," d " },
+ strip: true,
+ liberal_parsing: true))
+ end
+
+ def test_string
+ assert_equal(["a", " b"],
+ CSV.parse_line(%Q{ a , " b" },
+ strip: " "))
+ end
+
+ def test_no_quote
+ assert_equal([" a ", " b "],
+ CSV.parse_line(%Q{" a ", b },
+ strip: %Q{"},
+ quote_char: nil))
+ end
+end
diff --git a/test/csv/test_encodings.rb b/test/csv/test_encodings.rb
index 01101f1..64ea36a 100755
--- a/test/csv/test_encodings.rb
+++ b/test/csv/test_encodings.rb
@@ -256,12 +256,13 @@ class TestCSVEncodings < Test::Unit::TestCase
end
def test_invalid_encoding_row_error
- csv = CSV.new("invalid,\xF8\r\nvalid,x\r\n".force_encoding("UTF-8"),
- encoding: "UTF-8")
+ csv = CSV.new("valid,x\rinvalid,\xF8\r".force_encoding("UTF-8"),
+ encoding: "UTF-8", row_sep: "\r")
error = assert_raise(CSV::MalformedCSVError) do
csv.shift
+ csv.shift
end
- assert_equal("Invalid byte sequence in UTF-8 in line 1.",
+ assert_equal("Invalid byte sequence in UTF-8 in line 2.",
error.message)
end
@@ -270,9 +271,9 @@ class TestCSVEncodings < Test::Unit::TestCase
def assert_parses(fields, encoding, options = { })
encoding = Encoding.find(encoding) unless encoding.is_a? Encoding
orig_fields = fields
- fields = encode_ary(fields, encoding)
+ fields = encode_ary(fields, encoding)
data = ary_to_data(fields, options)
- parsed = CSV.parse(data, options)
+ parsed = CSV.parse(data, options)
assert_equal(fields, parsed)
parsed.flatten.each_with_index do |field, i|
assert_equal(encoding, field.encoding, "Field[#{i + 1}] was transcoded.")
diff --git a/test/csv/test_features.rb b/test/csv/test_features.rb
index 0b92776..306b880 100755
--- a/test/csv/test_features.rb
+++ b/test/csv/test_features.rb
@@ -56,7 +56,7 @@ line,4,jkl
error = assert_raise(CSV::MalformedCSVError) do
CSV.parse_line("1,2,3\n,4,5\r\n", row_sep: "\r\n")
end
- assert_equal("Unquoted fields do not allow \\r or \\n in line 1.",
+ assert_equal("Unquoted fields do not allow new line <\"\\n\"> in line 1.",
error.message)
assert_equal( ["1", "2", "3\n", "4", "5"],
CSV.parse_line(%Q{1,2,"3\n",4,5\r\n}, row_sep: "\r\n"))
@@ -295,78 +295,6 @@ line,4,jkl
assert_match(/\A\d\.\d\.\d\z/, CSV::VERSION)
end
- def test_accepts_comment_skip_lines_option
- assert_nothing_raised(ArgumentError) do
- CSV.new(@sample_data, :skip_lines => /\A\s*#/)
- end
- end
-
- def test_accepts_comment_defaults_to_nil
- c = CSV.new(@sample_data)
- assert_nil(c.skip_lines)
- end
-
- class RegexStub
- end
-
- def test_requires_skip_lines_to_call_match
- regex_stub = RegexStub.new
- csv = CSV.new(@sample_data, :skip_lines => regex_stub)
- assert_raise_with_message(ArgumentError, /skip_lines/) do
- csv.shift
- end
- end
-
- class Matchable
- def initialize(pattern)
- @pattern = pattern
- end
-
- def match(line)
- @pattern.match(line)
- end
- end
-
- def test_skip_lines_match
- csv = <<-CSV.chomp
-1
-# 2
-3
-# 4
- CSV
- assert_equal([["1"], ["3"]],
- CSV.parse(csv, :skip_lines => Matchable.new(/\A#/)))
- end
-
- def test_comment_rows_are_ignored
- sample_data = "line,1,a\n#not,a,line\nline,2,b\n #also,no,line"
- c = CSV.new sample_data, :skip_lines => /\A\s*#/
- assert_equal [["line", "1", "a"], ["line", "2", "b"]], c.each.to_a
- end
-
- def test_comment_rows_are_ignored_with_heredoc
- sample_data = <<~EOL
- 1,foo
- .2,bar
- 3,baz
- EOL
-
- c = CSV.new(sample_data, skip_lines: ".")
- assert_equal [["1", "foo"], ["3", "baz"]], c.each.to_a
- end
-
- def test_quoted_skip_line_markers_are_ignored
- sample_data = "line,1,a\n\"#not\",a,line\nline,2,b"
- c = CSV.new sample_data, :skip_lines => /\A\s*#/
- assert_equal [["line", "1", "a"], ["#not", "a", "line"], ["line", "2", "b"]], c.each.to_a
- end
-
- def test_string_works_like_a_regexp
- sample_data = "line,1,a\n#(not,a,line\nline,2,b\n also,#no,line"
- c = CSV.new sample_data, :skip_lines => "#"
- assert_equal [["line", "1", "a"], ["line", "2", "b"]], c.each.to_a
- end
-
def test_table_nil_equality
assert_nothing_raised(NoMethodError) { CSV.parse("test", headers: true) == nil }
end
diff --git a/test/csv/test_interface.rb b/test/csv/test_interface.rb
deleted file mode 100755
index 77730fa..0000000
--- a/test/csv/test_interface.rb
+++ /dev/null
@@ -1,450 +0,0 @@
-# -*- coding: utf-8 -*-
-# frozen_string_literal: false
-
-require_relative "helper"
-require "tempfile"
-
-class TestCSVInterface < Test::Unit::TestCase
- extend DifferentOFS
-
- def setup
- super
- @tempfile = Tempfile.new(%w"temp .csv")
- @tempfile.close
- @path = @tempfile.path
-
- File.open(@path, "wb") do |file|
- file << "1\t2\t3\r\n"
- file << "4\t5\r\n"
- end
-
- @expected = [%w{1 2 3}, %w{4 5}]
- end
-
- def teardown
- @tempfile.close(true)
- super
- end
-
- ### Test Read Interface ###
-
- def test_foreach
- CSV.foreach(@path, col_sep: "\t", row_sep: "\r\n") do |row|
- assert_equal(@expected.shift, row)
- end
- end
-
- def test_foreach_enum
- CSV.foreach(@path, col_sep: "\t", row_sep: "\r\n").zip(@expected) do |row, exp|
- assert_equal(exp, row)
- end
- end
-
- def test_open_and_close
- csv = CSV.open(@path, "r+", col_sep: "\t", row_sep: "\r\n")
- assert_not_nil(csv)
- assert_instance_of(CSV, csv)
- assert_not_predicate(csv, :closed?)
- csv.close
- assert_predicate(csv, :closed?)
-
- ret = CSV.open(@path) do |new_csv|
- csv = new_csv
- assert_instance_of(CSV, new_csv)
- "Return value."
- end
- assert_predicate(csv, :closed?)
- assert_equal("Return value.", ret)
- end
-
- def test_open_encoding_valid
- # U+1F600 GRINNING FACE
- # U+1F601 GRINNING FACE WITH SMILING EYES
- File.open(@path, "w") do |file|
- file << "\u{1F600},\u{1F601}"
- end
- CSV.open(@path, encoding: "utf-8") do |csv|
- assert_equal([["\u{1F600}", "\u{1F601}"]],
- csv.to_a)
- end
- end
-
- def test_open_encoding_invalid
- # U+1F600 GRINNING FACE
- # U+1F601 GRINNING FACE WITH SMILING EYES
- File.open(@path, "w") do |file|
- file << "\u{1F600},\u{1F601}"
- end
- CSV.open(@path, encoding: "EUC-JP") do |csv|
- error = assert_raise(CSV::MalformedCSVError) do
- csv.shift
- end
- assert_equal("Invalid byte sequence in EUC-JP in line 1.",
- error.message)
- end
- end
-
- def test_open_encoding_nonexistent
- _output, error = capture_io do
- CSV.open(@path, encoding: "nonexistent") do
- end
- end
- assert_equal("path:0: warning: Unsupported encoding nonexistent ignored\n",
- error.gsub(/\A.+:\d+: /, "path:0: "))
- end
-
- def test_open_encoding_utf_8_with_bom
- # U+FEFF ZERO WIDTH NO-BREAK SPACE, BOM
- # U+1F600 GRINNING FACE
- # U+1F601 GRINNING FACE WITH SMILING EYES
- File.open(@path, "w") do |file|
- file << "\u{FEFF}\u{1F600},\u{1F601}"
- end
- CSV.open(@path, encoding: "bom|utf-8") do |csv|
- assert_equal([["\u{1F600}", "\u{1F601}"]],
- csv.to_a)
- end
- end
-
- def test_parse
- data = File.binread(@path)
- assert_equal( @expected,
- CSV.parse(data, col_sep: "\t", row_sep: "\r\n") )
-
- CSV.parse(data, col_sep: "\t", row_sep: "\r\n") do |row|
- assert_equal(@expected.shift, row)
- end
- end
-
- def test_parse_line
- row = CSV.parse_line("1;2;3", col_sep: ";")
- assert_not_nil(row)
- assert_instance_of(Array, row)
- assert_equal(%w{1 2 3}, row)
-
- # shortcut interface
- row = "1;2;3".parse_csv(col_sep: ";")
- assert_not_nil(row)
- assert_instance_of(Array, row)
- assert_equal(%w{1 2 3}, row)
- end
-
- def test_parse_line_with_empty_lines
- assert_equal(nil, CSV.parse_line("")) # to signal eof
- assert_equal(Array.new, CSV.parse_line("\n1,2,3"))
- end
-
- def test_parse_header_only
- table = CSV.parse("a,b,c", headers: true)
- assert_equal([
- ["a", "b", "c"],
- [],
- ],
- [
- table.headers,
- table.each.to_a,
- ])
- end
-
- def test_read_and_readlines
- assert_equal( @expected,
- CSV.read(@path, col_sep: "\t", row_sep: "\r\n") )
- assert_equal( @expected,
- CSV.readlines(@path, col_sep: "\t", row_sep: "\r\n") )
-
-
- data = CSV.open(@path, col_sep: "\t", row_sep: "\r\n") do |csv|
- csv.read
- end
- assert_equal(@expected, data)
- data = CSV.open(@path, col_sep: "\t", row_sep: "\r\n") do |csv|
- csv.readlines
- end
- assert_equal(@expected, data)
- end
-
- def test_table
- table = CSV.table(@path, col_sep: "\t", row_sep: "\r\n")
- assert_instance_of(CSV::Table, table)
- assert_equal([[:"1", :"2", :"3"], [4, 5, nil]], table.to_a)
- end
-
- def test_shift # aliased as gets() and readline()
- CSV.open(@path, "rb+", col_sep: "\t", row_sep: "\r\n") do |csv|
- assert_equal(@expected.shift, csv.shift)
- assert_equal(@expected.shift, csv.shift)
- assert_equal(nil, csv.shift)
- end
- end
-
- def test_enumerators_are_supported
- CSV.open(@path, col_sep: "\t", row_sep: "\r\n") do |csv|
- enum = csv.each
- assert_instance_of(Enumerator, enum)
- assert_equal(@expected.shift, enum.next)
- end
- end
-
- def test_nil_is_not_acceptable
- assert_raise_with_message ArgumentError, "Cannot parse nil as CSV" do
- CSV.new(nil)
- end
- end
-
- def test_open_handles_prematurely_closed_file_descriptor_gracefully
- assert_nothing_raised(Exception) do
- CSV.open(@path) do |csv|
- csv.close
- end
- end
- end
-
- ### Test Write Interface ###
-
- def test_generate
- str = CSV.generate do |csv| # default empty String
- assert_instance_of(CSV, csv)
- assert_equal(csv, csv << [1, 2, 3])
- assert_equal(csv, csv << [4, nil, 5])
- end
- assert_not_nil(str)
- assert_instance_of(String, str)
- assert_equal("1,2,3\n4,,5\n", str)
-
- CSV.generate(str) do |csv| # appending to a String
- assert_equal(csv, csv << ["last", %Q{"row"}])
- end
- assert_equal(%Q{1,2,3\n4,,5\nlast,"""row"""\n}, str)
-
- out = CSV.generate("test") { |csv| csv << ["row"] }
- assert_equal("testrow\n", out)
- end
-
- def test_generate_line
- line = CSV.generate_line(%w{1 2 3}, col_sep: ";")
- assert_not_nil(line)
- assert_instance_of(String, line)
- assert_equal("1;2;3\n", line)
-
- # shortcut interface
- line = %w{1 2 3}.to_csv(col_sep: ";")
- assert_not_nil(line)
- assert_instance_of(String, line)
- assert_equal("1;2;3\n", line)
-
- line = CSV.generate_line(%w"1 2", row_sep: nil)
- assert_equal("1,2", line)
- end
-
- def test_write_header_detection
- File.unlink(@path)
-
- headers = %w{a b c}
- CSV.open(@path, "w", headers: true) do |csv|
- csv << headers
- csv << %w{1 2 3}
- assert_equal(headers, csv.headers)
- end
- end
-
- def test_write_lineno
- File.unlink(@path)
-
- CSV.open(@path, "w") do |csv|
- lines = 20
- lines.times { csv << %w{a b c} }
- assert_equal(lines, csv.lineno)
- end
- end
-
- def test_write_hash
- File.unlink(@path)
-
- lines = [{a: 1, b: 2, c: 3}, {a: 4, b: 5, c: 6}]
- CSV.open( @path, "wb", headers: true,
- header_converters: :symbol ) do |csv|
- csv << lines.first.keys
- lines.each { |line| csv << line }
- end
- CSV.open( @path, "rb", headers: true,
- converters: :all,
- header_converters: :symbol ) do |csv|
- csv.each { |line| assert_equal(lines.shift, line.to_hash) }
- end
- end
-
- def test_write_hash_with_string_keys
- File.unlink(@path)
-
- lines = [{a: 1, b: 2, c: 3}, {a: 4, b: 5, c: 6}]
- CSV.open( @path, "wb", headers: true ) do |csv|
- csv << lines.first.keys
- lines.each { |line| csv << line }
- end
- CSV.open( @path, "rb", headers: true ) do |csv|
- csv.each do |line|
- csv.headers.each_with_index do |header, h|
- keys = line.to_hash.keys
- assert_instance_of(String, keys[h])
- assert_same(header, keys[h])
- end
- end
- end
- end
-
- def test_write_hash_with_headers_array
- File.unlink(@path)
-
- lines = [{a: 1, b: 2, c: 3}, {a: 4, b: 5, c: 6}]
- CSV.open(@path, "wb", headers: [:b, :a, :c]) do |csv|
- lines.each { |line| csv << line }
- end
-
- # test writing fields in the correct order
- File.open(@path, "rb") do |f|
- assert_equal("2,1,3", f.gets.strip)
- assert_equal("5,4,6", f.gets.strip)
- end
-
- # test reading CSV with headers
- CSV.open( @path, "rb", headers: [:b, :a, :c],
- converters: :all ) do |csv|
- csv.each { |line| assert_equal(lines.shift, line.to_hash) }
- end
- end
-
- def test_write_hash_with_headers_string
- File.unlink(@path)
-
- lines = [{"a" => 1, "b" => 2, "c" => 3}, {"a" => 4, "b" => 5, "c" => 6}]
- CSV.open(@path, "wb", headers: "b|a|c", col_sep: "|") do |csv|
- lines.each { |line| csv << line }
- end
-
- # test writing fields in the correct order
- File.open(@path, "rb") do |f|
- assert_equal("2|1|3", f.gets.strip)
- assert_equal("5|4|6", f.gets.strip)
- end
-
- # test reading CSV with headers
- CSV.open( @path, "rb", headers: "b|a|c",
- col_sep: "|",
- converters: :all ) do |csv|
- csv.each { |line| assert_equal(lines.shift, line.to_hash) }
- end
- end
-
- def test_write_headers
- File.unlink(@path)
-
- lines = [{"a" => 1, "b" => 2, "c" => 3}, {"a" => 4, "b" => 5, "c" => 6}]
- CSV.open( @path, "wb", headers: "b|a|c",
- write_headers: true,
- col_sep: "|" ) do |csv|
- lines.each { |line| csv << line }
- end
-
- # test writing fields in the correct order
- File.open(@path, "rb") do |f|
- assert_equal("b|a|c", f.gets.strip)
- assert_equal("2|1|3", f.gets.strip)
- assert_equal("5|4|6", f.gets.strip)
- end
-
- # test reading CSV with headers
- CSV.open( @path, "rb", headers: true,
- col_sep: "|",
- converters: :all ) do |csv|
- csv.each { |line| assert_equal(lines.shift, line.to_hash) }
- end
- end
-
- def test_write_headers_empty
- File.unlink(@path)
-
- CSV.open( @path, "wb", headers: "b|a|c",
- write_headers: true,
- col_sep: "|" ) do |csv|
- end
-
- File.open(@path, "rb") do |f|
- assert_equal("b|a|c", f.gets.strip)
- end
- end
-
- def test_append # aliased add_row() and puts()
- File.unlink(@path)
-
- CSV.open(@path, "wb", col_sep: "\t", row_sep: "\r\n") do |csv|
- @expected.each { |row| csv << row }
- end
-
- test_shift
-
- # same thing using CSV::Row objects
- File.unlink(@path)
-
- CSV.open(@path, "wb", col_sep: "\t", row_sep: "\r\n") do |csv|
- @expected.each { |row| csv << CSV::Row.new(Array.new, row) }
- end
-
- test_shift
- end
-
- ### Test Read and Write Interface ###
-
- def test_filter
- assert_respond_to(CSV, :filter)
-
- expected = [[1, 2, 3], [4, 5]]
- CSV.filter( "1;2;3\n4;5\n", (result = String.new),
- in_col_sep: ";", out_col_sep: ",",
- converters: :all ) do |row|
- assert_equal(row, expected.shift)
- row.map! { |n| n * 2 }
- row << "Added\r"
- end
- assert_equal("2,4,6,\"Added\r\"\n8,10,\"Added\r\"\n", result)
- end
-
- def test_instance
- csv = String.new
-
- first = nil
- assert_nothing_raised(Exception) do
- first = CSV.instance(csv, col_sep: ";")
- first << %w{a b c}
- end
-
- assert_equal("a;b;c\n", csv)
-
- second = nil
- assert_nothing_raised(Exception) do
- second = CSV.instance(csv, col_sep: ";")
- second << [1, 2, 3]
- end
-
- assert_equal(first.object_id, second.object_id)
- assert_equal("a;b;c\n1;2;3\n", csv)
-
- # shortcuts
- assert_equal(STDOUT, CSV.instance.instance_eval { @io })
- assert_equal(STDOUT, CSV { |new_csv| new_csv.instance_eval { @io } })
- end
-
- def test_options_are_not_modified
- opt = {}.freeze
- assert_nothing_raised { CSV.foreach(@path, opt) }
- assert_nothing_raised { CSV.open(@path, opt){} }
- assert_nothing_raised { CSV.parse("", opt) }
- assert_nothing_raised { CSV.parse_line("", opt) }
- assert_nothing_raised { CSV.read(@path, opt) }
- assert_nothing_raised { CSV.readlines(@path, opt) }
- assert_nothing_raised { CSV.table(@path, opt) }
- assert_nothing_raised { CSV.generate(opt){} }
- assert_nothing_raised { CSV.generate_line([], opt) }
- assert_nothing_raised { CSV.filter("", "", opt){} }
- assert_nothing_raised { CSV.instance("", opt) }
- end
-end
diff --git a/test/csv/write/test_converters.rb b/test/csv/write/test_converters.rb
new file mode 100644
index 0000000..a93b104
--- /dev/null
+++ b/test/csv/write/test_converters.rb
@@ -0,0 +1,53 @@
+# -*- coding: utf-8 -*-
+# frozen_string_literal: false
+
+require_relative "../helper"
+
+module TestCSVWriteConverters
+ def test_one
+ assert_equal(%Q[=a,=b,=c\n],
+ generate_line(["a", "b", "c"],
+ write_converters: ->(value) {"=" + value}))
+ end
+
+ def test_multiple
+ assert_equal(%Q[=a_,=b_,=c_\n],
+ generate_line(["a", "b", "c"],
+ write_converters: [
+ ->(value) {"=" + value},
+ ->(value) {value + "_"},
+ ]))
+ end
+
+ def test_nil_value
+ assert_equal(%Q[a,NaN,c\n],
+ generate_line(["a", nil, "c"],
+ write_nil_value: "NaN"))
+ end
+
+ def test_empty_value
+ assert_equal(%Q[a,,c\n],
+ generate_line(["a", "", "c"],
+ write_empty_value: nil))
+ end
+end
+
+class TestCSVWriteConvertersGenerateLine < Test::Unit::TestCase
+ include TestCSVWriteConverters
+ extend DifferentOFS
+
+ def generate_line(row, **kwargs)
+ CSV.generate_line(row, **kwargs)
+ end
+end
+
+class TestCSVWriteConvertersGenerate < Test::Unit::TestCase
+ include TestCSVWriteConverters
+ extend DifferentOFS
+
+ def generate_line(row, **kwargs)
+ CSV.generate(**kwargs) do |csv|
+ csv << row
+ end
+ end
+end