rio 0.4.2 → 0.5.1

data/test/tc/csv_columns.rb

@@ -19,19 +19,221 @@ class TC_csv_columns < Test::RIO::TestCase
     super
     @src = rio(?")
     @dst_name = 'dst.csv'
-    @records,@strings,@lines,@string = create_test_csv_data(@src,1, 8, false)
+    @records,@strings,@lines,@string = create_test_csv_data(@src,3, 8,',',$/, true)
+    if $USE_FASTER_CSV
+      opts = {:headers => true, :return_headers => true}
+      @rows = []
+      ::CSV.parse(@string, opts) do |row|
+        @rows << row
+      end
+    end
   end
 
+  def col_recs(r,cola)
+    ans = []
+    r.each do |rec|
+      row = []
+      cola.each do |col|
+        row << rec[col]
+      end
+      ans << row.flatten
+    end
+    ans
+  end
   def test_basic
 
     rio('src1.csv') < @src
-    r = @records[0]
-    assert_equal([[r[1],r[2],r[5]]],rio('src1.csv').csv.columns(1,2,5).to_a)
-    assert_equal([r[3...6]],rio('src1.csv').csv.columns(3...6).to_a)
-    assert_equal([[r[3],r[5]]],rio('src1.csv').csv.columns(3...6).skipcolumns(4).to_a)
-    assert_equal([[r[0],r[7]]],rio('src1.csv').csv.skipcolumns(1..6).to_a)
-    assert_equal([[]],rio('src1.csv').csv.skipcolumns.to_a)
-    assert_equal([r],rio('src1.csv').csv.to_a)
+    r = @records
+    assert_equal(col_recs(r,[1,2,5]),rio('src1.csv').csv.columns(1,2,5).to_a)
+    assert_equal(col_recs(r,(3...6).to_a),rio('src1.csv').csv.columns(3...6).to_a)
+    assert_equal(col_recs(r,[3,5]),rio('src1.csv').csv.columns(3...6).skipcolumns(4).to_a)
+    assert_equal(col_recs(r,[0,7]),rio('src1.csv').csv.skipcolumns(1..6).to_a)
+    assert_equal([[],[],[],[]],rio('src1.csv').csv.skipcolumns.to_a)
+    assert_equal(r,rio('src1.csv').csv.columns.to_a)
+    
+  end
+
+  def test_neg_recs
+
+    rio('src1.csv') < @src
+    r = @records
+    assert_equal(col_recs(r,[7]),rio('src1.csv').csv.columns(-1).to_a)
+    assert_equal(col_recs(r,[6]),rio('src1.csv').csv.columns(-2).to_a)
+    assert_equal(col_recs(r,[0..7]),rio('src1.csv').csv.columns(0..-1).to_a)
+    assert_equal(col_recs(r,[0..6]),rio('src1.csv').csv.columns(0..-2).to_a)
+    assert_equal(col_recs(r,[0...7]),rio('src1.csv').csv.columns(0...-1).to_a)
+    assert_equal(col_recs(r,[0...6]),rio('src1.csv').csv.columns(0...-2).to_a)
+
+    assert_equal(col_recs(r,[3..7]),rio('src1.csv').csv.columns(-5..-1).to_a)
+    assert_equal(col_recs(r,[3..6]),rio('src1.csv').csv.columns(-5..-2).to_a)
+    assert_equal(col_recs(r,[3...7]),rio('src1.csv').csv.columns(-5...-1).to_a)
+    assert_equal(col_recs(r,[3...6]),rio('src1.csv').csv.columns(-5...-2).to_a)
+
+    assert_equal(col_recs(r,[3..6]),rio('src1.csv').csv.columns(-5..6).to_a)
+    assert_equal(col_recs(r,[3..7]),rio('src1.csv').csv.columns(-5..7).to_a)
+    assert_equal(col_recs(r,[3..7]),rio('src1.csv').csv.columns(-5..8).to_a)
+    assert_equal(col_recs(r,[3..7]),rio('src1.csv').csv.columns(-5..9).to_a)
+    
+    assert_equal(col_recs(r,[3...6]),rio('src1.csv').csv.columns(-5...6).to_a)
+    assert_equal(col_recs(r,[3...7]),rio('src1.csv').csv.columns(-5...7).to_a)
+    assert_equal(col_recs(r,[3...8]),rio('src1.csv').csv.columns(-5...8).to_a)
+    assert_equal(col_recs(r,[3...8]),rio('src1.csv').csv.columns(-5...9).to_a)
+    
+    assert_equal(col_recs(r,[7..6]),rio('src1.csv').csv.columns(-1..6).to_a)
+    assert_equal(col_recs(r,[7..7]),rio('src1.csv').csv.columns(-1..7).to_a)
+    assert_equal(col_recs(r,[7..8]),rio('src1.csv').csv.columns(-1..8).to_a)
+    assert_equal(col_recs(r,[7..9]),rio('src1.csv').csv.columns(-1..9).to_a)
+    
+    assert_equal(col_recs(r,[7...6]),rio('src1.csv').csv.columns(-1...6).to_a)
+    assert_equal(col_recs(r,[7...7]),rio('src1.csv').csv.columns(-1...7).to_a)
+    assert_equal(col_recs(r,[7...8]),rio('src1.csv').csv.columns(-1...8).to_a)
+    assert_equal(col_recs(r,[7...9]),rio('src1.csv').csv.columns(-1...9).to_a)
+    
+    assert_equal(col_recs(r,[7..2]),rio('src1.csv').csv.columns(-1..-6).to_a)
+    assert_equal(col_recs(r,[7..1]),rio('src1.csv').csv.columns(-1..-7).to_a)
+    assert_equal(col_recs(r,[7..0]),rio('src1.csv').csv.columns(-1..-8).to_a)
+    assert_equal(col_recs(r,[]),rio('src1.csv').csv.columns(-1..-9).to_a)
+    
+  end
+
+  def col_lines(r,cola)
+    ans = []
+    col_recs(r,cola).each do |recs|
+      ans << ::CSV::generate_line(recs)
+    end
+    ans
+  end
+
+  def test_lines
+    if $USE_FASTER_CSV
+      rio('src1.csv') < @src
+      r = @records
+      assert_equal(col_lines(r,[1,2,5]),rio('src1.csv').csv.columns(1,2,5).lines[])
+      assert_equal(col_lines(r,(3...6).to_a),rio('src1.csv').csv.columns(3...6).lines[])
+      assert_equal(col_lines(r,[3,5]),rio('src1.csv').csv.columns(3...6).skipcolumns(4).lines[])
+      assert_equal(col_lines(r,[0,7]),rio('src1.csv').csv.skipcolumns(1..6).lines[])
+      assert_equal(["\n","\n","\n","\n"],rio('src1.csv').csv.skipcolumns.lines[])
+      assert_equal(col_lines(r,(0...r[0].size).to_a),rio('src1.csv').csv.columns.lines[])
+    end
+  end
+
+  def test_neg_lines
+
+    rio('src1.csv') < @src
+    r = @records
+    assert_equal(col_lines(r,[7]),rio('src1.csv').csv.columns(-1).lines[])
+    assert_equal(col_lines(r,[6]),rio('src1.csv').csv.columns(-2).lines[])
+    assert_equal(col_lines(r,[0..7]),rio('src1.csv').csv.columns(0..-1).lines[])
+    assert_equal(col_lines(r,[0..6]),rio('src1.csv').csv.columns(0..-2).lines[])
+    assert_equal(col_lines(r,[0...7]),rio('src1.csv').csv.columns(0...-1).lines[])
+    assert_equal(col_lines(r,[0...6]),rio('src1.csv').csv.columns(0...-2).lines[])
+
+    assert_equal(col_lines(r,[3..7]),rio('src1.csv').csv.columns(-5..-1).lines[])
+    assert_equal(col_lines(r,[3..6]),rio('src1.csv').csv.columns(-5..-2).lines[])
+    assert_equal(col_lines(r,[3...7]),rio('src1.csv').csv.columns(-5...-1).lines[])
+    assert_equal(col_lines(r,[3...6]),rio('src1.csv').csv.columns(-5...-2).lines[])
+
+    assert_equal(col_lines(r,[3..6]),rio('src1.csv').csv.columns(-5..6).lines[])
+    assert_equal(col_lines(r,[3..7]),rio('src1.csv').csv.columns(-5..7).lines[])
+    assert_equal(col_lines(r,[3..7]),rio('src1.csv').csv.columns(-5..8).lines[])
+    assert_equal(col_lines(r,[3..7]),rio('src1.csv').csv.columns(-5..9).lines[])
+    
+    assert_equal(col_lines(r,[3...6]),rio('src1.csv').csv.columns(-5...6).lines[])
+    assert_equal(col_lines(r,[3...7]),rio('src1.csv').csv.columns(-5...7).lines[])
+    assert_equal(col_lines(r,[3...8]),rio('src1.csv').csv.columns(-5...8).lines[])
+    assert_equal(col_lines(r,[3...8]),rio('src1.csv').csv.columns(-5...9).lines[])
+    
+    assert_equal(col_lines(r,[7..6]),rio('src1.csv').csv.columns(-1..6).lines[])
+    assert_equal(col_lines(r,[7..7]),rio('src1.csv').csv.columns(-1..7).lines[])
+    assert_equal(col_lines(r,[7..8]),rio('src1.csv').csv.columns(-1..8).lines[])
+    assert_equal(col_lines(r,[7..9]),rio('src1.csv').csv.columns(-1..9).lines[])
+    
+    assert_equal(col_lines(r,[7...6]),rio('src1.csv').csv.columns(-1...6).lines[])
+    assert_equal(col_lines(r,[7...7]),rio('src1.csv').csv.columns(-1...7).lines[])
+    assert_equal(col_lines(r,[7...8]),rio('src1.csv').csv.columns(-1...8).lines[])
+    assert_equal(col_lines(r,[7...9]),rio('src1.csv').csv.columns(-1...9).lines[])
+    
+    assert_equal(col_lines(r,[7..2]),rio('src1.csv').csv.columns(-1..-6).lines[])
+    assert_equal(col_lines(r,[7..1]),rio('src1.csv').csv.columns(-1..-7).lines[])
+    assert_equal(col_lines(r,[7..0]),rio('src1.csv').csv.columns(-1..-8).lines[])
+    assert_equal(col_lines(r,[]),rio('src1.csv').csv.columns(-1..-9).lines[])
+    
+  end
+
+  def col_rows(r,cola)
+    ans = []
+    col_recs(r,cola).each_with_index do |recs,i|
+      #p recs
+      if $USE_FASTER_CSV
+        ans << ::CSV::Row.new(cola.map{|n| r[0][n]},recs,i==0)
+      else
+        h = {}
+        recs.each_with_index do |rec,n|
+          #p rec,n
+          h["Col#{cola[n]}"]  = rec
+        end
+        ans << h
+      end
+    end
+    first_row = ($USE_FASTER_CSV ? 1 : 0)
+    ans[first_row,r.size-first_row]
+  end
+
+  def test_rows
+    rio('src1.csv') < @src
+    r = @records
+    assert_equal(col_rows(r,[1,2,5]),rio('src1.csv').csv.columns(1,2,5).rows[])
+    assert_equal(col_rows(r,(3...6).to_a),rio('src1.csv').csv.columns(3...6).rows[])
+    assert_equal(col_rows(r,[3,5]),rio('src1.csv').csv.columns(3...6).skipcolumns(4).rows[])
+    assert_equal(col_rows(r,[0,7]),rio('src1.csv').csv.skipcolumns(1..6).rows[])
+    assert_equal(col_rows(r,[]),rio('src1.csv').csv.skipcolumns(3...8,1,0..4).rows[])
+    assert_equal(col_rows(r,[]),rio('src1.csv').csv.skipcolumns.rows[])
+    assert_equal(col_rows(r,(0...r[0].size).to_a),rio('src1.csv').csv.columns.rows[])
+  end
+
+  def test_neg_rows
+
+    rio('src1.csv') < @src
+    r = @records
+    assert_equal(col_rows(r,[7]),rio('src1.csv').csv.columns(-1).rows[])
+    assert_equal(col_rows(r,[6]),rio('src1.csv').csv.columns(-2).rows[])
+    assert_equal(col_rows(r,(0..7).to_a),rio('src1.csv').csv.columns(0..-1).rows[])
+    assert_equal(col_rows(r,(0..6).to_a),rio('src1.csv').csv.columns(0..-2).rows[])
+    assert_equal(col_rows(r,(0...7).to_a),rio('src1.csv').csv.columns(0...-1).rows[])
+    assert_equal(col_rows(r,(0...6).to_a),rio('src1.csv').csv.columns(0...-2).rows[])
+
+    assert_equal(col_rows(r,(3..7).to_a),rio('src1.csv').csv.columns(-5..-1).rows[])
+    assert_equal(col_rows(r,(3..6).to_a),rio('src1.csv').csv.columns(-5..-2).rows[])
+    assert_equal(col_rows(r,(3...7).to_a),rio('src1.csv').csv.columns(-5...-1).rows[])
+    assert_equal(col_rows(r,(3...6).to_a),rio('src1.csv').csv.columns(-5...-2).rows[])
+
+    assert_equal(col_rows(r,(3..6).to_a),rio('src1.csv').csv.columns(-5..6).rows[])
+    assert_equal(col_rows(r,(3..7).to_a),rio('src1.csv').csv.columns(-5..7).rows[])
+    assert_equal(col_rows(r,(3..7).to_a),rio('src1.csv').csv.columns(-5..8).rows[])
+    assert_equal(col_rows(r,(3..7).to_a),rio('src1.csv').csv.columns(-5..9).rows[])
+    
+    assert_equal(col_rows(r,(3...6).to_a),rio('src1.csv').csv.columns(-5...6).rows[])
+    assert_equal(col_rows(r,(3...7).to_a),rio('src1.csv').csv.columns(-5...7).rows[])
+    assert_equal(col_rows(r,(3...8).to_a),rio('src1.csv').csv.columns(-5...8).rows[])
+    assert_equal(col_rows(r,(3...8).to_a),rio('src1.csv').csv.columns(-5...9).rows[])
+    
+    assert_equal(col_rows(r,(7..6).to_a),rio('src1.csv').csv.columns(-1..6).rows[])
+    assert_equal(col_rows(r,(7..7).to_a),rio('src1.csv').csv.columns(-1..7).rows[])
+    assert_equal(col_rows(r,(7..7).to_a),rio('src1.csv').csv.columns(-1..8).rows[])
+    assert_equal(col_rows(r,(7..7).to_a),rio('src1.csv').csv.columns(-1..9).rows[])
+    
+    assert_equal(col_rows(r,(7...6).to_a),rio('src1.csv').csv.columns(-1...6).rows[])
+    assert_equal(col_rows(r,(7...7).to_a),rio('src1.csv').csv.columns(-1...7).rows[])
+    assert_equal(col_rows(r,(7...8).to_a),rio('src1.csv').csv.columns(-1...8).rows[])
+    assert_equal(col_rows(r,(7...8).to_a),rio('src1.csv').csv.columns(-1...9).rows[])
+    
+    assert_equal(col_rows(r,(7..2).to_a),rio('src1.csv').csv.columns(-1..-6).rows[])
+    assert_equal(col_rows(r,(7..1).to_a),rio('src1.csv').csv.columns(-1..-7).rows[])
+    assert_equal(col_rows(r,(7..0).to_a),rio('src1.csv').csv.columns(-1..-8).rows[])
+    assert_equal(col_rows(r,[]),rio('src1.csv').csv.columns(-1..-9).rows[])
     
   end
+
+
+
 end

data/test/tc/csv_gzip.rb

@@ -0,0 +1,78 @@
+#!/usr/local/bin/ruby
+if $0 == __FILE__
+  Dir.chdir File.dirname(__FILE__)+'/../'
+  $:.unshift File.expand_path('../lib/')
+end
+
+require 'rio'
+require 'tc/testcase'
+require 'tc/csvutil'
+
+class TC_csv_gzip < Test::RIO::TestCase
+  include CSV_Util
+
+  @@once = false
+  def self.once
+    @@once = true
+  end
+  def setup()
+    super
+    @src = rio(?")
+    @dst_name = 'dst.csv'
+    @records,@strings,@lines,@string = create_test_csv_data(@src,3, 3, ',', $/, true)
+    if $USE_FASTER_CSV
+      opts = {:headers => true, :return_headers => true}
+      @rows = []
+      ::CSV.parse(@string, opts) do |row|
+        @rows << row
+      end
+    else
+      @rows = []
+      @records.each do |rec|
+        h = {}
+        (0...rec.size).each do |n|
+          h["Col#{n}"] = rec[n]
+        end
+        @rows << h
+      end
+    end
+      
+  end
+
+  def test_basic
+    rio('basic.csv') < @string
+    assert_equal(@string,File.read('basic.csv'))
+    rio('basic.csv').csv > rio('basic.csv.gz').csv.gzip
+    assert_equal(@lines, rio('basic.csv.gz').csv.gzip.lines[])    
+    assert_equal(@records, rio('basic.csv.gz').csv.gzip.records[])
+    assert_equal(@rows[1...@rows.size], rio('basic.csv.gz').csv.gzip.rows[])
+
+    rio('basic.csv.gz').csv.gzip < rio('basic.csv').csv
+    assert_equal(@lines, rio('basic.csv.gz').csv.gzip.lines[])    
+    assert_equal(@records, rio('basic.csv.gz').csv.gzip.records[])
+    assert_equal(@rows[1...@rows.size], rio('basic.csv.gz').csv.gzip.rows[])
+  end
+
+  def test_copy
+    rio('copy.csv') < @string
+    assert_equal(@string,File.read('copy.csv'))
+
+    rio('copy.csv').csv > rio('copy.csv.gz').csv.gzip
+    rio('copy.csv.gz').csv.gzip > rio('out.csv').csv
+    assert_equal(@lines, rio('out.csv').csv.lines[])    
+
+    rio('out1.csv.gz').csv.gzip < rio('copy.csv.gz').csv.gzip
+    assert_equal(@lines, rio('out1.csv.gz').csv.gzip.lines[])    
+    rio('copy.csv.gz').csv.gzip > rio('out2.csv.gz').csv.gzip 
+    assert_equal(@string, rio('out2.csv.gz').gzip.contents)    
+
+    csv_arg = ($USE_FASTER_CSV ? {:col_sep => ';'} : ';')
+    rio('out3.csv.gz').csv(csv_arg).gzip < rio('copy.csv.gz').csv.gzip
+    assert_equal(@string.gsub(',',';'), rio('out3.csv.gz').gzip.contents)    
+    rio('copy.csv.gz').csv.gzip > rio('out4.csv.gz').csv(csv_arg).gzip 
+    assert_equal(@string.gsub(',',';'), rio('out4.csv.gz').gzip.contents)    
+
+  end
+
+
+end

data/test/tc/csv_headers.rb

@@ -0,0 +1,134 @@
+#!/usr/local/bin/ruby
+if $0 == __FILE__
+  Dir.chdir File.dirname(__FILE__)+'/../'
+  $:.unshift File.expand_path('../lib/')
+end
+
+require 'rio'
+require 'tc/testcase'
+require 'tc/csvutil'
+
+class TC_csv_headers < Test::RIO::TestCase
+  include CSV_Util
+
+  @@once = false
+  def self.once
+    @@once = true
+  end
+
+  def setup()
+    super
+    @src = rio(?")
+    @dst_name = 'dst.csv'
+    @records,@strings,@lines,@string = create_test_csv_data(@src,2, 5,',',$/, true)
+    if $USE_FASTER_CSV
+      opts = {:headers => true, :return_headers => true}
+      @rows = []
+      ::CSV.parse(@string, opts) do |row|
+        @rows << row
+      end
+    end
+  end
+
+  def col_recs(r,cola)
+    ans = []
+    r.each do |rec|
+      row = []
+      cola.each do |col|
+        row << rec[col]
+      end
+      ans << row.flatten
+    end
+    ans
+  end
+
+  def test_basic
+    rio('basic.csv') < @src
+    r = @records
+    assert_equal(r[0,3],rio('basic.csv').csv[])
+    assert_equal(r[1,2],rio('basic.csv').csv.headers.records[])
+    assert_equal([r[0]],rio('basic.csv').csv.headers?)
+    
+    assert_equal(r[0,3],rio('basic.csv').csv(:return_headers => true).headers.records[])
+    
+    heads = (0..2).map{|n| "HEAD#{n}"}
+    assert_equal(r[0,3],rio('basic.csv').csv.headers(heads).records[])
+    assert_equal(heads,rio('basic.csv').csv.headers(heads).headers?)
+    assert_equal([heads] + r[0,3],rio('basic.csv').csv(:return_headers => true).headers(heads).records[])
+    
+  end
+
+  def test_num_columns
+    rio('columns.csv') < @src
+    r = @records
+    exp = r.map{|el| [el[1]]}
+    assert_equal(exp,rio('columns.csv').csv.columns(1)[])
+    exp = r[1,2].map{|el| [el[1]]}
+    assert_equal(exp,rio('columns.csv').csv.headers.columns(1)[])
+    heads = (0..2).map{|n| "HEAD#{n}"}
+    exp = r.map{|el| [el[1]]}
+    assert_equal(exp,rio('columns.csv').csv.headers(heads).columns(1).records[])
+    exp = [["HEAD1"]] + exp
+    assert_equal(exp,rio('basic.csv').csv(:return_headers => true).headers(heads).columns(1).records[])
+
+#    p rio('columns.csv').csv.headers(heads).records[]
+  end
+  def col_rows(r,cola,heads=nil)
+    ans = []
+    col_recs(r,cola).each_with_index do |recs,i|
+      #p recs
+      if $USE_FASTER_CSV
+        heads ||= cola.map{|n| r[0][n]}
+        ans << ::CSV::Row.new(heads,recs,i==0)
+      else
+        h = {}
+        recs.each_with_index do |rec,n|
+          #p rec,n
+          h["Col#{cola[n]}"]  = rec
+        end
+        ans << h
+      end
+    end
+    first_row = ($USE_FASTER_CSV ? 1 : 0)
+    ans[first_row,r.size-first_row]
+  end
+
+  def test_named_columns
+    rio('fields.csv') < @src
+    r = @records
+    exp = col_rows(r,[1,2,3,4])
+    #assert_equal(exp,rio('fields.csv').csv.columns(1).rows[])
+    exp = col_rows(r,[1,2,3,4])
+    assert_equal(exp,rio('fields.csv').csv.columns('Head1'..'Head4').rows[])
+    exp = col_rows(r,[1,2,4])
+    assert_equal(exp,rio('fields.csv').csv.columns('Head1'..'Head4').skipcolumns('Head3').rows[])
+    exp = col_rows(r,[3,4])
+    assert_equal(exp,rio('fields.csv').csv.columns('Head1'..'Head4').skipcolumns('Head0'...'Head3').rows[])
+
+#    p rio('fields.csv').csv.headers(heads).records[]
+  end
+
+  def test_mixed_columns
+    rio('mixed.csv') < @src
+    r = @records
+    exp = col_rows(r,[1,2,3])
+    assert_equal(exp,rio('mixed.csv').csv.columns('Head1'..'Head3').rows[])
+    assert_equal(exp,rio('mixed.csv').csv.columns('Head1'...'Head4').rows[])
+    assert_equal(exp,rio('mixed.csv').csv.columns('Head1',2,'Head3'...'Head4').rows[])
+    assert_equal(exp,rio('mixed.csv').csv.columns('Head2',1...4).rows[])
+    assert_equal(exp,rio('mixed.csv').csv.columns('Head0'..'Head4').skipcolumns(0,'Head4').rows[])
+
+  end
+
+  def test_external_columns
+    rio('external.csv') < @src
+    r = @records
+    heads = (0..4).map{|n| "HEAD#{n}"}
+    exp = col_rows([heads] + r[0,3],[0,1,2,3,4],heads)
+    assert_equal(exp,rio('external.csv').csv.headers(heads).rows[])
+    exp = col_rows([heads[1,3]] + r[0,3],[1,2,3],heads[1,3])
+    assert_equal(exp,rio('external.csv').csv.headers(heads).columns('HEAD1'..'HEAD3').rows[])
+  end
+
+
+end

data/test/tc/csvutil.rb

@@ -4,8 +4,6 @@ if $0 == __FILE__
   $:.unshift File.expand_path('../lib/')
 end
 
-require 'rio'
-
 module CSV_Util
   def records_to_rows(records)
     n_records = records.size
@@ -21,34 +19,73 @@ module CSV_Util
     end
     rows
   end
-  def records_to_strings(records)
-    records.map { |values| values.join(',') }
+  def records_to_strings(records,fs=',')
+    records.map { |values| values.join(fs) }
   end
-  def records_to_string(records)
-    records_to_strings(records).join("\n") + "\n"
+  def records_to_string(records,fs=',',rs=$/)
+    records_to_strings(records,fs).join(rs) + rs
   end
-  def strings_to_string(strings)
-    strings.join("\n") + "\n"
+  def strings_to_string(strings,rs=$/)
+    strings.join(rs) + rs
   end
-  def strings_to_lines(strings)
-    strings.map { |s| s + "\n" }
+  def strings_to_lines(strings,rs=$/)
+    strings.map { |s| s + rs }
   end
   def create_test_csv_records(n_rows,n_cols,header=true)
     records = []
     
-    records << (0...n_cols).map { |n| "Head#{n}" } if header
+    records << (0...n_cols).map { |n| %{Head#{n}} } if header
     
     (0...n_rows).each do |nrow|
-      records << (0...n_cols).map { |n| "Dat#{nrow}#{n}" }
+      records << (0...n_cols).map { |n| %{Dat#{nrow}#{n}} }
     end
     records
   end
 
-  def create_test_csv_data(frio,n_rows,n_cols,header=true)
+  def tcsv_gen_header_fields(n_cols)
+    (0...n_cols).map { |n| %{Head#{n}} }
+  end
+  def tcsv_gen_data_fields(nrow,n_cols)
+    (0...n_cols).map { |n| %{Dat#{nrow}#{n}} }
+  end
+  def tcsv_gen_recs(n_rows,n_cols,header=true)
+    recs = []
+    recs << tcsv_gen_header_fields(n_cols) if header
+    (0...n_rows).each do |nrow|
+      recs << tcsv_gen_data_fields(nrow,n_cols)
+    end
+    recs
+  end
+
+
+  def tcsv_rec_strings(recs,fs,qc)
+    tcsv_rec_lines(recs,fs,"",qc).map{ |s| s.chomp }
+  end
+
+  def tcsv_rec_lines(recs,fs,rs,qc)
+    lines = []
+    recs.each do |rec|
+      lines << ::CSV.generate_line(rec,{:col_sep => fs, 
+                            :row_sep => $/, 
+                            :quote_char => qc}).chomp + $/
+    end
+    lines
+  end
+
+  def create_test_csv_file(frio,n_rows,n_cols,fs,rs,qc,header=true)
+    records = tcsv_gen_recs(n_rows,n_cols,header)
+    lines = tcsv_rec_lines(records,fs,rs,qc)
+    strings = tcsv_rec_strings(records,fs,qc)
+    string = strings.join($/) + $/
+    frio < string
+    [records,strings,lines,string]
+  end
+
+  def create_test_csv_data(frio,n_rows,n_cols,fs,rs,header=true)
     records = create_test_csv_records(n_rows,n_cols,header)
-    strings = records_to_strings(records)
-    lines = strings_to_lines(strings)
-    string = strings_to_string(strings)
+    strings = records_to_strings(records,fs)
+    lines = strings_to_lines(strings,rs)
+    string = strings_to_string(strings,rs)
     frio < string
     [records,strings,lines,string]
   end