fastcsv 0.0.4 → 0.0.5

data/ext/fastcsv/fastcsv.rl

@@ -22,6 +22,9 @@ if (enc2 != NULL) { \
 #define FREE \
 if (buf != NULL) { \
   free(buf); \
+} \
+if (row_sep != NULL) { \
+  free(row_sep); \
 }
 
 static VALUE cClass, cParser, eError;
@@ -96,9 +99,23 @@ typedef struct {
 
   action mark_row {
     d->start = p;
+
+    if (len_row_sep) {
+      if (p - mark_row_sep != len_row_sep || row_sep[0] != *mark_row_sep || (len_row_sep == 2 && row_sep[1] != *(mark_row_sep + 1))) {
+        FREE;
+
+        rb_raise(eError, "Unquoted fields do not allow \\r or \\n (line %d).", curline - 1);
+      }
+    }
+    else {
+      len_row_sep = p - mark_row_sep;
+      row_sep = ALLOC_N(char, len_row_sep);
+      memcpy(row_sep, mark_row_sep, len_row_sep);
+    }
   }
 
   action new_row {
+    mark_row_sep = p;
     curline++;
 
     if (d->start == 0 || p == d->start) {
@@ -118,7 +135,7 @@ typedef struct {
   }
 
   action last_row {
-    if (d->start == 0 || p == d->start) {
+    if (d->start == 0 || p == d->start) { // same as new_row
       rb_ivar_set(self, s_row, rb_str_new2(""));
     }
     else if (p > d->start) {
@@ -135,8 +152,8 @@ typedef struct {
   }
 
   EOF = 0;
-  quote_char = '"';
-  col_sep = ',' >new_field;
+  quote_char = any when { fc == quote_char };
+  col_sep = any when { fc == col_sep } >new_field;
   row_sep = ('\r' '\n'? | '\n');
   unquoted = (any* -- quote_char -- col_sep -- row_sep - EOF) %read_unquoted;
   quoted = quote_char >open_quote (any - quote_char - EOF | quote_char quote_char | row_sep)* %read_quoted quote_char >close_quote;
@@ -184,18 +201,18 @@ static void rb_io_ext_int_to_encs(rb_encoding *ext, rb_encoding *intern, rb_enco
 
 static VALUE raw_parse(int argc, VALUE *argv, VALUE self) {
   int cs, act, have = 0, curline = 1, io = 0;
-  char *ts = 0, *te = 0, *buf = 0, *eof = 0;
+  char *ts = 0, *te = 0, *buf = 0, *eof = 0, *mark_row_sep = 0, *row_sep = 0;
 
   VALUE port, opts, r_encoding;
   VALUE row = rb_ary_new(), field = Qnil, bufsize = Qnil;
-  int done = 0, unclosed_line = 0, buffer_size = 0, taint = 0;
+  int done = 0, unclosed_line = 0, buffer_size = 0, taint = 0, len_row_sep = 0;
   rb_encoding *enc = NULL, *enc2 = NULL, *encoding = NULL;
 
   Data *d;
   Data_Get_Struct(self, Data, d);
 
   VALUE option;
-  char quote_char = '"';
+  char quote_char = '"', col_sep = ',';
 
   rb_scan_args(argc, argv, "11", &port, &opts);
   taint = OBJ_TAINTED(port);
@@ -217,6 +234,22 @@ static VALUE raw_parse(int argc, VALUE *argv, VALUE self) {
     rb_raise(rb_eArgError, "options has to be a Hash or nil");
   }
 
+  option = rb_hash_aref(opts, ID2SYM(rb_intern("quote_char")));
+  if (TYPE(option) == T_STRING && RSTRING_LEN(option) == 1) {
+    quote_char = *StringValueCStr(option);
+  }
+  else if (!NIL_P(option)) {
+    rb_raise(rb_eArgError, ":quote_char has to be a single character String");
+  }
+
+  option = rb_hash_aref(opts, ID2SYM(rb_intern("col_sep")));
+  if (TYPE(option) == T_STRING && RSTRING_LEN(option) == 1) {
+    col_sep = *StringValueCStr(option);
+  }
+  else if (!NIL_P(option)) {
+    rb_raise(rb_eArgError, ":col_sep has to be a single character String");
+  }
+
   // @see rb_io_extract_modeenc
   /* Set to defaults */
   rb_io_ext_int_to_encs(NULL, NULL, &enc, &enc2, 0);
@@ -351,7 +384,7 @@ static VALUE raw_parse(int argc, VALUE *argv, VALUE self) {
   while (!done) {
     VALUE str;
     char *p, *pe;
-    int len, space = buffer_size - have, tokstart_diff, tokend_diff, start_diff;
+    int len, space = buffer_size - have, tokstart_diff, tokend_diff, start_diff, mark_row_sep_diff;
 
     if (io) {
       if (space == 0) {
@@ -359,6 +392,7 @@ static VALUE raw_parse(int argc, VALUE *argv, VALUE self) {
         tokstart_diff = ts - buf;
         tokend_diff = te - buf;
         start_diff = d->start - buf;
+        mark_row_sep_diff = mark_row_sep - buf;
 
         buffer_size += BUFSIZE;
         REALLOC_N(buf, char, buffer_size);
@@ -368,6 +402,7 @@ static VALUE raw_parse(int argc, VALUE *argv, VALUE self) {
         ts = buf + tokstart_diff;
         te = buf + tokend_diff;
         d->start = buf + start_diff;
+        mark_row_sep = buf + mark_row_sep_diff;
       }
       p = buf + have;
 
@@ -408,7 +443,7 @@ static VALUE raw_parse(int argc, VALUE *argv, VALUE self) {
     %% write exec;
 
     if (done && cs < raw_parse_first_final) {
-      if (d->start == 0 || p == d->start) {
+      if (d->start == 0 || p == d->start) { // same as new_row
         rb_ivar_set(self, s_row, rb_str_new2(""));
       }
       else if (p > d->start) {

data/fastcsv.gemspec

@@ -2,12 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name        = "fastcsv"
-  s.version     = '0.0.4'
+  s.version     = '0.0.5'
   s.platform    = Gem::Platform::RUBY
-  s.authors     = ["Open North"]
-  s.email       = ["info@opennorth.ca"]
-  s.homepage    = "http://github.com/opennorth/fastcsv"
-  s.summary     = %q{A fast Ragel-based CSV parser}
+  s.authors     = ["James McKinney"]
+  s.homepage    = "https://github.com/jpmckinney/fastcsv"
+  s.summary     = %q{A fast Ragel-based CSV parser, compatible with Ruby's CSV}
   s.license     = 'MIT'
 
   s.files         = `git ls-files`.split("\n")
@@ -17,7 +16,7 @@ Gem::Specification.new do |s|
   s.extensions    = ["ext/fastcsv/extconf.rb"]
 
   s.add_development_dependency('coveralls')
-  s.add_development_dependency('json', '~> 1.7.7') # to silence coveralls warning
+  s.add_development_dependency('json', '~> 1.8') # to silence coveralls warning
   s.add_development_dependency('rake')
   s.add_development_dependency('rake-compiler')
   s.add_development_dependency('rspec', '~> 3.1')

data/lib/fastcsv.rb

@@ -123,7 +123,7 @@ private
           encoding = enc
         end
       end
-      parser.raw_parse(@io, encoding: encoding) do |row|
+      parser.raw_parse(@io, encoding: encoding, quote_char: quote_char, col_sep: col_sep) do |row|
         Fiber.yield(row)
       end
     end

data/spec/fastcsv_spec.rb

@@ -147,7 +147,6 @@ RSpec.shared_examples 'a CSV parser' do
   it 'should raise an error on mixed row separators' do
     csv = "foo\rbar\nbaz\r\n"
     expect{CSV.parse(csv)}.to raise_error(CSV::MalformedCSVError, 'Unquoted fields do not allow \r or \n (line 2).')
-    skip
     expect{FastCSV.parse(csv)}.to raise_error(FastCSV::MalformedCSVError, 'Unquoted fields do not allow \r or \n (line 2).')
   end
 

data/test/csv/test_csv_parsing.rb

@@ -160,16 +160,16 @@ class TestCSV::Parsing < TestCSV
     assert_equal(6, lines.size)
     assert_match(/\Aline,4/, lines.find { |l| l =~ /some\rjunk/ })
 
-    # csv = FastCSV.new(bad_data)
-    # begin
-    #   loop do
-    #     assert_not_nil(csv.shift)
-    #     assert_send([csv.lineno, :<, 5]) # FIXME 4
-    #   end
-    # rescue FastCSV::MalformedCSVError
-    #   assert_equal( "Unquoted fields do not allow \\r or \\n (line 4).",
-    #                 $!.message )
-    # end
+    csv = FastCSV.new(bad_data)
+    begin
+      loop do
+        assert_not_nil(csv.shift)
+        assert_send([csv.lineno, :<, 5]) # FIXME 4
+      end
+    rescue FastCSV::MalformedCSVError
+      assert_equal( "Unquoted fields do not allow \\r or \\n (line 4).",
+                    $!.message )
+    end
 
     assert_raise(FastCSV::MalformedCSVError) { FastCSV.parse_line('1,2,"3...') }
 

data/test/csv/test_encodings.rb

@@ -72,7 +72,7 @@ class TestCSV::Encodings < TestCSV
     each_encoding do |encoding|
       begin
         assert_parses( [ %w[ abc def ],
-                         %w[ ghi jkl ] ], encoding, col_sep: "," )
+                         %w[ ghi jkl ] ], encoding, col_sep: "|" )
       rescue Encoding::ConverterNotFoundError
         fail("Failed to properly escape #{encoding.name}.")
       end
@@ -112,8 +112,8 @@ class TestCSV::Encodings < TestCSV
   def test_csv_chars_are_transcoded
     encode_for_tests([%w[abc def]]) do |data|
       %w[col_sep row_sep quote_char].each do |csv_char|
-        assert_equal( ",".encode(data.encoding),
-                      FastCSV.new(data, csv_char.to_sym => ",").send(csv_char) )
+        assert_equal( "|".encode(data.encoding),
+                      FastCSV.new(data, csv_char.to_sym => "|").send(csv_char) )
       end
     end
   end
@@ -221,15 +221,15 @@ class TestCSV::Encodings < TestCSV
     each_encoding do |encoding|
       # test generate_line with encoding hint
       begin
-        csv = %w[abc d,ef].map { |f| f.encode(encoding) }.
-          to_csv(col_sep: ",", encoding: encoding.name)
+        csv = %w[abc d|ef].map { |f| f.encode(encoding) }.
+          to_csv(col_sep: "|", encoding: encoding.name)
       rescue Encoding::ConverterNotFoundError
         next
       end
       assert_equal(encoding, csv.encoding)
 
       # test generate_line with encoding guessing from fields
-      csv = %w[abc d,ef].map { |f| f.encode(encoding) }.to_csv(col_sep: ",")
+      csv = %w[abc d|ef].map { |f| f.encode(encoding) }.to_csv(col_sep: "|")
       assert_equal(encoding, csv.encoding)
 
       # writing to files
@@ -283,23 +283,23 @@ class TestCSV::Encodings < TestCSV
       end unless encoding == __ENCODING__
     rescue Encoding::ConverterNotFoundError
     end
-    # options[:encoding] = encoding.name
-    # FastCSV.open(@temp_csv_path, options) do |csv|
-    #   csv.each_with_index do |row, i|
-    #     assert_equal(fields[i], row)
-    #   end
-    # end
-    # options.delete(:encoding)
-    # options[:external_encoding] = encoding.name
-    # options[:internal_encoding] = __ENCODING__.name
-    # begin
-    #   FastCSV.open(@temp_csv_path, options) do |csv|
-    #     csv.each_with_index do |row, i|
-    #       assert_equal(orig_fields[i], row)
-    #     end
-    #   end unless encoding == __ENCODING__
-    # rescue Encoding::ConverterNotFoundError
-    # end
+    options[:encoding] = encoding.name
+    FastCSV.open(@temp_csv_path, options) do |csv|
+      csv.each_with_index do |row, i|
+        assert_equal(fields[i], row)
+      end
+    end
+    options.delete(:encoding)
+    options[:external_encoding] = encoding.name
+    options[:internal_encoding] = __ENCODING__.name
+    begin
+      FastCSV.open(@temp_csv_path, options) do |csv|
+        csv.each_with_index do |row, i|
+          assert_equal(orig_fields[i], row)
+        end
+      end unless encoding == __ENCODING__
+    rescue Encoding::ConverterNotFoundError
+    end
   end
 
   def encode_ary(ary, encoding)

data/test/csv/test_features.rb

@@ -47,16 +47,16 @@ class TestCSV::Features < TestCSV
     @csv = FastCSV.new(@sample_data)
   end
 
-  # def test_col_sep
-  #   [";", "\t"].each do |sep|
-  #     TEST_CASES.each do |test_case|
-  #       assert_equal( test_case.last.map { |t| t.tr(",", sep) unless t.nil? },
-  #                     FastCSV.parse_line( test_case.first.tr(",", sep),
-  #                                     col_sep: sep ) )
-  #     end
-  #   end
-  #   assert_equal([",,,", nil], FastCSV.parse_line(",,,;", col_sep: ";"))
-  # end
+  def test_col_sep
+    [";", "\t"].each do |sep|
+      TEST_CASES.each do |test_case|
+        assert_equal( test_case.last.map { |t| t.tr(",", sep) unless t.nil? },
+                      FastCSV.parse_line( test_case.first.tr(",", sep),
+                                      col_sep: sep ) )
+      end
+    end
+    assert_equal([",,,", nil], FastCSV.parse_line(",,,;", col_sep: ";"))
+  end
 
   # def test_row_sep
   #   assert_raise(FastCSV::MalformedCSVError) do
@@ -66,13 +66,13 @@ class TestCSV::Features < TestCSV
   #                 FastCSV.parse_line(%Q{1,2,"3\n",4,5\r\n}, row_sep: "\r\n"))
   # end
 
-  # def test_quote_char
-  #   TEST_CASES.each do |test_case|
-  #     assert_equal( test_case.last.map { |t| t.tr('"', "'") unless t.nil? },
-  #                   FastCSV.parse_line( test_case.first.tr('"', "'"),
-  #                                   quote_char: "'" ) )
-  #   end
-  # end
+  def test_quote_char
+    TEST_CASES.each do |test_case|
+      assert_equal( test_case.last.map { |t| t.tr('"', "'") unless t.nil? },
+                    FastCSV.parse_line( test_case.first.tr('"', "'"),
+                                    quote_char: "'" ) )
+    end
+  end
 
   def test_csv_char_readers
     %w[col_sep row_sep quote_char].each do |reader|

data/test/csv/test_headers.rb

@@ -131,20 +131,20 @@ class TestCSV::Headers < TestCSV
     assert(!row.field_row?)
   end
 
-  # def test_csv_header_string_inherits_separators
-  #   # parse with custom col_sep
-  #   csv = nil
-  #   assert_nothing_raised(Exception) do
-  #     csv = FastCSV.parse( @data.tr(",", "|"), col_sep: "|",
-  #                                          headers: "my|new|headers" )
-  #   end
-
-  #   # verify headers were recognized
-  #   row = csv[0]
-  #   assert_not_nil(row)
-  #   assert_instance_of(FastCSV::Row, row)
-  #   assert_equal([%w{my first}, %w{new second}, %w{headers third}], row.to_a)
-  # end
+  def test_csv_header_string_inherits_separators
+    # parse with custom col_sep
+    csv = nil
+    assert_nothing_raised(Exception) do
+      csv = FastCSV.parse( @data.tr(",", "|"), col_sep: "|",
+                                           headers: "my|new|headers" )
+    end
+
+    # verify headers were recognized
+    row = csv[0]
+    assert_not_nil(row)
+    assert_instance_of(FastCSV::Row, row)
+    assert_equal([%w{my first}, %w{new second}, %w{headers third}], row.to_a)
+  end
 
   def test_return_headers
     # activate headers and request they are returned

data/test/csv/test_interface.rb

@@ -20,8 +20,8 @@ class TestCSV::Interface < TestCSV
     @path = @tempfile.path
 
     File.open(@path, "wb") do |file|
-      file << "1,2,3\r\n"
-      file << "4,5\r\n"
+      file << "1\t2\t3\r\n"
+      file << "4\t5\r\n"
     end
 
     @expected = [%w{1 2 3}, %w{4 5}]
@@ -35,19 +35,19 @@ class TestCSV::Interface < TestCSV
   ### Test Read Interface ###
 
   def test_foreach
-    FastCSV.foreach(@path, col_sep: ",", row_sep: "\r\n") do |row|
+    FastCSV.foreach(@path, col_sep: "\t", row_sep: "\r\n") do |row|
       assert_equal(@expected.shift, row)
     end
   end
 
   def test_foreach_enum
-    FastCSV.foreach(@path, col_sep: ",", row_sep: "\r\n").zip(@expected) do |row, exp|
+    FastCSV.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 = FastCSV.open(@path, "r+", col_sep: ",", row_sep: "\r\n")
+    csv = FastCSV.open(@path, "r+", col_sep: "\t", row_sep: "\r\n")
     assert_not_nil(csv)
     assert_instance_of(FastCSV, csv)
     assert_equal(false, csv.closed?)
@@ -66,21 +66,21 @@ class TestCSV::Interface < TestCSV
   def test_parse
     data = File.binread(@path)
     assert_equal( @expected,
-                  FastCSV.parse(data, col_sep: ",", row_sep: "\r\n") )
+                  FastCSV.parse(data, col_sep: "\t", row_sep: "\r\n") )
 
-    FastCSV.parse(data, col_sep: ",", row_sep: "\r\n") do |row|
+    FastCSV.parse(data, col_sep: "\t", row_sep: "\r\n") do |row|
       assert_equal(@expected.shift, row)
     end
   end
 
   def test_parse_line
-    row = FastCSV.parse_line("1,2,3", col_sep: ",")
+    row = FastCSV.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: ",")
+    row = "1;2;3".parse_csv(col_sep: ";")
     assert_not_nil(row)
     assert_instance_of(Array, row)
     assert_equal(%w{1 2 3}, row)
@@ -93,29 +93,29 @@ class TestCSV::Interface < TestCSV
 
   def test_read_and_readlines
     assert_equal( @expected,
-                  FastCSV.read(@path, col_sep: ",", row_sep: "\r\n") )
+                  FastCSV.read(@path, col_sep: "\t", row_sep: "\r\n") )
     assert_equal( @expected,
-                  FastCSV.readlines(@path, col_sep: ",", row_sep: "\r\n") )
+                  FastCSV.readlines(@path, col_sep: "\t", row_sep: "\r\n") )
 
 
-    data = FastCSV.open(@path, col_sep: ",", row_sep: "\r\n") do |csv|
+    data = FastCSV.open(@path, col_sep: "\t", row_sep: "\r\n") do |csv|
       csv.read
     end
     assert_equal(@expected, data)
-    data = FastCSV.open(@path, col_sep: ",", row_sep: "\r\n") do |csv|
+    data = FastCSV.open(@path, col_sep: "\t", row_sep: "\r\n") do |csv|
       csv.readlines
     end
     assert_equal(@expected, data)
   end
 
   def test_table
-    table = FastCSV.table(@path, col_sep: ",", row_sep: "\r\n")
+    table = FastCSV.table(@path, col_sep: "\t", row_sep: "\r\n")
     assert_instance_of(FastCSV::Table, table)
     assert_equal([[:"1", :"2", :"3"], [4, 5, nil]], table.to_a)
   end
 
   def test_shift  # aliased as gets() and readline()
-    FastCSV.open(@path, "rb+", col_sep: ",", row_sep: "\r\n") do |csv|
+    FastCSV.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)
@@ -123,7 +123,7 @@ class TestCSV::Interface < TestCSV
   end
 
   def test_enumerators_are_supported
-    FastCSV.open(@path, col_sep: ",", row_sep: "\r\n") do |csv|
+    FastCSV.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)
@@ -149,16 +149,16 @@ class TestCSV::Interface < TestCSV
   end
 
   def test_generate_line
-    line = FastCSV.generate_line(%w{1 2 3}, col_sep: ",")
+    line = FastCSV.generate_line(%w{1 2 3}, col_sep: ";")
     assert_not_nil(line)
     assert_instance_of(String, line)
-    assert_equal("1,2,3\n", line)
+    assert_equal("1;2;3\n", line)
 
     # shortcut interface
-    line = %w{1 2 3}.to_csv(col_sep: ",")
+    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)
+    assert_equal("1;2;3\n", line)
   end
 
   def test_write_header_detection
@@ -242,19 +242,19 @@ class TestCSV::Interface < TestCSV
     File.unlink(@path)
 
     lines = [{"a" => 1, "b" => 2, "c" => 3}, {"a" => 4, "b" => 5, "c" => 6}]
-    FastCSV.open(@path, "wb", headers: "b,a,c", col_sep: ",") do |csv|
+    FastCSV.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)
+      assert_equal("2|1|3", f.gets.strip)
+      assert_equal("5|4|6", f.gets.strip)
     end
 
     # test reading FastCSV with headers
-    FastCSV.open( @path, "rb", headers:    "b,a,c",
-                           col_sep:    ",",
+    FastCSV.open( @path, "rb", headers:    "b|a|c",
+                           col_sep:    "|",
                            converters: :all ) do |csv|
       csv.each { |line| assert_equal(lines.shift, line.to_hash) }
     end
@@ -264,22 +264,22 @@ class TestCSV::Interface < TestCSV
     File.unlink(@path)
 
     lines = [{"a" => 1, "b" => 2, "c" => 3}, {"a" => 4, "b" => 5, "c" => 6}]
-    FastCSV.open( @path, "wb", headers:       "b,a,c",
+    FastCSV.open( @path, "wb", headers:       "b|a|c",
                            write_headers: true,
-                           col_sep:       "," ) do |csv|
+                           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)
+      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 FastCSV with headers
     FastCSV.open( @path, "rb", headers:    true,
-                           col_sep:    ",",
+                           col_sep:    "|",
                            converters: :all ) do |csv|
       csv.each { |line| assert_equal(lines.shift, line.to_hash) }
     end
@@ -288,7 +288,7 @@ class TestCSV::Interface < TestCSV
   def test_append  # aliased add_row() and puts()
     File.unlink(@path)
 
-    FastCSV.open(@path, "wb", col_sep: ",", row_sep: "\r\n") do |csv|
+    FastCSV.open(@path, "wb", col_sep: "\t", row_sep: "\r\n") do |csv|
       @expected.each { |row| csv << row }
     end
 
@@ -297,7 +297,7 @@ class TestCSV::Interface < TestCSV
     # same thing using FastCSV::Row objects
     File.unlink(@path)
 
-    FastCSV.open(@path, "wb", col_sep: ",", row_sep: "\r\n") do |csv|
+    FastCSV.open(@path, "wb", col_sep: "\t", row_sep: "\r\n") do |csv|
       @expected.each { |row| csv << FastCSV::Row.new(Array.new, row) }
     end
 
@@ -310,8 +310,8 @@ class TestCSV::Interface < TestCSV
     assert_respond_to(FastCSV, :filter)
 
     expected = [[1, 2, 3], [4, 5]]
-    FastCSV.filter( "1,2,3\n4,5\n", (result = String.new),
-                in_col_sep: ",", out_col_sep: ",",
+    FastCSV.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 }
@@ -325,20 +325,20 @@ class TestCSV::Interface < TestCSV
 
     first = nil
     assert_nothing_raised(Exception) do
-      first =  FastCSV.instance(csv, col_sep: ",")
+      first =  FastCSV.instance(csv, col_sep: ";")
       first << %w{a b c}
     end
 
-    assert_equal("a,b,c\n", csv)
+    assert_equal("a;b;c\n", csv)
 
     second = nil
     assert_nothing_raised(Exception) do
-      second =  FastCSV.instance(csv, col_sep: ",")
+      second =  FastCSV.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)
+    assert_equal("a;b;c\n1;2;3\n", csv)
 
     # shortcuts
     assert_equal(STDOUT, FastCSV.instance.instance_eval { @io })