fastcsv 0.0.2 → 0.0.3

data/spec/fastcsv_spec.rb

@@ -1,6 +1,7 @@
+# coding: utf-8
 require 'spec_helper'
 
-require 'csv'
+$ORIGINAL_VERBOSE = $VERBOSE
 
 RSpec.shared_examples 'a CSV parser' do
   let :simple do
@@ -61,7 +62,6 @@ RSpec.shared_examples 'a CSV parser' do
     %('foo','bar','baz'),
 
     # Buffers.
-    "01234567890" * 2_000, # 20,000 > BUFSIZE
     "0123456789," * 2_000,
 
     # Uneven rows.
@@ -76,23 +76,44 @@ RSpec.shared_examples 'a CSV parser' do
     end
   end
 
+  # This has caused segmentation faults in the StringIO context in the past, so
+  # we separate it out so that it's easier to special case this spec. The fault
+  # seems to occur less frequently when the spec is run in isolation. The
+  # "TypeError: no implicit conversion from nil to integer" exception after a
+  # fault is related to RSpec, not the fault.
+  it "should parse long rows" do
+    csv = "01234567890" * 2_000 # 20,000 > BUFSIZE
+    expect(parse(csv)).to eq(CSV.parse(csv))
+  end
+
   [
     # Whitespace.
-    # @note Ruby's CSV library has inexplicably inconsistent error messages for
-    #   the same class of error.
+    #
+    # CSV's error messages are a consequence of its parser's implementation. It
+    # splits on :col_sep and then reads parts, making it possible to identify
+    # its "Missing or stray quote". FastCSV, as a state machine, wouldn't even
+    # get that far, as it would simply find no match and quit.
+    #
+    # * "Missing or stray quote in line %d" if quoted field matches /[^"]"[^"]/
+    #   (for any quote char). Raises "Unclosed quoted field" instead if the
+    #   quoted field has an odd number of quote chars.
+    # * "Unquoted fields do not allow \r or \n (line \d)." if unquoted field
+    #   contains "\r" or "\n", e.g. if `:row_sep` is "\n" but file uses "\r"
+    # * "Illegal quoting in line %d" if unquoted field contains quote char.
+    # * "Unclosed quoted field on line %d" if reaches EOF without closing.
     [%(   "x"), 'Illegal quoting in line %d.', 'Illegal quoting in line %d.'],
-    [%("x"   ), 'Unclosed quoted field on line %d.', 'Illegal quoting in line %d.'],
+    [%("x"   ), 'Unclosed quoted field on line %d.', 'Illegal quoting in line %d.'], # WONTFIX
     [%(   "x"   ), 'Illegal quoting in line %d.', 'Illegal quoting in line %d.'],
     # Tab.
     [%(	"x"), 'Illegal quoting in line %d.', 'Illegal quoting in line %d.'],
-    [%("x"	), 'Unclosed quoted field on line %d.', 'Illegal quoting in line %d.'],
+    [%("x"	), 'Unclosed quoted field on line %d.', 'Illegal quoting in line %d.'], # WONTFIX
     [%(	"x"	), 'Illegal quoting in line %d.', 'Illegal quoting in line %d.'],
 
     # Quoted next to unquoted.
-    [%("x"x), 'Unclosed quoted field on line %d.', 'Illegal quoting in line %d.'],
+    [%("x"x), 'Unclosed quoted field on line %d.', 'Illegal quoting in line %d.'], # WONTFIX
     [%(x"x"), 'Illegal quoting in line %d.', 'Illegal quoting in line %d.'],
     [%(x"x"x), 'Illegal quoting in line %d.', 'Illegal quoting in line %d.'],
-    [%("x"x"x"), 'Missing or stray quote in line %d', 'Illegal quoting in line %d.'],
+    [%("x"x"x"), 'Missing or stray quote in line %d', 'Illegal quoting in line %d.'], # WONTFIX
 
     # Unclosed quote.
     [%("x), 'Unclosed quoted field on line %d.', 'Unclosed quoted field on line %d.'],
@@ -101,17 +122,17 @@ RSpec.shared_examples 'a CSV parser' do
     [%(x"x), 'Illegal quoting in line %d.', 'Illegal quoting in line %d.'],
 
     # Unescaped quote in quoted field.
-    [%("x"x"), 'Unclosed quoted field on line %d.', 'Illegal quoting in line %d.'],
+    [%("x"x"), 'Unclosed quoted field on line %d.', 'Illegal quoting in line %d.'], # WONTFIX
   ].each do |csv,csv_error,fastcsv_error|
     it "should raise an error on: #{csv.inspect.gsub('\"', '"')}" do
       expect{CSV.parse(csv)}.to raise_error(CSV::MalformedCSVError, csv_error % 1)
-      expect{parse(csv)}.to raise_error(FastCSV::ParseError, fastcsv_error % 1)
+      expect{parse(csv)}.to raise_error(FastCSV::MalformedCSVError, fastcsv_error % 1)
     end
 
     it "should raise an error with the correct line number on: #{"\n#{csv}\n".inspect.gsub('\"', '"')}" do
       csv = "\n#{csv}\n"
       expect{CSV.parse(csv)}.to raise_error(CSV::MalformedCSVError, csv_error % 2)
-      expect{parse(csv)}.to raise_error(FastCSV::ParseError, fastcsv_error % 2)
+      expect{parse(csv)}.to raise_error(FastCSV::MalformedCSVError, fastcsv_error % 2)
     end
   end
 
@@ -123,9 +144,10 @@ RSpec.shared_examples 'a CSV parser' do
     expect(actual).to eq(expected)
   end
 
-  it 'should raise an error on mixed row separators are' do
-    expect{CSV.parse("foo\rbar\nbaz\r\n")}.to raise_error(CSV::MalformedCSVError, 'Unquoted fields do not allow \r or \n (line 2).')
-    skip
+  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).')
+    expect{FastCSV.parse(csv)}.to raise_error(FastCSV::MalformedCSVError, 'Unquoted fields do not allow \r or \n (line 2).')
   end
 
   context 'when initializing' do
@@ -143,25 +165,82 @@ RSpec.shared_examples 'a CSV parser' do
   end
 
   context 'when setting a buffer size' do
+    def parse_with_buffer_size(csv, buffer_size)
+      parser = FastCSV::Parser.new
+      parser.buffer_size = buffer_size
+      rows = parse(csv, nil, parser)
+      parser.buffer_size = nil
+      rows
+    end
+
     it 'should allow nil' do
-      FastCSV.buffer_size = nil
-      expect(parse(simple)).to eq(CSV.parse(simple))
-      FastCSV.buffer_size = nil
+      expect(parse_with_buffer_size(simple, nil)).to eq(CSV.parse(simple))
     end
 
+    # If buffer_size is actually set to 0, it can cause segmentation faults.
     it 'should allow zero' do
-      FastCSV.buffer_size = 0
-      expect(parse(simple)).to eq(CSV.parse(simple))
-      FastCSV.buffer_size = nil
+      expect(parse_with_buffer_size(simple, 0)).to eq(CSV.parse(simple))
     end
   end
 end
 
+RSpec.shared_examples 'with encoded strings' do
+  before(:all) do
+    $VERBOSE = nil
+  end
+
+  after(:all) do
+    $VERBOSE = $ORIGINAL_VERBOSE
+  end
+
+  def parse_with_encoding(basename, encoding)
+    filename = File.expand_path(File.join('..', 'fixtures', basename), __FILE__)
+    options = {encoding: encoding}
+    File.open(filename) do |io|
+      rows = []
+      FastCSV.raw_parse(io, options){|row| rows << row}
+      expected = CSV.read(filename, options)
+      expect(rows[0][0].encoding).to eq(expected[0][0].encoding)
+      expect(rows).to eq(expected)
+    end
+  end
+
+  it 'should encode with internal encoding' do
+    parse_with_encoding("iso-8859-1#{suffix}.csv", 'iso-8859-1')
+  end
+
+  it 'should encode with external encoding' do
+    parse_with_encoding("iso-8859-1#{suffix}.csv", 'iso-8859-1:-')
+  end
+
+  it 'should transcode' do
+    parse_with_encoding("iso-8859-1#{suffix}.csv", 'iso-8859-1:utf-8')
+  end
+
+  it 'should recover from blank external encoding' do
+    parse_with_encoding("utf-8#{suffix}.csv", ':utf-8')
+  end
+
+  it 'should recover from invalid internal encoding' do
+    parse_with_encoding("utf-8#{suffix}.csv", 'invalid')
+    parse_with_encoding("utf-8#{suffix}.csv", 'utf-8:invalid')
+  end
+
+  it 'should recover from invalid external encoding' do
+    parse_with_encoding("utf-8#{suffix}.csv", 'invalid:-')
+    parse_with_encoding("utf-8#{suffix}.csv", 'invalid:utf-8')
+  end
+
+  it 'should recover from invalid internal and external encodings' do
+    parse_with_encoding("utf-8#{suffix}.csv", 'invalid:invalid')
+  end
+end
+
 RSpec.describe FastCSV do
   context "with String" do
-    def parse(csv, options = nil)
+    def parse(csv, options = nil, parser = FastCSV)
       rows = []
-      FastCSV.raw_parse(csv, options){|row| rows << row}
+      parser.raw_parse(csv, options){|row| rows << row}
       rows
     end
 
@@ -172,16 +251,17 @@ RSpec.describe FastCSV do
     include_examples 'a CSV parser'
 
     it 'should not raise an error on negative buffer size' do
-      FastCSV.buffer_size = -1
-      expect{parse(simple)}.to_not raise_error
-      FastCSV.buffer_size = nil
+      parser = FastCSV::Parser.new
+      parser.buffer_size = -1
+      expect{parse(simple, nil, parser)}.to_not raise_error
+      parser.buffer_size = nil
     end
   end
 
   context "with StringIO" do
-    def parse(csv, options = nil)
+    def parse(csv, options = nil, parser = FastCSV)
       rows = []
-      FastCSV.raw_parse(StringIO.new(csv), options){|row| rows << row}
+      parser.raw_parse(StringIO.new(csv), options){|row| rows << row}
       rows
     end
 
@@ -192,53 +272,105 @@ RSpec.describe FastCSV do
     include_examples 'a CSV parser'
 
     it 'should raise an error on negative buffer size' do
-      FastCSV.buffer_size = -1
-      expect{parse(simple)}.to raise_error(NoMemoryError)
-      FastCSV.buffer_size = nil
+      parser = FastCSV::Parser.new
+      parser.buffer_size = -1
+      expect{parse(simple, nil, parser)}.to raise_error(NoMemoryError)
+      parser.buffer_size = nil
     end
   end
 
-  context 'with encoded strings' do
-    def parse_with_encoding(basename, encoding)
-      filename = File.expand_path(File.join('..', 'fixtures', basename), __FILE__)
-      options = {encoding: encoding}
-      File.open(filename) do |io|
-        rows = []
-        FastCSV.raw_parse(io, options){|row| rows << row}
-        expected = CSV.read(filename, options)
-        expect(rows[0][0].encoding).to eq(expected[0][0].encoding)
-        expect(rows).to eq(expected)
-      end
+  context 'with encoded unquoted fields' do
+    def suffix
+      ''
+    end
+
+    include_examples 'with encoded strings'
+  end
+
+  context 'with encoded quoted fields' do
+    def suffix
+      '-quoted'
+    end
+
+    include_examples 'with encoded strings'
+  end
+
+  context 'when initializing' do
+    it 'should raise an error if the input is not a String or IO' do
+      expect{FastCSV.raw_parse(nil)}.to raise_error(ArgumentError, 'data has to respond to #read or #to_str')
     end
+  end
 
-    it 'should encode' do
-      parse_with_encoding('iso-8859-1.csv', 'iso-8859-1')
+  describe '#row' do
+    [
+      "",
+      "\n",
+      "\n\n",
+      "a,b,",
+      "a,b,\n",
+      "a,b,\nx,y,\n",
+      "a,b,c",
+      "a,b,c\n",
+      "a,b,c\nx,y,z\n",
+    ].each do |csv|
+      it "should return the current row for: #{csv.inspect.gsub('\"', '"')}" do
+        parser = FastCSV::Parser.new
+        rows = []
+        parser.raw_parse(csv) do |row|
+          rows << parser.row
+        end
+        expect(rows).to eq(CSV.parse(csv).map{|row| CSV.generate_line(row).chomp("\n")})
+      end
     end
+  end
 
-    it 'should transcode' do
-      parse_with_encoding('iso-8859-1.csv', 'iso-8859-1:utf-8')
+  context 'with IO methods' do
+    let(:csv) do
+      FastCSV.open(File.expand_path(File.join('..', 'fixtures', 'csv.csv'), __FILE__))
     end
 
-    it 'should recover from blank external encoding' do
-      parse_with_encoding('utf-8.csv', ':utf-8')
+    let(:csv2) do
+      FastCSV.open(File.expand_path(File.join('..', 'fixtures', 'csv.csv'), __FILE__))
     end
 
-    it 'should recover from invalid internal encoding' do
-      parse_with_encoding('utf-8.csv', 'invalid')
+    describe '#pos=' do
+      it 'should read from the new position' do
+        expect(csv.shift).to eq(%w(name age))
+        expect(csv.shift).to eq(%w(Alice 42))
+        csv.pos = 9
+        expect(csv.shift).to eq(%w(Alice 42))
+        expect(csv.shift).to eq(%w(Bob 40))
+      end
     end
 
-    it 'should recover from invalid external encoding' do
-      parse_with_encoding('utf-8.csv', 'invalid:-')
+    describe '#reopen' do
+      it 'should read from the new position' do
+        expect(csv.shift).to eq(%w(name age))
+        expect(csv.shift).to eq(%w(Alice 42))
+        csv.reopen(csv2)
+        expect(csv.shift).to eq(%w(name age))
+        expect(csv.shift).to eq(%w(Alice 42))
+      end
     end
 
-    it 'should recover from invalid encodings' do
-      parse_with_encoding('utf-8.csv', 'invalid:invalid')
+    describe '#seek' do
+      it 'should read from the new position' do
+        expect(csv.shift).to eq(%w(name age))
+        expect(csv.shift).to eq(%w(Alice 42))
+        csv.seek(9)
+        expect(csv.shift).to eq(%w(Alice 42))
+        expect(csv.shift).to eq(%w(Bob 40))
+      end
     end
-  end
 
-  context 'when initializing' do
-    it 'should raise an error if the input is not a String or IO' do
-      expect{FastCSV.raw_parse(nil)}.to raise_error(ArgumentError, 'data has to respond to #read or #to_str')
+    describe '#rewind' do
+      it 'should read from the new position' do
+        expect(csv.shift).to eq(%w(name age))
+        expect(csv.shift).to eq(%w(Alice 42))
+        csv.rewind
+        expect(csv.shift).to eq(%w(name age))
+        expect(csv.shift).to eq(%w(Alice 42))
+      end
     end
   end
 end

data/spec/fixtures/csv.csv

@@ -0,0 +1,3 @@
+name,age
+Alice,42
+Bob,40

data/spec/fixtures/iso-8859-1-quoted.csv

@@ -0,0 +1 @@
+ñ

data/spec/fixtures/utf-8-quoted.csv

@@ -0,0 +1 @@
+"ñ"

data/spec/spec_helper.rb

@@ -1,6 +1,11 @@
 require 'coveralls'
 Coveralls.wear!
 
+SimpleCov.start do
+  add_filter '/spec/'
+  add_filter '/test/'
+end
+
 RSpec.configure do |config|
   config.expect_with :rspec do |expectations|
     expectations.include_chain_clauses_in_custom_matcher_descriptions = true

data/test/csv/base.rb

@@ -0,0 +1,8 @@
+require "test/unit"
+
+require "csv"
+
+require_relative "../with_different_ofs.rb"
+
+class TestCSV < Test::Unit::TestCase
+end

data/test/csv/test_csv_parsing.rb

@@ -0,0 +1,221 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+
+# tc_csv_parsing.rb
+#
+#  Created by James Edward Gray II on 2005-10-31.
+#  Copyright 2005 James Edward Gray II. You can redistribute or modify this code
+#  under the terms of Ruby's license.
+
+require "timeout"
+
+require_relative "base"
+
+#
+# Following tests are my interpretation of the
+# {FastCSV RCF}[http://www.ietf.org/rfc/rfc4180.txt].  I only deviate from that
+# document in one place (intentionally) and that is to make the default row
+# separator <tt>$/</tt>.
+#
+class TestCSV::Parsing < TestCSV
+  extend DifferentOFS
+
+  BIG_DATA = "123456789\n" * 1024
+
+  def test_mastering_regex_example
+    ex = %Q{Ten Thousand,10000, 2710 ,,"10,000","It's ""10 Grand"", baby",10K}
+    assert_equal( [ "Ten Thousand", "10000", " 2710 ", nil, "10,000",
+                    "It's \"10 Grand\", baby", "10K" ],
+                  FastCSV.parse_line(ex) )
+  end
+
+  # Old Ruby 1.8 FastCSV library tests.
+  def test_std_lib_csv
+    [ ["\t", ["\t"]],
+      ["foo,\"\"\"\"\"\",baz", ["foo", "\"\"", "baz"]],
+      ["foo,\"\"\"bar\"\"\",baz", ["foo", "\"bar\"", "baz"]],
+      ["\"\"\"\n\",\"\"\"\n\"", ["\"\n", "\"\n"]],
+      ["foo,\"\r\n\",baz", ["foo", "\r\n", "baz"]],
+      ["\"\"", [""]],
+      ["foo,\"\"\"\",baz", ["foo", "\"", "baz"]],
+      ["foo,\"\r.\n\",baz", ["foo", "\r.\n", "baz"]],
+      ["foo,\"\r\",baz", ["foo", "\r", "baz"]],
+      ["foo,\"\",baz", ["foo", "", "baz"]],
+      ["\",\"", [","]],
+      ["foo", ["foo"]],
+      [",,", [nil, nil, nil]],
+      [",", [nil, nil]],
+      ["foo,\"\n\",baz", ["foo", "\n", "baz"]],
+      ["foo,,baz", ["foo", nil, "baz"]],
+      ["\"\"\"\r\",\"\"\"\r\"", ["\"\r", "\"\r"]],
+      ["\",\",\",\"", [",", ","]],
+      ["foo,bar,", ["foo", "bar", nil]],
+      [",foo,bar", [nil, "foo", "bar"]],
+      ["foo,bar", ["foo", "bar"]],
+      [";", [";"]],
+      ["\t,\t", ["\t", "\t"]],
+      ["foo,\"\r\n\r\",baz", ["foo", "\r\n\r", "baz"]],
+      ["foo,\"\r\n\n\",baz", ["foo", "\r\n\n", "baz"]],
+      ["foo,\"foo,bar\",baz", ["foo", "foo,bar", "baz"]],
+      [";,;", [";", ";"]] ].each do |csv_test|
+      assert_equal(csv_test.last, FastCSV.parse_line(csv_test.first))
+    end
+
+    [ ["foo,\"\"\"\"\"\",baz", ["foo", "\"\"", "baz"]],
+      ["foo,\"\"\"bar\"\"\",baz", ["foo", "\"bar\"", "baz"]],
+      ["foo,\"\r\n\",baz", ["foo", "\r\n", "baz"]],
+      ["\"\"", [""]],
+      ["foo,\"\"\"\",baz", ["foo", "\"", "baz"]],
+      ["foo,\"\r.\n\",baz", ["foo", "\r.\n", "baz"]],
+      ["foo,\"\r\",baz", ["foo", "\r", "baz"]],
+      ["foo,\"\",baz", ["foo", "", "baz"]],
+      ["foo", ["foo"]],
+      [",,", [nil, nil, nil]],
+      [",", [nil, nil]],
+      ["foo,\"\n\",baz", ["foo", "\n", "baz"]],
+      ["foo,,baz", ["foo", nil, "baz"]],
+      ["foo,bar", ["foo", "bar"]],
+      ["foo,\"\r\n\n\",baz", ["foo", "\r\n\n", "baz"]],
+      ["foo,\"foo,bar\",baz", ["foo", "foo,bar", "baz"]] ].each do |csv_test|
+      assert_equal(csv_test.last, FastCSV.parse_line(csv_test.first))
+    end
+  end
+
+  # From:  http://ruby-talk.org/cgi-bin/scat.rb/ruby/ruby-core/6496
+  def test_aras_edge_cases
+    [ [%Q{a,b},               ["a", "b"]],
+      [%Q{a,"""b"""},         ["a", "\"b\""]],
+      [%Q{a,"""b"},           ["a", "\"b"]],
+      [%Q{a,"b"""},           ["a", "b\""]],
+      [%Q{a,"\nb"""},         ["a", "\nb\""]],
+      [%Q{a,"""\nb"},         ["a", "\"\nb"]],
+      [%Q{a,"""\nb\n"""},     ["a", "\"\nb\n\""]],
+      [%Q{a,"""\nb\n""",\nc}, ["a", "\"\nb\n\"", nil]],
+      [%Q{a,,,},              ["a", nil, nil, nil]],
+      [%Q{,},                 [nil, nil]],
+      [%Q{"",""},             ["", ""]],
+      [%Q{""""},              ["\""]],
+      [%Q{"""",""},           ["\"",""]],
+      [%Q{,""},               [nil,""]],
+      [%Q{,"\r"},             [nil,"\r"]],
+      [%Q{"\r\n,"},           ["\r\n,"]],
+      [%Q{"\r\n,",},          ["\r\n,", nil]] ].each do |edge_case|
+        assert_equal(edge_case.last, FastCSV.parse_line(edge_case.first))
+      end
+  end
+
+  def test_james_edge_cases
+    # A read at eof? should return nil.
+    assert_equal(nil, FastCSV.parse_line(""))
+    #
+    # With Ruby 1.8 FastCSV it's impossible to tell an empty line from a line
+    # containing a single +nil+ field.  The old FastCSV library returns
+    # <tt>[nil]</tt> in these cases, but <tt>Array.new</tt> makes more sense to
+    # me.
+    #
+    assert_equal(Array.new, FastCSV.parse_line("\n1,2,3\n"))
+  end
+
+  def test_rob_edge_cases
+    [ [%Q{"a\nb"},                         ["a\nb"]],
+      [%Q{"\n\n\n"},                       ["\n\n\n"]],
+      [%Q{a,"b\n\nc"},                     ['a', "b\n\nc"]],
+      [%Q{,"\r\n"},                        [nil,"\r\n"]],
+      [%Q{,"\r\n."},                       [nil,"\r\n."]],
+      [%Q{"a\na","one newline"},           ["a\na", 'one newline']],
+      [%Q{"a\n\na","two newlines"},        ["a\n\na", 'two newlines']],
+      [%Q{"a\r\na","one CRLF"},            ["a\r\na", 'one CRLF']],
+      [%Q{"a\r\n\r\na","two CRLFs"},       ["a\r\n\r\na", 'two CRLFs']],
+      [%Q{with blank,"start\n\nfinish"\n}, ['with blank', "start\n\nfinish"]],
+    ].each do |edge_case|
+      assert_equal(edge_case.last, FastCSV.parse_line(edge_case.first))
+    end
+  end
+
+  def test_non_regex_edge_cases
+    # An early version of the non-regex parser fails this test
+    [ [ "foo,\"foo,bar,baz,foo\",\"foo\"",
+        ["foo", "foo,bar,baz,foo", "foo"] ] ].each do |edge_case|
+      assert_equal(edge_case.last, FastCSV.parse_line(edge_case.first))
+    end
+
+    assert_raise(FastCSV::MalformedCSVError) do
+      FastCSV.parse_line("1,\"23\"4\"5\", 6")
+    end
+  end
+
+  def test_malformed_csv
+    # assert_raise(FastCSV::MalformedCSVError) do
+    #   FastCSV.parse_line("1,2\r,3", row_sep: "\n")
+    # end
+
+    bad_data = <<-END_DATA.gsub(/^ +/, "")
+    line,1,abc
+    line,2,"def\nghi"
+
+    line,4,some\rjunk
+    line,5,jkl
+    END_DATA
+    lines = bad_data.lines.to_a
+    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
+
+    assert_raise(FastCSV::MalformedCSVError) { FastCSV.parse_line('1,2,"3...') }
+
+    bad_data = <<-END_DATA.gsub(/^ +/, "")
+    line,1,abc
+    line,2,"def\nghi"
+
+    line,4,8'10"
+    line,5,jkl
+    END_DATA
+    lines = bad_data.lines.to_a
+    assert_equal(6, lines.size)
+    assert_match(/\Aline,4/, lines.find { |l| l =~ /8'10"/ })
+
+    csv = FastCSV.new(bad_data)
+    begin
+      loop do
+        assert_not_nil(csv.shift)
+        assert_send([csv.lineno, :<, 4])
+      end
+    rescue FastCSV::MalformedCSVError
+      assert_equal("Illegal quoting in line 4.", $!.message)
+    end
+  end
+
+  def test_the_parse_fails_fast_when_it_can_for_unquoted_fields
+    assert_parse_errors_out('valid,fields,bad start"' + BIG_DATA)
+  end
+
+  def test_the_parse_fails_fast_when_it_can_for_unescaped_quotes
+    assert_parse_errors_out('valid,fields,"bad start"unescaped' + BIG_DATA)
+  end
+
+  # def test_field_size_limit_controls_lookahead
+  #   assert_parse_errors_out( 'valid,fields,"' + BIG_DATA + '"',
+  #                            field_size_limit: 2048 )
+  # end
+
+  private
+
+  def assert_parse_errors_out(*args)
+    assert_raise(FastCSV::MalformedCSVError) do
+      Timeout.timeout(0.2) do
+        FastCSV.parse(*args)
+        fail("Parse didn't error out")
+      end
+    end
+  end
+end