* {ext,lib,test}/**/*.rb: removed trailing spaces.

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@22784 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

10 files changed, 321 insertions, 321 deletions

diff --git a/test/csv/test_csv_parsing.rb b/test/csv/test_csv_parsing.rb
index e391687537..a9e6cd400c 100644
--- a/test/csv/test_csv_parsing.rb
+++ b/test/csv/test_csv_parsing.rb
@@ -12,22 +12,22 @@ require "timeout"
 
 require "csv"
 
-# 
-# Following tests are my interpretation of the 
-# {CSV RCF}[http://www.ietf.org/rfc/rfc4180.txt].  I only deviate from that 
+#
+# Following tests are my interpretation of the
+# {CSV 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 TestCSVParsing < Test::Unit::TestCase
   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" ],
                   CSV.parse_line(ex) )
   end
-  
+
   # Old Ruby 1.8 CSV library tests.
   def test_std_lib_csv
     [ ["\t", ["\t"]],
@@ -79,7 +79,7 @@ class TestCSVParsing < Test::Unit::TestCase
       assert_equal(csv_test.last, CSV.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"]],
@@ -102,35 +102,35 @@ class TestCSVParsing < Test::Unit::TestCase
         assert_equal(edge_case.last, CSV.parse_line(edge_case.first))
       end
   end
-  
+
   def test_james_edge_cases
     # A read at eof? should return nil.
     assert_equal(nil, CSV.parse_line(""))
-    # 
+    #
     # With Ruby 1.8 CSV it's impossible to tell an empty line from a line
     # containing a single +nil+ field.  The old CSV library returns
     # <tt>[nil]</tt> in these cases, but <tt>Array.new</tt> makes more sense to
     # me.
-    # 
+    #
     assert_equal(Array.new, CSV.parse_line("\n1,2,3\n"))
   end
-  
+
   def test_malformed_csv
     assert_raise(CSV::MalformedCSVError) do
       CSV.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 = CSV.new(bad_data)
     begin
       loop do
@@ -141,20 +141,20 @@ class TestCSVParsing < Test::Unit::TestCase
       assert_equal( "Unquoted fields do not allow \\r or \\n (line 4).",
                     $!.message )
     end
-  
+
     assert_raise(CSV::MalformedCSVError) { CSV.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 = CSV.new(bad_data)
     begin
       loop do
@@ -165,22 +165,22 @@ class TestCSVParsing < Test::Unit::TestCase
       assert_equal("Illegal quoting on 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(CSV::MalformedCSVError) do
       Timeout.timeout(0.2) do
diff --git a/test/csv/test_csv_writing.rb b/test/csv/test_csv_writing.rb
index 98e41fe9c4..eacba49613 100644
--- a/test/csv/test_csv_writing.rb
+++ b/test/csv/test_csv_writing.rb
@@ -76,19 +76,19 @@ class TestCSVWriting < Test::Unit::TestCase
         assert_equal(test_case.first + $/, CSV.generate_line(test_case.last))
       end
   end
-  
+
   def test_col_sep
     assert_equal( "a;b;;c\n", CSV.generate_line( ["a", "b", nil, "c"],
                                                  col_sep: ";" ) )
     assert_equal( "a\tb\t\tc\n", CSV.generate_line( ["a", "b", nil, "c"],
                                                     col_sep: "\t" ) )
   end
-  
+
   def test_row_sep
     assert_equal( "a,b,,c\r\n", CSV.generate_line( ["a", "b", nil, "c"],
                                                    row_sep: "\r\n" ) )
   end
-  
+
   def test_force_quotes
     assert_equal( %Q{"1","b","","already ""quoted"""\n},
                   CSV.generate_line( [1, "b", nil, %Q{already "quoted"}],
diff --git a/test/csv/test_data_converters.rb b/test/csv/test_data_converters.rb
index 781450dc9e..1ad5093424 100644
--- a/test/csv/test_data_converters.rb
+++ b/test/csv/test_data_converters.rb
@@ -15,18 +15,18 @@ class TestDataConverters < Test::Unit::TestCase
   def setup
     @data   = "Numbers,:integer,1,:float,3.015"
     @parser = CSV.new(@data)
-    
+
     @custom = lambda { |field| field =~ /\A:(\S.*?)\s*\Z/ ? $1.to_sym : field }
-    
+
     @win_safe_time_str = Time.now.strftime("%a %b %d %H:%M:%S %Y")
   end
-  
+
   def test_builtin_integer_converter
     # does convert
     [-5, 1, 10000000000].each do |n|
       assert_equal(n, CSV::Converters[:integer][n.to_s])
     end
-    
+
     # does not convert
     (%w{junk 1.0} + [""]).each do |str|
       assert_equal(str, CSV::Converters[:integer][str])
@@ -38,7 +38,7 @@ class TestDataConverters < Test::Unit::TestCase
     [-5.1234, 0, 2.3e-11].each do |n|
       assert_equal(n, CSV::Converters[:float][n.to_s])
     end
-    
+
     # does not convert
     (%w{junk 1..0 .015F} + [""]).each do |str|
       assert_equal(str, CSV::Converters[:float][str])
@@ -64,43 +64,43 @@ class TestDataConverters < Test::Unit::TestCase
     # does not convert
     assert_instance_of(String, CSV::Converters[:date_time]["junk"])
   end
-  
+
   def test_convert_with_builtin
     # setup parser...
     assert(@parser.respond_to?(:convert))
     assert_nothing_raised(Exception) { @parser.convert(:integer) }
-    
+
     # and use
     assert_equal(["Numbers", ":integer", 1, ":float", "3.015"], @parser.shift)
-    
+
     setup  # reset
-    
+
     # setup parser...
     assert_nothing_raised(Exception) { @parser.convert(:float) }
-    
+
     # and use
     assert_equal(["Numbers", ":integer", 1.0, ":float", 3.015], @parser.shift)
   end
-  
+
   def test_convert_order
     # floats first, then integers...
-    assert_nothing_raised(Exception) do 
+    assert_nothing_raised(Exception) do
       @parser.convert(:float)
       @parser.convert(:integer)
     end
-    
+
     # gets us nothing but floats
     assert_equal( [String, String, Float, String, Float],
                   @parser.shift.map { |field| field.class } )
-    
+
     setup  # reset
 
     # integers have precendance...
-    assert_nothing_raised(Exception) do 
+    assert_nothing_raised(Exception) do
       @parser.convert(:integer)
       @parser.convert(:float)
     end
-    
+
     # gives us proper number conversion
     assert_equal( [String, String, Fixnum, String, Float],
                   @parser.shift.map { |field| field.class } )
@@ -109,7 +109,7 @@ class TestDataConverters < Test::Unit::TestCase
   def test_builtin_numeric_combo_converter
     # setup parser...
     assert_nothing_raised(Exception) { @parser.convert(:numeric) }
-    
+
     # and use
     assert_equal( [String, String, Fixnum, String, Float],
                   @parser.shift.map { |field| field.class } )
@@ -120,18 +120,18 @@ class TestDataConverters < Test::Unit::TestCase
     @data   << ",#{@win_safe_time_str}"        # add a DateTime field
     @parser =  CSV.new(@data)                  # reset parser
     assert_nothing_raised(Exception) { @parser.convert(:all) }
-    
+
     # and use
     assert_equal( [String, String, Fixnum, String, Float, DateTime],
                   @parser.shift.map { |field| field.class } )
   end
-  
+
   def test_convert_with_custom_code
     # define custom converter...
     assert_nothing_raised(Exception) do
       @parser.convert { |field| field =~ /\A:(\S.*?)\s*\Z/ ? $1.to_sym : field }
     end
-    
+
     # and use
     assert_equal(["Numbers", :integer, "1", :float, "3.015"], @parser.shift)
 
@@ -140,11 +140,11 @@ class TestDataConverters < Test::Unit::TestCase
     # mix built-in and custom...
     assert_nothing_raised(Exception) { @parser.convert(:numeric) }
     assert_nothing_raised(Exception) { @parser.convert(&@custom) }
-    
+
     # and use
     assert_equal(["Numbers", :integer, 1, :float, 3.015], @parser.shift)
   end
-  
+
   def test_convert_with_custom_code_using_field_info
     # define custom converter that uses field information...
     assert_nothing_raised(Exception) do
@@ -153,26 +153,26 @@ class TestDataConverters < Test::Unit::TestCase
         info.index == 4 ? Float(field).floor : field
       end
     end
-    
+
     # and use
     assert_equal(["Numbers", ":integer", "1", ":float", 3], @parser.shift)
   end
-  
+
   def test_convert_with_custom_code_using_field_info_header
     @parser = CSV.new(@data, headers: %w{one two three four five})
-    
+
     # define custom converter that uses field header information...
     assert_nothing_raised(Exception) do
       @parser.convert do |field, info|
         info.header == "three" ? Integer(field) * 100 : field
       end
     end
-    
+
     # and use
     assert_equal( ["Numbers", ":integer", 100, ":float", "3.015"],
                   @parser.shift.fields )
   end
-  
+
   def test_shortcut_interface
     assert_equal( ["Numbers", ":integer", 1, ":float", 3.015],
                   CSV.parse_line(@data, converters: :numeric) )
@@ -183,14 +183,14 @@ class TestDataConverters < Test::Unit::TestCase
     assert_equal( ["Numbers", :integer, 1, :float, 3.015],
                   CSV.parse_line(@data, converters: [:numeric, @custom]) )
   end
-  
+
   def test_unconverted_fields
     [ [ @data,
         ["Numbers", :integer, 1, :float, 3.015],
         %w{Numbers :integer 1 :float 3.015} ],
       ["\n", Array.new, Array.new] ].each do |test, fields, unconverted|
       row = nil
-      assert_nothing_raised(Exception) do 
+      assert_nothing_raised(Exception) do
         row = CSV.parse_line( test,
                               converters:         [:numeric, @custom],
                               unconverted_fields: true )
@@ -206,7 +206,7 @@ class TestDataConverters < Test::Unit::TestCase
     1,2,3
     END_CSV
     row = nil
-    assert_nothing_raised(Exception) do 
+    assert_nothing_raised(Exception) do
       row = CSV.parse_line( data,
                             converters:         :numeric,
                             unconverted_fields: true,
@@ -217,7 +217,7 @@ class TestDataConverters < Test::Unit::TestCase
     assert_respond_to(row, :unconverted_fields)
     assert_equal(%w{1 2 3}, row.unconverted_fields)
 
-    assert_nothing_raised(Exception) do 
+    assert_nothing_raised(Exception) do
       row = CSV.parse_line( data,
                             converters:         :numeric,
                             unconverted_fields: true,
@@ -230,7 +230,7 @@ class TestDataConverters < Test::Unit::TestCase
     assert_respond_to(row, :unconverted_fields)
     assert_equal(%w{first second third}, row.unconverted_fields)
 
-    assert_nothing_raised(Exception) do 
+    assert_nothing_raised(Exception) do
       row = CSV.parse_line( data,
                             converters:         :numeric,
                             unconverted_fields: true,
@@ -244,7 +244,7 @@ class TestDataConverters < Test::Unit::TestCase
     assert_respond_to(row, :unconverted_fields)
     assert_equal(%w{first second third}, row.unconverted_fields)
 
-    assert_nothing_raised(Exception) do 
+    assert_nothing_raised(Exception) do
       row = CSV.parse_line( data,
                             converters:         :numeric,
                             unconverted_fields: true,
diff --git a/test/csv/test_encodings.rb b/test/csv/test_encodings.rb
index 0a300af291..63f7207c29 100644
--- a/test/csv/test_encodings.rb
+++ b/test/csv/test_encodings.rb
@@ -15,43 +15,43 @@ class TestEncodings < Test::Unit::TestCase
   def setup
     @temp_csv_path = File.join(File.dirname(__FILE__), "temp.csv")
   end
-  
+
   def teardown
     File.unlink(@temp_csv_path) if File.exist? @temp_csv_path
   end
-  
+
   ########################################
   ### Hand Test Some Popular Encodings ###
   ########################################
-  
+
   def test_parses_utf8_encoding
     assert_parses( [ %w[ one two … ],
                      %w[ 1   …   3 ],
                      %w[ …   5   6 ] ], "UTF-8" )
   end
-  
+
   def test_parses_latin1_encoding
     assert_parses( [ %w[ one    two    Résumé ],
                      %w[ 1      Résumé 3      ],
                      %w[ Résumé 5      6      ] ], "ISO-8859-1" )
   end
-  
+
   def test_parses_utf16be_encoding
     assert_parses( [ %w[ one two … ],
                      %w[ 1   …   3 ],
                      %w[ …   5   6 ] ], "UTF-16BE" )
   end
-  
+
   def test_parses_shift_jis_encoding
     assert_parses( [ %w[ 一 二 三 ],
                      %w[ 四 五 六 ],
                      %w[ 七 八 九 ] ], "Shift_JIS" )
   end
-  
+
   ###########################################################
   ### Try Simple Reading for All Non-dummy Ruby Encodings ###
   ###########################################################
-  
+
   def test_reading_with_most_encodings
     each_encoding do |encoding|
       begin
@@ -62,7 +62,7 @@ class TestEncodings < Test::Unit::TestCase
       end
     end
   end
-  
+
   def test_regular_expression_escaping
     each_encoding do |encoding|
       begin
@@ -73,18 +73,18 @@ class TestEncodings < Test::Unit::TestCase
       end
     end
   end
-  
+
   #######################################################################
   ### Stress Test ASCII Compatible and Non-ASCII Compatible Encodings ###
   #######################################################################
-  
+
   def test_auto_line_ending_detection
     # arrange data to place a \r at the end of CSV's read ahead point
     encode_for_tests([["a" * 509]], row_sep: "\r\n") do |data|
       assert_equal("\r\n".encode(data.encoding), CSV.new(data).row_sep)
     end
   end
-  
+
   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|
@@ -93,7 +93,7 @@ class TestEncodings < Test::Unit::TestCase
       end
     end
   end
-  
+
   def test_parser_works_with_encoded_headers
     encode_for_tests([%w[one two three], %w[1 2 3]]) do |data|
       parsed = CSV.parse(data, headers: true)
@@ -105,7 +105,7 @@ class TestEncodings < Test::Unit::TestCase
       end
     end
   end
-  
+
   def test_built_in_converters_transcode_to_utf_8_then_convert
     encode_for_tests([%w[one two three], %w[1 2 3]]) do |data|
       parsed = CSV.parse(data, converters: :integer)
@@ -114,7 +114,7 @@ class TestEncodings < Test::Unit::TestCase
       assert_equal([1, 2, 3], parsed[1])
     end
   end
-  
+
   def test_built_in_header_converters_transcode_to_utf_8_then_convert
     encode_for_tests([%w[one two three], %w[1 2 3]]) do |data|
       parsed = CSV.parse( data, headers:           true,
@@ -125,7 +125,7 @@ class TestEncodings < Test::Unit::TestCase
               "Wrong data encoding." )
     end
   end
-  
+
   def test_open_allows_you_to_set_encodings
     encode_for_tests([%w[abc def]]) do |data|
       # read and write in encoding
@@ -136,7 +136,7 @@ class TestEncodings < Test::Unit::TestCase
                   "Wrong data encoding." )
         end
       end
-      
+
       # read and write with transcoding
       File.open(@temp_csv_path, "wb:UTF-32BE:#{data.encoding.name}") do |f|
         f << data
@@ -149,7 +149,7 @@ class TestEncodings < Test::Unit::TestCase
       end
     end
   end
-  
+
   def test_foreach_allows_you_to_set_encodings
     encode_for_tests([%w[abc def]]) do |data|
       # read and write in encoding
@@ -158,7 +158,7 @@ class TestEncodings < Test::Unit::TestCase
         assert( row.all? { |f| f.encoding == data.encoding },
                 "Wrong data encoding." )
       end
-      
+
       # read and write with transcoding
       File.open(@temp_csv_path, "wb:UTF-32BE:#{data.encoding.name}") do |f|
         f << data
@@ -170,7 +170,7 @@ class TestEncodings < Test::Unit::TestCase
       end
     end
   end
-  
+
   def test_read_allows_you_to_set_encodings
     encode_for_tests([%w[abc def]]) do |data|
       # read and write in encoding
@@ -178,7 +178,7 @@ class TestEncodings < Test::Unit::TestCase
       rows = CSV.read(@temp_csv_path, encoding: data.encoding.name)
       assert( rows.flatten.all? { |f| f.encoding == data.encoding },
               "Wrong data encoding." )
-      
+
       # read and write with transcoding
       File.open(@temp_csv_path, "wb:UTF-32BE:#{data.encoding.name}") do |f|
         f << data
@@ -189,22 +189,22 @@ class TestEncodings < Test::Unit::TestCase
               "Wrong data encoding." )
     end
   end
-  
+
   #################################
   ### Write CSV in any Encoding ###
   #################################
-  
+
   def test_can_write_csv_in_any_encoding
     each_encoding do |encoding|
       # test generate_line with encoding hint
       csv = %w[abc d|ef].map { |f| f.encode(encoding) }.
                          to_csv(col_sep: "|", encoding: encoding.name)
       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: "|")
       assert_equal(encoding, csv.encoding)
-      
+
       # writing to files
       data = encode_ary([%w[abc d,ef], %w[123 456 ]], encoding)
       CSV.open(@temp_csv_path, "wb:#{encoding.name}") do |f|
@@ -213,9 +213,9 @@ class TestEncodings < Test::Unit::TestCase
       assert_equal(data, CSV.read(@temp_csv_path, encoding: encoding.name))
     end
   end
-  
+
   private
-  
+
   def assert_parses(fields, encoding, options = { })
     encoding = Encoding.find(encoding) unless encoding.is_a? Encoding
     fields   = encode_ary(fields, encoding)
@@ -225,11 +225,11 @@ class TestEncodings < Test::Unit::TestCase
       assert_equal(encoding, field.encoding, "Field[#{i + 1}] was transcoded.")
     end
   end
-  
+
   def encode_ary(ary, encoding)
     ary.map { |row| row.map { |field| field.encode(encoding) } }
   end
-  
+
   def ary_to_data(ary, options = { })
     encoding   = ary.flatten.first.encoding
     quote_char = (options[:quote_char] || '"').encode(encoding)
@@ -241,12 +241,12 @@ class TestEncodings < Test::Unit::TestCase
       }.join(col_sep) + row_sep
     }.join.encode(encoding)
   end
-  
+
   def encode_for_tests(data, options = { })
     yield ary_to_data(encode_ary(data, "UTF-8"),    options)
     yield ary_to_data(encode_ary(data, "UTF-16BE"), options)
   end
-  
+
   def each_encoding
     Encoding.list.each do |encoding|
       next if encoding.dummy?  # skip "dummy" encodings
diff --git a/test/csv/test_features.rb b/test/csv/test_features.rb
index 9ed3f98191..58efd1c9b3 100644
--- a/test/csv/test_features.rb
+++ b/test/csv/test_features.rb
@@ -30,17 +30,17 @@ class TestCSVFeatures < Test::Unit::TestCase
                  [%Q{,"\r"},             [nil,"\r"]],
                  [%Q{"\r\n,"},           ["\r\n,"]],
                  [%Q{"\r\n,",},          ["\r\n,", nil]] ]
-  
+
   def setup
     @sample_data = <<-END_DATA.gsub(/^ +/, "")
     line,1,abc
     line,2,"def\nghi"
-    
+
     line,4,jkl
     END_DATA
     @csv = CSV.new(@sample_data)
   end
-  
+
   def test_col_sep
     [";", "\t"].each do |sep|
       TEST_CASES.each do |test_case|
@@ -51,7 +51,7 @@ class TestCSVFeatures < Test::Unit::TestCase
     end
     assert_equal([",,,", nil], CSV.parse_line(",,,;", col_sep: ";"))
   end
-  
+
   def test_row_sep
     assert_raise(CSV::MalformedCSVError) do
         CSV.parse_line("1,2,3\n,4,5\r\n", row_sep: "\r\n")
@@ -59,7 +59,7 @@ class TestCSVFeatures < Test::Unit::TestCase
     assert_equal( ["1", "2", "3\n", "4", "5"],
                   CSV.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? },
@@ -67,31 +67,31 @@ class TestCSVFeatures < Test::Unit::TestCase
                                     quote_char: "'" ) )
     end
   end
-  
+
   def test_csv_char_readers
     %w[col_sep row_sep quote_char].each do |reader|
       csv = CSV.new("abc,def", reader.to_sym => "|")
       assert_equal("|", csv.send(reader))
     end
   end
-  
+
   def test_row_sep_auto_discovery
     ["\r\n", "\n", "\r"].each do |line_end|
       data       = "1,2,3#{line_end}4,5#{line_end}"
       discovered = CSV.new(data).row_sep
       assert_equal(line_end, discovered)
     end
-    
+
     assert_equal("\n", CSV.new("\n\r\n\r").row_sep)
-    
+
     assert_equal($/, CSV.new("").row_sep)
-    
+
     assert_equal($/, CSV.new(STDERR).row_sep)
   end
-  
+
   def test_lineno
     assert_equal(5, @sample_data.lines.to_a.size)
-    
+
     4.times do |line_count|
       assert_equal(line_count, @csv.lineno)
       assert_not_nil(@csv.shift)
@@ -99,24 +99,24 @@ class TestCSVFeatures < Test::Unit::TestCase
     end
     assert_nil(@csv.shift)
   end
-  
+
   def test_readline
     test_lineno
-    
+
     @csv.rewind
-    
+
     test_lineno
   end
-  
+
   def test_unknown_options
     assert_raise(ArgumentError) { CSV.new(String.new, unknown: :error) }
   end
-  
+
   def test_skip_blanks
     assert_equal(4, @csv.to_a.size)
 
     @csv  = CSV.new(@sample_data, skip_blanks: true)
-    
+
     count = 0
     @csv.each do |row|
       count += 1
@@ -124,7 +124,7 @@ class TestCSVFeatures < Test::Unit::TestCase
     end
     assert_equal(3, count)
   end
-  
+
   def test_csv_behavior_readers
     %w[ unconverted_fields return_headers write_headers
         skip_blanks        force_quotes ].each do |behavior|
@@ -134,47 +134,47 @@ class TestCSVFeatures < Test::Unit::TestCase
       assert(csv.send("#{behavior}?"), "Behavior change now registered.")
     end
   end
-  
+
   def test_converters_reader
     # no change
     assert_equal( [:integer],
                   CSV.new("abc,def", converters: [:integer]).converters )
-    
+
     # just one
     assert_equal( [:integer],
                   CSV.new("abc,def", converters: :integer).converters )
-    
+
     # expanded
     assert_equal( [:integer, :float],
                   CSV.new("abc,def", converters: :numeric).converters )
-    
+
     # custom
     csv = CSV.new("abc,def", converters: [:integer, lambda {  }])
     assert_equal(2, csv.converters.size)
     assert_equal(:integer, csv.converters.first)
     assert_instance_of(Proc, csv.converters.last)
   end
-  
+
   def test_header_converters_reader
     # no change
     hc = :header_converters
     assert_equal([:downcase], CSV.new("abc,def", hc => [:downcase]).send(hc))
-    
+
     # just one
     assert_equal([:downcase], CSV.new("abc,def", hc => :downcase).send(hc))
-    
+
     # custom
     csv = CSV.new("abc,def", hc => [:symbol, lambda {  }])
     assert_equal(2, csv.send(hc).size)
     assert_equal(:symbol, csv.send(hc).first)
     assert_instance_of(Proc, csv.send(hc).last)
   end
-  
+
   # reported by Kev Jackson
   def test_failing_to_escape_col_sep_bug_fix
     assert_nothing_raised(Exception) { CSV.new(String.new, col_sep: "|") }
   end
-  
+
   # reported by Chris Roos
   def test_failing_to_reset_headers_in_rewind_bug_fix
     csv = CSV.new("forename,surname", headers: true, return_headers: true)
@@ -182,7 +182,7 @@ class TestCSVFeatures < Test::Unit::TestCase
     csv.rewind
     csv.each { |row| assert row.header_row? }
   end
-  
+
   # reported by Dave Burt
   def test_leading_empty_fields_with_multibyte_col_sep_bug_fix
     data = <<-END_DATA.gsub(/^\s+/, "")
@@ -192,7 +192,7 @@ class TestCSVFeatures < Test::Unit::TestCase
     parsed = CSV.parse(data, col_sep: "<=>")
     assert_equal([[nil, nil, "A", "B", "C"], ["1", "2", "3"]], parsed)
   end
-  
+
   def test_gzip_reader_bug_fix
     zipped = nil
     assert_nothing_raised(NoMethodError) do
@@ -204,7 +204,7 @@ class TestCSVFeatures < Test::Unit::TestCase
     end
     assert_equal("\r\n", zipped.row_sep)
   end
-  
+
   def test_gzip_writer_bug_fix
     file   = File.join(File.dirname(__FILE__), "temp.gz")
     zipped = nil
@@ -214,13 +214,13 @@ class TestCSVFeatures < Test::Unit::TestCase
     zipped << %w[one two three]
     zipped << [1, 2, 3]
     zipped.close
-    
+
     assert( Zlib::GzipReader.open(file) { |f| f.read }.
                              include?($INPUT_RECORD_SEPARATOR),
             "@row_sep did not default" )
     File.unlink(file)
   end
-  
+
   def test_inspect_is_smart_about_io_types
     str = CSV.new("string,data").inspect
     assert(str.include?("io_type:StringIO"), "IO type not detected.")
@@ -234,14 +234,14 @@ class TestCSVFeatures < Test::Unit::TestCase
     assert(str.include?("io_type:File"), "IO type not detected.")
     File.unlink(path)
   end
-  
+
   def test_inspect_shows_key_attributes
     str = @csv.inspect
     %w[lineno col_sep row_sep quote_char].each do |attr_name|
       assert_match(/\b#{attr_name}:[^\s>]+/, str)
     end
   end
-  
+
   def test_inspect_shows_headers_when_available
     CSV.new("one,two,three\n1,2,3\n", headers: true) do |csv|
       assert(csv.inspect.include?("headers:true"), "Header hint not shown.")
@@ -249,7 +249,7 @@ class TestCSVFeatures < Test::Unit::TestCase
       assert_match(/headers:\[[^\]]+\]/, csv.inspect)
     end
   end
-  
+
   def test_inspect_encoding_is_ascii_compatible
     CSV.new("one,two,three\n1,2,3\n".encode("UTF-16BE")) do |csv|
       assert( Encoding.compatible?( Encoding.find("US-ASCII"),
@@ -257,7 +257,7 @@ class TestCSVFeatures < Test::Unit::TestCase
               "inspect() was not ASCII compatible." )
     end
   end
-  
+
   def test_version
     assert_not_nil(CSV::VERSION)
     assert_instance_of(String, CSV::VERSION)
diff --git a/test/csv/test_headers.rb b/test/csv/test_headers.rb
index 6ce5675816..6e56ffc27c 100644
--- a/test/csv/test_headers.rb
+++ b/test/csv/test_headers.rb
@@ -19,12 +19,12 @@ class TestCSVHeaders < Test::Unit::TestCase
     1,2,3
     END_CSV
   end
-  
+
   def test_first_row
     [:first_row, true].each do |setting|  # two names for the same setting
       # activate headers
       csv = nil
-      assert_nothing_raised(Exception) do 
+      assert_nothing_raised(Exception) do
         csv = CSV.parse(@data, headers: setting)
       end
 
@@ -44,11 +44,11 @@ class TestCSVHeaders < Test::Unit::TestCase
       assert_nil(csv[2])
     end
   end
-  
+
   def test_array_of_headers
     # activate headers
     csv = nil
-    assert_nothing_raised(Exception) do 
+    assert_nothing_raised(Exception) do
       csv = CSV.parse(@data, headers: [:my, :new, :headers])
     end
 
@@ -73,7 +73,7 @@ class TestCSVHeaders < Test::Unit::TestCase
 
     # empty
     assert_nil(csv[3])
-    
+
     # with return and convert
     assert_nothing_raised(Exception) do
       csv = CSV.parse( @data, headers:           [:my, :new, :headers],
@@ -87,11 +87,11 @@ class TestCSVHeaders < Test::Unit::TestCase
     assert(row.header_row?)
     assert(!row.field_row?)
   end
-  
+
   def test_csv_header_string
     # activate headers
     csv = nil
-    assert_nothing_raised(Exception) do 
+    assert_nothing_raised(Exception) do
       csv = CSV.parse(@data, headers: "my,new,headers")
     end
 
@@ -115,7 +115,7 @@ class TestCSVHeaders < Test::Unit::TestCase
 
     # empty
     assert_nil(csv[3])
-    
+
     # with return and convert
     assert_nothing_raised(Exception) do
       csv = CSV.parse( @data, headers:           "my,new,headers",
@@ -129,11 +129,11 @@ class TestCSVHeaders < Test::Unit::TestCase
     assert(row.header_row?)
     assert(!row.field_row?)
   end
-  
+
   def test_csv_header_string_inherits_separators
     # parse with custom col_sep
     csv = nil
-    assert_nothing_raised(Exception) do 
+    assert_nothing_raised(Exception) do
       csv = CSV.parse( @data.tr(",", "|"), col_sep: "|",
                                            headers: "my|new|headers" )
     end
@@ -144,7 +144,7 @@ class TestCSVHeaders < Test::Unit::TestCase
     assert_instance_of(CSV::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
     csv = nil
@@ -180,14 +180,14 @@ class TestCSVHeaders < Test::Unit::TestCase
     # empty
     assert_nil(csv[3])
   end
-  
+
   def test_converters
     # create test data where headers and fields look alike
     data = <<-END_MATCHING_CSV.gsub(/^\s+/, "")
     1,2,3
     1,2,3
     END_MATCHING_CSV
-    
+
     # normal converters do not affect headers
     csv = CSV.parse( data, headers:        true,
                            return_headers: true,
@@ -195,9 +195,9 @@ class TestCSVHeaders < Test::Unit::TestCase
     assert_equal([%w{1 1}, %w{2 2}, %w{3 3}], csv[0].to_a)
     assert_equal([["1", 1], ["2", 2], ["3", 3]], csv[1].to_a)
     assert_nil(csv[2])
-    
+
     # header converters do affect headers (only)
-    assert_nothing_raised(Exception) do 
+    assert_nothing_raised(Exception) do
       csv = CSV.parse( data, headers:           true,
                              return_headers:    true,
                              converters:        :numeric,
@@ -207,21 +207,21 @@ class TestCSVHeaders < Test::Unit::TestCase
     assert_equal([[:"1", 1], [:"2", 2], [:"3", 3]], csv[1].to_a)
     assert_nil(csv[2])
   end
-  
+
   def test_builtin_downcase_converter
     csv = CSV.parse( "One,TWO Three", headers:           true,
                                       return_headers:    true,
                                       header_converters: :downcase )
     assert_equal(%w{one two\ three}, csv.headers)
   end
-  
+
   def test_builtin_symbol_converter
     csv = CSV.parse( "One,TWO Three", headers:           true,
                                       return_headers:    true,
                                       header_converters: :symbol )
     assert_equal([:one, :two_three], csv.headers)
   end
-  
+
   def test_custom_converter
     converter = lambda { |header| header.tr(" ", "_") }
     csv       = CSV.parse( "One,TWO Three",
@@ -230,56 +230,56 @@ class TestCSVHeaders < Test::Unit::TestCase
                            header_converters: converter )
     assert_equal(%w{One TWO_Three}, csv.headers)
   end
-  
+
   def test_table_support
     csv = nil
-    assert_nothing_raised(Exception) do 
+    assert_nothing_raised(Exception) do
       csv = CSV.parse(@data, headers: true)
     end
-    
+
     assert_instance_of(CSV::Table, csv)
   end
-  
+
   def test_skip_blanks
     @data = <<-END_CSV.gsub(/^ +/, "")
-    
+
 
     A,B,C
-    
+
     1,2,3
-    
-    
-    
+
+
+
     END_CSV
-    
+
     expected = [%w[1 2 3]]
     CSV.parse(@data, headers: true, skip_blanks: true) do |row|
       assert_equal(expected.shift, row.fields)
     end
-    
+
     expected = [%w[A B C], %w[1 2 3]]
     CSV.parse( @data,
                headers:        true,
-               return_headers: true, 
+               return_headers: true,
                skip_blanks:    true ) do |row|
       assert_equal(expected.shift, row.fields)
     end
   end
-  
+
   def test_headers_reader
     # no headers
     assert_nil(CSV.new(@data).headers)
-    
+
     # headers
     csv = CSV.new(@data, headers: true)
     assert_equal(true, csv.headers)                    # before headers are read
     csv.shift                                          # set headers
     assert_equal(%w[first second third], csv.headers)  # after headers are read
   end
-  
+
   def test_blank_row_bug_fix
     @data += "\n#{@data}"  # add a blank row
-    
+
     # ensure that everything returned is a Row object
     CSV.parse(@data, headers: true) do |row|
       assert_instance_of(CSV::Row, row)
diff --git a/test/csv/test_interface.rb b/test/csv/test_interface.rb
index b9e634a559..a6028f92f3 100644
--- a/test/csv/test_interface.rb
+++ b/test/csv/test_interface.rb
@@ -14,7 +14,7 @@ require "csv"
 class TestCSVInterface < Test::Unit::TestCase
   def setup
     @path = File.join(File.dirname(__FILE__), "temp_test_data.csv")
-    
+
     File.open(@path, "w") do |file|
       file << "1\t2\t3\r\n"
       file << "4\t5\r\n"
@@ -22,19 +22,19 @@ class TestCSVInterface < Test::Unit::TestCase
 
     @expected = [%w{1 2 3}, %w{4 5}]
   end
-  
+
   def teardown
     File.unlink(@path)
   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_open_and_close
     csv = CSV.open(@path, "r+", col_sep: "\t", row_sep: "\r\n")
     assert_not_nil(csv)
@@ -42,7 +42,7 @@ class TestCSVInterface < Test::Unit::TestCase
     assert_equal(false, csv.closed?)
     csv.close
     assert(csv.closed?)
-    
+
     ret = CSV.open(@path) do |new_csv|
       csv = new_csv
       assert_instance_of(CSV, new_csv)
@@ -51,7 +51,7 @@ class TestCSVInterface < Test::Unit::TestCase
     assert(csv.closed?)
     assert_equal("Return value.", ret)
   end
-  
+
   def test_parse
     data = File.read(@path)
     assert_equal( @expected,
@@ -61,27 +61,27 @@ class TestCSVInterface < Test::Unit::TestCase
       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_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
@@ -91,13 +91,13 @@ class TestCSVInterface < Test::Unit::TestCase
     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, "r+", col_sep: "\t", row_sep: "\r\n") do |csv|
       assert_equal(@expected.shift, csv.shift)
@@ -105,7 +105,7 @@ class TestCSVInterface < Test::Unit::TestCase
       assert_equal(nil, csv.shift)
     end
   end
-  
+
   ### Test Write Interface ###
 
   def test_generate
@@ -123,13 +123,13 @@ class TestCSVInterface < Test::Unit::TestCase
     end
     assert_equal(%Q{1,2,3\n4,,5\nlast,"""row"""\n}, str)
   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)
@@ -173,7 +173,7 @@ class TestCSVInterface < Test::Unit::TestCase
       csv.each { |line| assert_equal(lines.shift, line.to_hash) }
     end
   end
-  
+
   def test_write_hash_with_headers_array
     File.unlink(@path)
 
@@ -216,7 +216,7 @@ class TestCSVInterface < Test::Unit::TestCase
       csv.each { |line| assert_equal(lines.shift, line.to_hash) }
     end
   end
-  
+
   def test_write_headers
     File.unlink(@path)
 
@@ -241,10 +241,10 @@ class TestCSVInterface < Test::Unit::TestCase
       csv.each { |line| assert_equal(lines.shift, line.to_hash) }
     end
   end
-  
+
   def test_append  # aliased add_row() and puts()
     File.unlink(@path)
-    
+
     CSV.open(@path, "w", col_sep: "\t", row_sep: "\r\n") do |csv|
       @expected.each { |row| csv << row }
     end
@@ -253,19 +253,19 @@ class TestCSVInterface < Test::Unit::TestCase
 
     # same thing using CSV::Row objects
     File.unlink(@path)
-    
+
     CSV.open(@path, "w", 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: ",",
@@ -276,27 +276,27 @@ class TestCSVInterface < Test::Unit::TestCase
     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 
+    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 
+    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 } })
diff --git a/test/csv/test_row.rb b/test/csv/test_row.rb
index d0b0cdc406..f9aa959701 100644
--- a/test/csv/test_row.rb
+++ b/test/csv/test_row.rb
@@ -15,27 +15,27 @@ class TestCSVRow < Test::Unit::TestCase
   def setup
     @row = CSV::Row.new(%w{A B C A A}, [1, 2, 3, 4])
   end
-  
+
   def test_initialize
     # basic
     row = CSV::Row.new(%w{A B C}, [1, 2, 3])
     assert_not_nil(row)
     assert_instance_of(CSV::Row, row)
     assert_equal([["A", 1], ["B", 2], ["C", 3]], row.to_a)
-    
+
     # missing headers
     row = CSV::Row.new(%w{A}, [1, 2, 3])
     assert_not_nil(row)
     assert_instance_of(CSV::Row, row)
     assert_equal([["A", 1], [nil, 2], [nil, 3]], row.to_a)
-    
+
     # missing fields
     row = CSV::Row.new(%w{A B C}, [1, 2])
     assert_not_nil(row)
     assert_instance_of(CSV::Row, row)
     assert_equal([["A", 1], ["B", 2], ["C", nil]], row.to_a)
   end
-  
+
   def test_row_type
     # field rows
     row = CSV::Row.new(%w{A B C}, [1, 2, 3])         # implicit
@@ -50,11 +50,11 @@ class TestCSVRow < Test::Unit::TestCase
     assert(row.header_row?)
     assert(!row.field_row?)
   end
-  
+
   def test_headers
     assert_equal(%w{A B C A A}, @row.headers)
   end
-  
+
   def test_field
     # by name
     assert_equal(2, @row.field("B"))
@@ -62,11 +62,11 @@ class TestCSVRow < Test::Unit::TestCase
 
     # by index
     assert_equal(3, @row.field(2))
-    
+
     # missing
     assert_nil(@row.field("Missing"))
     assert_nil(@row.field(10))
-    
+
     # minimum index
     assert_equal(1, @row.field("A"))
     assert_equal(1, @row.field("A", 0))
@@ -76,24 +76,24 @@ class TestCSVRow < Test::Unit::TestCase
     assert_equal(nil, @row.field("A", 4))
     assert_equal(nil, @row.field("A", 5))
   end
-  
+
   def test_set_field
     # set field by name
     assert_equal(100, @row["A"] = 100)
-    
+
     # set field by index
     assert_equal(300, @row[3] = 300)
-    
+
     # set field by name and minimum index
     assert_equal([:a, :b, :c], @row["A", 4] = [:a, :b, :c])
-    
+
     # verify the changes
     assert_equal( [ ["A", 100],
                     ["B", 2],
                     ["C", 3],
                     ["A", 300],
                     ["A", [:a, :b, :c]] ], @row.to_a )
-    
+
     # assigning an index past the end
     assert_equal("End", @row[10] = "End")
     assert_equal( [ ["A", 100],
@@ -107,7 +107,7 @@ class TestCSVRow < Test::Unit::TestCase
                     [nil, nil],
                     [nil, nil],
                     [nil, "End"] ], @row.to_a )
-    
+
     # assigning a new field by header
     assert_equal("New", @row[:new] = "New")
     assert_equal( [ ["A", 100],
@@ -123,7 +123,7 @@ class TestCSVRow < Test::Unit::TestCase
                     [nil, "End"],
                     [:new, "New"] ], @row.to_a )
   end
-  
+
   def test_append
     # add a value
     assert_equal(@row, @row << "Value")
@@ -133,7 +133,7 @@ class TestCSVRow < Test::Unit::TestCase
                     ["A", 4],
                     ["A", nil],
                     [nil, "Value"] ], @row.to_a )
-    
+
     # add a pair
     assert_equal(@row, @row << %w{Header Field})
     assert_equal( [ ["A", 1],
@@ -143,7 +143,7 @@ class TestCSVRow < Test::Unit::TestCase
                     ["A", nil],
                     [nil, "Value"],
                     %w{Header Field} ], @row.to_a )
-    
+
     # a pair with Hash syntax
     assert_equal(@row, @row << {key: :value})
     assert_equal( [ ["A", 1],
@@ -154,7 +154,7 @@ class TestCSVRow < Test::Unit::TestCase
                     [nil, "Value"],
                     %w{Header Field},
                     [:key, :value] ], @row.to_a )
-    
+
     # multiple fields at once
     assert_equal(@row, @row.push(100, 200, [:last, 300]))
     assert_equal( [ ["A", 1],
@@ -169,39 +169,39 @@ class TestCSVRow < Test::Unit::TestCase
                     [nil, 200],
                     [:last, 300] ], @row.to_a )
   end
-  
+
   def test_delete
     # by index
     assert_equal(["B", 2], @row.delete(1))
 
     # by header
     assert_equal(["C", 3], @row.delete("C"))
-    
+
     # using a block
     assert_equal(@row, @row.delete_if { |h, f| h == "A" and not f.nil? })
     assert_equal([["A", nil]], @row.to_a)
   end
-  
+
   def test_fields
     # all fields
     assert_equal([1, 2, 3, 4, nil], @row.fields)
-    
+
     # by header
     assert_equal([1, 3], @row.fields("A", "C"))
-    
+
     # by index
     assert_equal([2, 3, nil], @row.fields(1, 2, 10))
-    
+
     # by both
     assert_equal([2, 3, 4], @row.fields("B", "C", 3))
-    
+
     # with minimum indices
     assert_equal([2, 3, 4], @row.fields("B", "C", ["A", 3]))
-    
+
     # by header range
     assert_equal([2, 3], @row.values_at("B".."C"))
   end
-  
+
   def test_index
     # basic usage
     assert_equal(0, @row.index("A"))
@@ -218,20 +218,20 @@ class TestCSVRow < Test::Unit::TestCase
     assert_equal(4, @row.index("A", 4))
     assert_equal(nil, @row.index("A", 5))
   end
-  
+
   def test_queries
     # headers
     assert(@row.header?("A"))
     assert(@row.header?("C"))
     assert(!@row.header?("Z"))
     assert(@row.include?("A"))  # alias
-    
+
     # fields
     assert(@row.field?(4))
     assert(@row.field?(nil))
     assert(!@row.field?(10))
   end
-  
+
   def test_each
     # array style
     ary = @row.to_a
@@ -239,25 +239,25 @@ class TestCSVRow < Test::Unit::TestCase
       assert_equal(ary.first.first, pair.first)
       assert_equal(ary.shift.last, pair.last)
     end
-    
+
     # hash style
     ary = @row.to_a
     @row.each do |header, field|
       assert_equal(ary.first.first, header)
       assert_equal(ary.shift.last, field)
     end
-    
+
     # verify that we can chain the call
     assert_equal(@row, @row.each { })
   end
-  
+
   def test_enumerable
     assert_equal( [["A", 1], ["A", 4], ["A", nil]],
                   @row.select { |pair| pair.first == "A" } )
-    
+
     assert_equal(10, @row.inject(0) { |sum, (header, n)| sum + (n || 0) })
   end
-  
+
   def test_to_a
     row = CSV::Row.new(%w{A B C}, [1, 2, 3]).to_a
     assert_instance_of(Array, row)
@@ -267,27 +267,27 @@ class TestCSVRow < Test::Unit::TestCase
     end
     assert_equal([["A", 1], ["B", 2], ["C", 3]], row)
   end
-  
+
   def test_to_hash
     assert_equal({"A" => nil, "B" => 2, "C" => 3}, @row.to_hash)
   end
-  
+
   def test_to_csv
     # normal conversion
     assert_equal("1,2,3,4,\n", @row.to_csv)
     assert_equal("1,2,3,4,\n", @row.to_s)  # alias
-    
+
     # with options
     assert_equal( "1|2|3|4|\r\n",
                   @row.to_csv(col_sep: "|", row_sep: "\r\n") )
   end
-  
+
   def test_array_delegation
     assert(!@row.empty?, "Row was empty.")
-    
+
     assert_equal([@row.headers.size, @row.fields.size].max, @row.size)
   end
-  
+
   def test_inspect_shows_header_field_pairs
     str = @row.inspect
     @row.each do |header, field|
@@ -295,13 +295,13 @@ class TestCSVRow < Test::Unit::TestCase
               "Header field pair not found." )
     end
   end
-  
+
   def test_inspect_encoding_is_ascii_compatible
     assert( Encoding.compatible?( Encoding.find("US-ASCII"),
                                   @row.inspect.encoding ),
             "inspect() was not ASCII compatible." )
   end
-  
+
   def test_inspect_shows_symbol_headers_as_bare_attributes
     str = CSV::Row.new(@row.headers.map { |h| h.to_sym }, @row.fields).inspect
     @row.each do |header, field|
diff --git a/test/csv/test_serialization.rb b/test/csv/test_serialization.rb
index 878619f58a..f8e6df1b1d 100644
--- a/test/csv/test_serialization.rb
+++ b/test/csv/test_serialization.rb
@@ -16,48 +16,48 @@ class Hash
   def self.csv_load( meta, headers, fields )
     self[*headers.zip(fields).to_a.flatten.map { |e| eval(e) }]
   end
-  
+
   def csv_headers
     keys.map { |key| key.inspect }
   end
-  
+
   def csv_dump( headers )
     headers.map { |header| fetch(eval(header)).inspect }
   end
 end
 
 class TestSerialization < Test::Unit::TestCase
-  
+
   ### Classes Used to Test Serialization ###
-  
+
   class ReadOnlyName
     def initialize( first, last )
       @first, @last = first, last
     end
 
     attr_reader :first, :last
-    
+
     def ==( other )
       %w{first last}.all? { |att| send(att) == other.send(att) }
     end
   end
 
   Name = Struct.new(:first, :last)
-  
+
   class FullName < Name
     def initialize( first, last, suffix = nil )
       super(first, last)
-      
+
       @suffix = suffix
     end
-    
+
     attr_accessor :suffix
-    
+
     def ==( other )
       %w{first last suffix}.all? { |att| send(att) == other.send(att) }
     end
   end
-  
+
   ### Tests ###
 
   def test_class_dump
@@ -66,8 +66,8 @@ class TestSerialization < Test::Unit::TestCase
               %w{Greg Brown} ].map do |first, last|
       ReadOnlyName.new(first, last)
     end
-    
-    assert_nothing_raised(Exception) do 
+
+    assert_nothing_raised(Exception) do
       @data = CSV.dump(@names)
     end
     assert_equal(<<-END_CLASS_DUMP.gsub(/^\s*/, ""), @data)
@@ -78,15 +78,15 @@ class TestSerialization < Test::Unit::TestCase
     Greg,Brown
     END_CLASS_DUMP
   end
-  
+
   def test_struct_dump
     @names = [ %w{James Gray},
               %w{Dana Gray},
               %w{Greg Brown} ].map do |first, last|
       Name.new(first, last)
     end
-    
-    assert_nothing_raised(Exception) do 
+
+    assert_nothing_raised(Exception) do
       @data = CSV.dump(@names)
     end
     assert_equal(<<-END_STRUCT_DUMP.gsub(/^\s*/, ""), @data)
@@ -97,15 +97,15 @@ class TestSerialization < Test::Unit::TestCase
     Greg,Brown
     END_STRUCT_DUMP
   end
-  
+
   def test_inherited_struct_dump
     @names = [ %w{James Gray II},
               %w{Dana Gray},
               %w{Greg Brown} ].map do |first, last, suffix|
       FullName.new(first, last, suffix)
     end
-    
-    assert_nothing_raised(Exception) do 
+
+    assert_nothing_raised(Exception) do
       @data = CSV.dump(@names)
     end
     assert_equal(<<-END_STRUCT_DUMP.gsub(/^\s*/, ""), @data)
@@ -116,7 +116,7 @@ class TestSerialization < Test::Unit::TestCase
     ,Greg,Brown
     END_STRUCT_DUMP
   end
-  
+
   def test_load
     %w{ test_class_dump
         test_struct_dump
@@ -128,13 +128,13 @@ class TestSerialization < Test::Unit::TestCase
       end
     end
   end
-  
+
   def test_io
     test_class_dump
-    
+
     data_file = File.join(File.dirname(__FILE__), "temp_test_data.csv")
     CSV.dump(@names, File.open(data_file, "w"))
-    
+
     assert(File.exist?(data_file))
     assert_equal(<<-END_IO_DUMP.gsub(/^\s*/, ""), File.read(data_file))
     class,TestSerialization::ReadOnlyName
@@ -143,12 +143,12 @@ class TestSerialization < Test::Unit::TestCase
     Dana,Gray
     Greg,Brown
     END_IO_DUMP
-    
+
     assert_equal(@names, CSV.load(File.open(data_file)))
-    
+
     File.unlink(data_file)
   end
-  
+
   def test_custom_dump_and_load
     obj = {1 => "simple", test: Hash}
     assert_equal(obj, CSV.load(CSV.dump([obj])).first)
diff --git a/test/csv/test_table.rb b/test/csv/test_table.rb
index d0b4d10103..e87f1b2545 100644
--- a/test/csv/test_table.rb
+++ b/test/csv/test_table.rb
@@ -27,32 +27,32 @@ class TestCSVTable < Test::Unit::TestCase
     assert_not_nil(@table)
     assert_instance_of(CSV::Table, @table)
   end
-  
+
   def test_modes
     assert_equal(:col_or_row, @table.mode)
-    
+
     # non-destructive changes, intended for one shot calls
     cols = @table.by_col
     assert_equal(:col_or_row, @table.mode)
     assert_equal(:col, cols.mode)
     assert_equal(@table, cols)
-    
+
     rows = @table.by_row
     assert_equal(:col_or_row, @table.mode)
     assert_equal(:row, rows.mode)
     assert_equal(@table, rows)
-    
+
     # destructive mode changing calls
     assert_equal(@table, @table.by_row!)
     assert_equal(:row, @table.mode)
     assert_equal(@table, @table.by_col_or_row!)
     assert_equal(:col_or_row, @table.mode)
   end
-  
+
   def test_headers
     assert_equal(@rows.first.headers, @table.headers)
   end
-  
+
   def test_index
     ##################
     ### Mixed Mode ###
@@ -60,40 +60,40 @@ class TestCSVTable < Test::Unit::TestCase
     # by row
     @rows.each_index { |i| assert_equal(@rows[i], @table[i]) }
     assert_equal(nil, @table[100])  # empty row
-    
+
     # by col
     @rows.first.headers.each do |header|
       assert_equal(@rows.map { |row| row[header] }, @table[header])
     end
     assert_equal([nil] * @rows.size, @table["Z"])  # empty col
-    
+
     # by cell, row then col
     assert_equal(2, @table[0][1])
     assert_equal(6, @table[1]["C"])
-    
+
     # by cell, col then row
     assert_equal(5, @table["B"][1])
     assert_equal(9, @table["C"][2])
-    
+
     # with headers (by col)
     assert_equal(["B", 2, 5, 8], @header_table["B"])
-    
+
     ###################
     ### Column Mode ###
     ###################
     @table.by_col!
-    
+
     assert_equal([2, 5, 8], @table[1])
     assert_equal([2, 5, 8], @table["B"])
-    
+
     ################
     ### Row Mode ###
     ################
     @table.by_row!
-    
+
     assert_equal(@rows[1], @table[1])
     assert_raise(TypeError) { @table["B"] }
-    
+
     ############################
     ### One Shot Mode Change ###
     ############################
@@ -101,7 +101,7 @@ class TestCSVTable < Test::Unit::TestCase
     assert_equal([2, 5, 8], @table.by_col[1])
     assert_equal(@rows[1], @table[1])
   end
-  
+
   def test_set_row_or_column
     ##################
     ### Mixed Mode ###
@@ -113,7 +113,7 @@ class TestCSVTable < Test::Unit::TestCase
     @table[3] = CSV::Row.new(%w[A B C], [13, 14, 15])
     assert_equal( [%w[A B C], [1, 2, 3], [4, 5, 6], [10, 11, 12], [13, 14, 15]],
                   @table.to_a )
-    
+
     # set col
     @table["Type"] = "data"
     assert_equal( [ %w[A B C Type],
@@ -147,7 +147,7 @@ class TestCSVTable < Test::Unit::TestCase
     10,,12,data,3
     13,,15,data,
     END_RESULT
-    
+
     # with headers
     @header_table["Type"] = "data"
     assert_equal(%w[Type data data data], @header_table["Type"])
@@ -156,7 +156,7 @@ class TestCSVTable < Test::Unit::TestCase
     ### Column Mode ###
     ###################
     @table.by_col!
-    
+
     @table[1] = [2, 5, 11, 14]
     assert_equal( [ %w[A B C Type Index],
                     [1, 2, 3, "data", 1],
@@ -164,7 +164,7 @@ class TestCSVTable < Test::Unit::TestCase
                     [10, 11, 12, "data", 3],
                     [13, 14, 15, "data", nil] ],
                   @table.to_a )
-    
+
     @table["Extra"] = "new stuff"
     assert_equal( [ %w[A B C Type Index Extra],
                     [1, 2, 3, "data", 1, "new stuff"],
@@ -177,7 +177,7 @@ class TestCSVTable < Test::Unit::TestCase
     ### Row Mode ###
     ################
     @table.by_row!
-    
+
     @table[1] = (1..6).to_a
     assert_equal( [ %w[A B C Type Index Extra],
                     [1, 2, 3, "data", 1, "new stuff"],
@@ -185,10 +185,10 @@ class TestCSVTable < Test::Unit::TestCase
                     [10, 11, 12, "data", 3, "new stuff"],
                     [13, 14, 15, "data", nil, "new stuff"] ],
                   @table.to_a )
-    
+
     assert_raise(TypeError) { @table["Extra"] = nil }
   end
-  
+
   def test_each
     ######################
     ### Mixed/Row Mode ###
@@ -201,43 +201,43 @@ class TestCSVTable < Test::Unit::TestCase
 
     # verify that we can chain the call
     assert_equal(@table, @table.each { })
-    
+
     ###################
     ### Column Mode ###
     ###################
     @table.by_col!
-    
+
     headers = @table.headers
     @table.each do |header, column|
       assert_equal(headers.shift, header)
       assert_equal(@table[header], column)
     end
-    
+
     ############################
     ### One Shot Mode Change ###
     ############################
     @table.by_col_or_row!
-    
+
     @table.each { |row| assert_instance_of(CSV::Row, row) }
     @table.by_col.each { |tuple| assert_instance_of(Array, tuple) }
     @table.each { |row| assert_instance_of(CSV::Row, row) }
   end
-  
+
   def test_enumerable
     assert_equal( @rows.values_at(0, 2),
                   @table.select { |row| (row["B"] % 2).zero? } )
-    
+
     assert_equal(@rows[1], @table.find { |row| row["C"] > 5 })
   end
-  
+
   def test_to_a
     assert_equal([%w[A B C], [1, 2, 3], [4, 5, 6], [7, 8, 9]], @table.to_a)
-    
+
     # with headers
     assert_equal( [%w[A B C], [1, 2, 3], [4, 5, 6], [7, 8, 9]],
                   @header_table.to_a )
   end
-  
+
   def test_to_csv
     csv = <<-END_CSV.gsub(/^\s+/, "")
     A,B,C
@@ -245,11 +245,11 @@ class TestCSVTable < Test::Unit::TestCase
     4,5,6
     7,8,9
     END_CSV
-    
+
     # normal conversion
     assert_equal(csv, @table.to_csv)
     assert_equal(csv, @table.to_s)  # alias
-    
+
     # with options
     assert_equal( csv.gsub(",", "|").gsub("\n", "\r\n"),
                   @table.to_csv(col_sep: "|", row_sep: "\r\n") )
@@ -257,36 +257,36 @@ class TestCSVTable < Test::Unit::TestCase
     # with headers
     assert_equal(csv, @header_table.to_csv)
   end
-  
+
   def test_append
     # verify that we can chain the call
     assert_equal(@table, @table << [10, 11, 12])
-    
+
     # Array append
     assert_equal(CSV::Row.new(%w[A B C], [10, 11, 12]), @table[-1])
-    
+
     # Row append
     assert_equal(@table, @table << CSV::Row.new(%w[A B C], [13, 14, 15]))
     assert_equal(CSV::Row.new(%w[A B C], [13, 14, 15]), @table[-1])
   end
-  
+
   def test_delete
     ##################
     ### Mixed Mode ###
     ##################
     # delete a row
     assert_equal(@rows[1], @table.delete(1))
-    
+
     # delete a col
     assert_equal(@rows.map { |row| row["A"] }, @table.delete("A"))
-    
+
     # verify resulting table
     assert_equal(<<-END_RESULT.gsub(/^\s+/, ""), @table.to_csv)
     B,C
     2,3
     8,9
     END_RESULT
-    
+
     ###################
     ### Column Mode ###
     ###################
@@ -295,7 +295,7 @@ class TestCSVTable < Test::Unit::TestCase
 
     assert_equal(@rows.map { |row| row[0] }, @table.delete(0))
     assert_equal(@rows.map { |row| row["C"] }, @table.delete("C"))
-    
+
     # verify resulting table
     assert_equal(<<-END_RESULT.gsub(/^\s+/, ""), @table.to_csv)
     B
@@ -303,7 +303,7 @@ class TestCSVTable < Test::Unit::TestCase
     5
     8
     END_RESULT
-    
+
     ################
     ### Row Mode ###
     ################
@@ -312,7 +312,7 @@ class TestCSVTable < Test::Unit::TestCase
 
     assert_equal(@rows[1], @table.delete(1))
     assert_raise(TypeError) { @table.delete("C") }
-    
+
     # verify resulting table
     assert_equal(<<-END_RESULT.gsub(/^\s+/, ""), @table.to_csv)
     A,B,C
@@ -320,7 +320,7 @@ class TestCSVTable < Test::Unit::TestCase
     7,8,9
     END_RESULT
   end
-  
+
   def test_delete_if
     ######################
     ### Mixed/Row Mode ###
@@ -333,13 +333,13 @@ class TestCSVTable < Test::Unit::TestCase
     A,B,C
     4,5,6
     END_RESULT
-    
+
     ###################
     ### Column Mode ###
     ###################
     setup
     @table.by_col!
-    
+
     assert_equal(@table, @table.delete_if { |h, v| h > "A" })
     assert_equal(<<-END_RESULT.gsub(/^\s+/, ""), @table.to_csv)
     A
@@ -348,7 +348,7 @@ class TestCSVTable < Test::Unit::TestCase
     7
     END_RESULT
   end
-  
+
   def test_values_at
     ##################
     ### Mixed Mode ###
@@ -356,27 +356,27 @@ class TestCSVTable < Test::Unit::TestCase
     # rows
     assert_equal(@rows.values_at(0, 2), @table.values_at(0, 2))
     assert_equal(@rows.values_at(1..2), @table.values_at(1..2))
-    
+
     # cols
     assert_equal([[1, 3], [4, 6], [7, 9]], @table.values_at("A", "C"))
     assert_equal([[2, 3], [5, 6], [8, 9]], @table.values_at("B".."C"))
-    
+
     ###################
     ### Column Mode ###
     ###################
     @table.by_col!
-    
+
     assert_equal([[1, 3], [4, 6], [7, 9]], @table.values_at(0, 2))
     assert_equal([[1, 3], [4, 6], [7, 9]], @table.values_at("A", "C"))
-    
+
     ################
     ### Row Mode ###
     ################
     @table.by_row!
-    
+
     assert_equal(@rows.values_at(0, 2), @table.values_at(0, 2))
     assert_raise(TypeError) { @table.values_at("A", "C") }
-    
+
     ############################
     ### One Shot Mode Change ###
     ############################
@@ -384,22 +384,22 @@ class TestCSVTable < Test::Unit::TestCase
     assert_equal([[1, 3], [4, 6], [7, 9]], @table.by_col.values_at(0, 2))
     assert_equal(@rows.values_at(0, 2), @table.values_at(0, 2))
   end
-  
+
   def test_array_delegation
     assert(!@table.empty?, "Table was empty.")
-    
+
     assert_equal(@rows.size, @table.size)
   end
-  
+
   def test_inspect_shows_current_mode
     str = @table.inspect
     assert(str.include?("mode:#{@table.mode}"), "Mode not shown.")
-    
+
     @table.by_col!
     str = @table.inspect
     assert(str.include?("mode:#{@table.mode}"), "Mode not shown.")
   end
-  
+
   def test_inspect_encoding_is_ascii_compatible
     assert( Encoding.compatible?( Encoding.find("US-ASCII"),
                                   @table.inspect.encoding ),