← Back to branch summary

~ubuntu-branches/ubuntu/hardy/ruby1.8/hardy-updates

« back to all changes in this revision

Viewing changes to test/csv/test_csv.rb

  • Committer: Bazaar Package Importer
  • Author(s): akira yamada
  • Date: 2007-03-13 22:11:58 UTC
  • mfrom: (1.1.5 upstream)
  • Revision ID: james.westby@ubuntu.com-20070313221158-h3oql37brlaf2go2
Tags: 1.8.6-1
http://bugs.debian.org/410018
* new upstream version, 1.8.6.
* libruby1.8 conflicts with libopenssl-ruby1.8 (< 1.8.6) (closes: #410018)
* changed packaging style to cdbs from dbs.

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/csv/test_csv.rb
 
1
require 'test/unit'
 
2
require 'tempfile'
 
3
require 'fileutils'
 
4
 
 
5
require 'csv'
 
6
 
 
7
class CSV
 
8
  class StreamBuf
 
9
    # Let buffer work hard.
 
10
    remove_const("BufSize")
 
11
    BufSize = 2
 
12
  end
 
13
end
 
14
 
 
15
 
 
16
module CSVTestSupport
 
17
  def d(data)
 
18
    data
 
19
  end
 
20
end
 
21
 
 
22
 
 
23
class TestCSV < Test::Unit::TestCase
 
24
  file = Tempfile.new("crlf")
 
25
  file << "\n"
 
26
  file.open
 
27
  file.binmode
 
28
  RSEP = file.read
 
29
  file.close
 
30
 
 
31
  include CSVTestSupport
 
32
 
 
33
  class << self
 
34
    include CSVTestSupport
 
35
  end
 
36
 
 
37
  @@simpleCSVData = {
 
38
    [nil] => '',
 
39
    [''] => '""',
 
40
    [nil, nil] => ',',
 
41
    [nil, nil, nil] => ',,',
 
42
    ['foo'] => 'foo',
 
43
    [','] => '","',
 
44
    [',', ','] => '",",","',
 
45
    [';'] => ';',
 
46
    [';', ';'] => ';,;',
 
47
    ["\"\r", "\"\r"] => "\"\"\"\r\",\"\"\"\r\"",
 
48
    ["\"\n", "\"\n"] => "\"\"\"\n\",\"\"\"\n\"",
 
49
    ["\t"] => "\t",
 
50
    ["\t", "\t"] => "\t,\t",
 
51
    ['foo', 'bar'] => 'foo,bar',
 
52
    ['foo', '"bar"', 'baz'] => 'foo,"""bar""",baz',
 
53
    ['foo', 'foo,bar', 'baz'] => 'foo,"foo,bar",baz',
 
54
    ['foo', '""', 'baz'] => 'foo,"""""",baz',
 
55
    ['foo', '', 'baz'] => 'foo,"",baz',
 
56
    ['foo', nil, 'baz'] => 'foo,,baz',
 
57
    [nil, 'foo', 'bar'] => ',foo,bar',
 
58
    ['foo', 'bar', nil] => 'foo,bar,',
 
59
    ['foo', "\r", 'baz'] => "foo,\"\r\",baz",
 
60
    ['foo', "\n", 'baz'] => "foo,\"\n\",baz",
 
61
    ['foo', "\r\n\r", 'baz'] => "foo,\"\r\n\r\",baz",
 
62
    ['foo', "\r\n", 'baz'] => "foo,\"\r\n\",baz",
 
63
    ['foo', "\r.\n", 'baz'] => "foo,\"\r.\n\",baz",
 
64
    ['foo', "\r\n\n", 'baz'] => "foo,\"\r\n\n\",baz",
 
65
    ['foo', '"', 'baz'] => 'foo,"""",baz',
 
66
  }
 
67
 
 
68
  @@fullCSVData = {
 
69
    [d(nil)] => '',
 
70
    [d('')] => '""',
 
71
    [d(nil), d(nil)] => ',',
 
72
    [d(nil), d(nil), d(nil)] => ',,',
 
73
    [d('foo')] => 'foo',
 
74
    [d('foo'), d('bar')] => 'foo,bar',
 
75
    [d('foo'), d('"bar"'), d('baz')] => 'foo,"""bar""",baz',
 
76
    [d('foo'), d('foo,bar'), d('baz')] => 'foo,"foo,bar",baz',
 
77
    [d('foo'), d('""'), d('baz')] => 'foo,"""""",baz',
 
78
    [d('foo'), d(''), d('baz')] => 'foo,"",baz',
 
79
    [d('foo'), d(nil), d('baz')] => 'foo,,baz',
 
80
    [d('foo'), d("\r"), d('baz')] => "foo,\"\r\",baz",
 
81
    [d('foo'), d("\n"), d('baz')] => "foo,\"\n\",baz",
 
82
    [d('foo'), d("\r\n"), d('baz')] => "foo,\"\r\n\",baz",
 
83
    [d('foo'), d("\r.\n"), d('baz')] => "foo,\"\r.\n\",baz",
 
84
    [d('foo'), d("\r\n\n"), d('baz')] => "foo,\"\r\n\n\",baz",
 
85
    [d('foo'), d('"'), d('baz')] => 'foo,"""",baz',
 
86
  }
 
87
 
 
88
  @@fullCSVDataArray = @@fullCSVData.collect { |key, value| key }
 
89
 
 
90
  def ssv2csv(ssvStr, row_sep = nil)
 
91
    sepConv(ssvStr, ?;, ?,, row_sep)
 
92
  end
 
93
 
 
94
  def csv2ssv(csvStr, row_sep = nil)
 
95
    sepConv(csvStr, ?,, ?;, row_sep)
 
96
  end
 
97
 
 
98
  def tsv2csv(tsvStr, row_sep = nil)
 
99
    sepConv(tsvStr, ?\t, ?,, row_sep)
 
100
  end
 
101
 
 
102
  def csv2tsv(csvStr, row_sep = nil)
 
103
    sepConv(csvStr, ?,, ?\t, row_sep)
 
104
  end
 
105
 
 
106
  def sepConv(srcStr, srcSep, destSep, row_sep = nil)
 
107
    rows = []
 
108
    cols, idx = CSV.parse_row(srcStr, 0, rows, srcSep, row_sep)
 
109
    destStr = ''
 
110
    cols = CSV.generate_row(rows, rows.size, destStr, destSep, row_sep)
 
111
    destStr
 
112
  end
 
113
 
 
114
public
 
115
 
 
116
  def setup
 
117
    @tmpdir = File.join(Dir.tmpdir, "ruby_test_csv_tmp_#{$$}")
 
118
    Dir.mkdir(@tmpdir)
 
119
    @infile = File.join(@tmpdir, 'in.csv')
 
120
    @infiletsv = File.join(@tmpdir, 'in.tsv')
 
121
    @emptyfile = File.join(@tmpdir, 'empty.csv')
 
122
    @outfile = File.join(@tmpdir, 'out.csv')
 
123
    @bomfile = File.join(@tmpdir, "bom.csv")
 
124
    @macfile = File.join(@tmpdir, "mac.csv")
 
125
 
 
126
    CSV.open(@infile, "wb") do |writer|
 
127
      @@fullCSVDataArray.each do |row|
 
128
        writer.add_row(row)
 
129
      end
 
130
    end
 
131
 
 
132
    CSV.open(@infiletsv, "wb", ?\t) do |writer|
 
133
      @@fullCSVDataArray.each do |row|
 
134
        writer.add_row(row)
 
135
      end
 
136
    end
 
137
 
 
138
    CSV.generate(@emptyfile) do |writer|
 
139
      # Create empty file.
 
140
    end
 
141
 
 
142
    File.open(@bomfile, "wb") do |f|
 
143
      f.write("\357\273\277\"foo\"\r\n\"bar\"\r\n")
 
144
    end
 
145
 
 
146
    File.open(@macfile, "wb") do |f|
 
147
      f.write("\"Avenches\",\"aus Umgebung\"\r\"Bad Hersfeld\",\"Ausgrabung\"")
 
148
    end
 
149
  end
 
150
 
 
151
  def teardown
 
152
    FileUtils.rm_rf(@tmpdir)
 
153
  end
 
154
 
 
155
  #### CSV::Reader unit test
 
156
  
 
157
  def test_Reader_each
 
158
    file = File.open(@infile, "rb")
 
159
    begin
 
160
      reader = CSV::Reader.create(file)
 
161
      expectedArray = @@fullCSVDataArray.dup
 
162
      first = true
 
163
      ret = reader.each { |row|
 
164
        if first
 
165
          assert_instance_of(Array, row)
 
166
          first = false
 
167
        end
 
168
        expected = expectedArray.shift
 
169
        assert_equal(expected, row)
 
170
      }
 
171
      assert_nil(ret, "Return is nil")
 
172
      assert(expectedArray.empty?)
 
173
    ensure
 
174
      file.close
 
175
    end
 
176
 
 
177
    # Illegal format.
 
178
    reader = CSV::Reader.create("a,b\r\na,b,\"c\"\ra")
 
179
    assert_raises(CSV::IllegalFormatError) do
 
180
      reader.each do |row|
 
181
      end
 
182
    end
 
183
 
 
184
    reader = CSV::Reader.create("a,b\r\n\"")
 
185
    assert_raises(CSV::IllegalFormatError) do
 
186
      reader.each do |row|
 
187
      end
 
188
    end
 
189
  end
 
190
 
 
191
  def test_Reader_shift
 
192
    file = File.open(@infile, "rb")
 
193
    begin
 
194
      reader = CSV::Reader.create(file)
 
195
      first = true
 
196
      checked = 0
 
197
      @@fullCSVDataArray.each do |expected|
 
198
        actual = reader.shift
 
199
        if first
 
200
          assert_instance_of(Array, actual)
 
201
          first = false
 
202
        end
 
203
        assert_equal(expected, actual)
 
204
        checked += 1
 
205
      end
 
206
      assert(checked == @@fullCSVDataArray.size)
 
207
    ensure
 
208
      file.close
 
209
    end
 
210
 
 
211
    # Illegal format.
 
212
    reader = CSV::Reader.create("a,b\r\na,b,\"c\"\ra")
 
213
    assert_raises(CSV::IllegalFormatError) do
 
214
      reader.shift
 
215
      reader.shift
 
216
    end
 
217
 
 
218
    reader = CSV::Reader.create("a,b\r\na,b,\"c\"\ra")
 
219
    assert_raises(CSV::IllegalFormatError) do
 
220
      reader.shift
 
221
      reader.shift
 
222
    end
 
223
  end
 
224
 
 
225
  def test_Reader_getRow
 
226
    if CSV::Reader.respond_to?(:allocate)
 
227
      obj = CSV::Reader.allocate
 
228
      assert_raises(NotImplementedError) do
 
229
        row = []
 
230
        obj.shift
 
231
      end
 
232
    end
 
233
  end
 
234
 
 
235
  def test_IOReader_close_on_terminate
 
236
    f = File.open(@infile, "r")
 
237
    reader = CSV::IOReader.create(f)
 
238
    reader.close
 
239
    assert(!f.closed?)
 
240
    f.close
 
241
 
 
242
    f = File.open(@infile, "r")
 
243
    writer = CSV::IOReader.create(f)
 
244
    writer.close_on_terminate
 
245
    writer.close
 
246
    assert(f.closed?)
 
247
  end
 
248
 
 
249
  def test_Reader_close
 
250
    f = File.open(@infile, "r")
 
251
    reader = CSV::IOReader.create(f)
 
252
    reader.close_on_terminate
 
253
    reader.close
 
254
    assert(f.closed?)
 
255
  end
 
256
 
 
257
  def test_Reader_s_new
 
258
    assert_raises(RuntimeError) do
 
259
      CSV::Reader.new(nil)
 
260
    end
 
261
  end
 
262
 
 
263
  def test_Reader_s_create
 
264
    reader = CSV::Reader.create("abc")
 
265
    assert_instance_of(CSV::StringReader, reader, "With a String")
 
266
 
 
267
    file = File.open(@infile, "rb")
 
268
    reader = CSV::Reader.create(file)
 
269
    assert_instance_of(CSV::IOReader, reader, 'With an IO')
 
270
 
 
271
    obj = Object.new
 
272
    def obj.sysread(size)
 
273
      "abc"
 
274
    end
 
275
    def obj.read(size)
 
276
      "abc"
 
277
    end
 
278
    reader = CSV::Reader.create(obj)
 
279
    assert_instance_of(CSV::IOReader, reader, "With not an IO or String")
 
280
 
 
281
    # No need to test Tempfile because it's a pseudo IO.  I test this here
 
282
    # fors other tests.
 
283
    reader = CSV::Reader.create(Tempfile.new("in.csv"))
 
284
    assert_instance_of(CSV::IOReader, reader, "With an pseudo IO.")
 
285
    file.close
 
286
  end
 
287
 
 
288
  def test_IOReader_s_create_binmode
 
289
    file = File.open(@outfile, "wb")
 
290
    file << "\"\r\n\",\"\r\",\"\n\"\r1,2,3"
 
291
    file.close
 
292
 
 
293
    file = File.open(@outfile, "rb")
 
294
    begin
 
295
      reader = CSV::IOReader.new(file, ?,, ?\r)
 
296
      assert_equal(["\r\n", "\r", "\n"], reader.shift.to_a)
 
297
      assert_equal(["1", "2", "3"], reader.shift.to_a)
 
298
      reader.close
 
299
    ensure
 
300
      file.close
 
301
    end
 
302
 
 
303
    file = File.open(@outfile, "r")     # not "rb"
 
304
    begin
 
305
      lfincell = (RSEP == "\n" ? "\r\n" : "\n")
 
306
      reader = CSV::IOReader.new(file, ?,, ?\r)
 
307
      assert_equal([lfincell, "\r", "\n"], reader.shift.to_a)
 
308
      assert_equal(["1", "2", "3"], reader.shift.to_a)
 
309
      reader.close
 
310
    ensure
 
311
      file.close
 
312
    end
 
313
  end
 
314
 
 
315
  def test_Reader_s_parse
 
316
    ret = CSV::Reader.parse("a,b,c") { |row|
 
317
      assert_instance_of(Array, row, "Block parameter")
 
318
    }
 
319
    assert_nil(ret, "Return is nil")
 
320
 
 
321
    ret = CSV::Reader.parse("a;b;c", ?;) { |row|
 
322
      assert_instance_of(Array, row, "Block parameter")
 
323
    }
 
324
 
 
325
    file = Tempfile.new("in.csv")
 
326
    file << "a,b,c"
 
327
    file.open
 
328
    ret = CSV::Reader.parse(file) { |row|
 
329
      assert_instance_of(Array, row, "Block parameter")
 
330
    }
 
331
    assert_nil(ret, "Return is nil")
 
332
 
 
333
    file = Tempfile.new("in.csv")
 
334
    file << "a,b,c"
 
335
    file.open
 
336
    ret = CSV::Reader.parse(file, ?,) { |row|
 
337
      assert_instance_of(Array, row, "Block parameter")
 
338
    }
 
339
 
 
340
    # Illegal format.
 
341
    assert_raises(CSV::IllegalFormatError) do
 
342
      CSV::Reader.parse("a,b\r\na,b,\"c\"\ra") do |row|
 
343
      end
 
344
    end
 
345
 
 
346
    assert_raises(CSV::IllegalFormatError) do
 
347
      CSV::Reader.parse("a,b\r\na,b\"") do |row|
 
348
      end
 
349
    end
 
350
  end
 
351
 
 
352
 
 
353
  #### CSV::Writer unit test
 
354
  
 
355
  def test_Writer_s_new
 
356
    assert_raises(RuntimeError) do
 
357
      CSV::Writer.new(nil)
 
358
    end
 
359
  end
 
360
 
 
361
  def test_Writer_s_generate
 
362
    ret = CSV::Writer.generate(STDOUT) { |writer|
 
363
      assert_instance_of(CSV::BasicWriter, writer, "Block parameter")
 
364
    }
 
365
 
 
366
    ret = CSV::Writer.generate(STDOUT, ?;) { |writer|
 
367
      assert_instance_of(CSV::BasicWriter, writer, "Block parameter")
 
368
    }
 
369
 
 
370
    assert_nil(ret, "Return is nil")
 
371
  end
 
372
 
 
373
  def test_Writer_s_create
 
374
    writer = CSV::Writer.create(STDERR)
 
375
    assert_instance_of(CSV::BasicWriter, writer, "String")
 
376
 
 
377
    writer = CSV::Writer.create(STDERR, ?;)
 
378
    assert_instance_of(CSV::BasicWriter, writer, "String")
 
379
 
 
380
    writer = CSV::Writer.create(Tempfile.new("out.csv"))
 
381
    assert_instance_of(CSV::BasicWriter, writer, "IO")
 
382
  end
 
383
 
 
384
  def test_Writer_LSHIFT # '<<'
 
385
    file = Tempfile.new("out.csv")
 
386
    CSV::Writer.generate(file) do |writer|
 
387
      ret = writer << ['a', 'b', 'c']
 
388
      assert_instance_of(CSV::BasicWriter, ret, 'Return is self')
 
389
 
 
390
      writer << [nil, 'e', 'f'] << [nil, nil, '']
 
391
    end
 
392
    file.open
 
393
    file.binmode
 
394
    str = file.read
 
395
    assert_equal("a,b,c#{RSEP},e,f#{RSEP},,\"\"#{RSEP}", str, 'Normal')
 
396
 
 
397
    file = Tempfile.new("out2.csv")
 
398
    CSV::Writer.generate(file) do |writer|
 
399
      ret = writer << [d('a'), d('b'), d('c')]
 
400
      assert_instance_of(CSV::BasicWriter, ret, 'Return is self')
 
401
 
 
402
      writer << [d(nil), d('e'), d('f')] << [d(nil), d(nil), d('')]
 
403
    end
 
404
    file.open
 
405
    file.binmode
 
406
    str = file.read
 
407
    assert_equal("a,b,c#{RSEP},e,f#{RSEP},,\"\"#{RSEP}", str, 'Normal')
 
408
  end
 
409
 
 
410
  def test_Writer_add_row
 
411
    file = Tempfile.new("out.csv")
 
412
    CSV::Writer.generate(file) do |writer|
 
413
      ret = writer.add_row(
 
414
        [d('a'), d('b'), d('c')])
 
415
      assert_instance_of(CSV::BasicWriter, ret, 'Return is self')
 
416
 
 
417
      writer.add_row(
 
418
        [d(nil), d('e'), d('f')]
 
419
     ).add_row(
 
420
        [d(nil), d(nil), d('')]
 
421
     )
 
422
    end
 
423
    file.open
 
424
    file.binmode
 
425
    str = file.read
 
426
    assert_equal("a,b,c#{RSEP},e,f#{RSEP},,\"\"#{RSEP}", str, 'Normal')
 
427
  end
 
428
 
 
429
  def test_Writer_close
 
430
    f = File.open(@outfile, "w")
 
431
    writer = CSV::BasicWriter.create(f)
 
432
    writer.close_on_terminate
 
433
    writer.close
 
434
    assert(f.closed?)
 
435
  end
 
436
 
 
437
  def test_BasicWriter_close_on_terminate
 
438
    f = File.open(@outfile, "w")
 
439
    writer = CSV::BasicWriter.create(f)
 
440
    writer.close
 
441
    assert(!f.closed?)
 
442
    f.close
 
443
 
 
444
    f = File.open(@outfile, "w")
 
445
    writer = CSV::BasicWriter.new(f)
 
446
    writer.close_on_terminate
 
447
    writer.close
 
448
    assert(f.closed?)
 
449
  end
 
450
 
 
451
  def test_BasicWriter_s_create_binmode
 
452
    file = File.open(@outfile, "w")     # not "wb"
 
453
    begin
 
454
      writer = CSV::BasicWriter.new(file, ?,, ?\r)
 
455
      writer << ["\r\n", "\r", "\n"]
 
456
      writer << ["1", "2", "3"]
 
457
      writer.close
 
458
    ensure
 
459
      file.close
 
460
    end
 
461
 
 
462
    file = File.open(@outfile, "rb")
 
463
    str = file.read
 
464
    file.close
 
465
    assert_equal("\"\r#{RSEP}\",\"\r\",\"#{RSEP}\"\r1,2,3\r", str)
 
466
  end
 
467
 
 
468
  #### CSV unit test
 
469
 
 
470
  def test_s_open_reader
 
471
    assert_raises(ArgumentError, 'Illegal mode') do
 
472
      CSV.open("temp", "a")
 
473
    end
 
474
 
 
475
    assert_raises(ArgumentError, 'Illegal mode') do
 
476
      CSV.open("temp", "a", ?;)
 
477
    end
 
478
 
 
479
    reader = CSV.open(@infile, "r")
 
480
    assert_instance_of(CSV::IOReader, reader)
 
481
    reader.close
 
482
 
 
483
    reader = CSV.open(@infile, "rb")
 
484
    assert_instance_of(CSV::IOReader, reader)
 
485
    reader.close
 
486
 
 
487
    reader = CSV.open(@infile, "r", ?;)
 
488
    assert_instance_of(CSV::IOReader, reader)
 
489
    reader.close
 
490
 
 
491
    CSV.open(@infile, "r") do |row|
 
492
      assert_instance_of(Array, row)
 
493
      break
 
494
    end
 
495
 
 
496
    CSV.open(@infiletsv, "r", ?\t) do |row|
 
497
      assert_instance_of(Array, row)
 
498
      break
 
499
    end
 
500
 
 
501
    assert_raises(Errno::ENOENT) do
 
502
      CSV.open("NoSuchFileOrDirectory", "r")
 
503
    end
 
504
 
 
505
    assert_raises(Errno::ENOENT) do
 
506
      CSV.open("NoSuchFileOrDirectory", "r", ?;)
 
507
    end
 
508
 
 
509
    # Illegal format.
 
510
    File.open(@outfile, "wb") do |f|
 
511
      f << "a,b\r\na,b,\"c\"\ra"
 
512
    end
 
513
    assert_raises(CSV::IllegalFormatError) do
 
514
      CSV.open(@outfile, "r") do |row|
 
515
      end
 
516
    end
 
517
 
 
518
    File.open(@outfile, "wb") do |f|
 
519
      f << "a,b\r\na,b\""
 
520
    end
 
521
    assert_raises(CSV::IllegalFormatError) do
 
522
      CSV.open(@outfile, "r") do |row|
 
523
      end
 
524
    end
 
525
 
 
526
    CSV.open(@emptyfile, "r") do |row|
 
527
      assert_fail("Must not reach here")
 
528
    end
 
529
  end
 
530
 
 
531
  def test_s_parse
 
532
    result = CSV.parse(File.read(@infile))
 
533
    assert_instance_of(Array, result)
 
534
    assert_instance_of(Array, result[0])
 
535
 
 
536
    result = CSV.parse(File.read(@infile))
 
537
    assert_instance_of(Array, result)
 
538
    assert_instance_of(Array, result[0])
 
539
 
 
540
    assert_equal([], CSV.parse(""))
 
541
    assert_equal([[nil]], CSV.parse("\n"))
 
542
 
 
543
    CSV.parse(File.read(@infile)) do |row|
 
544
      assert_instance_of(Array, row)
 
545
      break
 
546
    end
 
547
 
 
548
    CSV.parse(File.read(@infiletsv), ?\t) do |row|
 
549
      assert_instance_of(Array, row)
 
550
      break
 
551
    end
 
552
 
 
553
    CSV.parse("") do |row|
 
554
      assert(false)
 
555
    end
 
556
 
 
557
    count = 0
 
558
    CSV.parse("\n") do |row|
 
559
      assert_equal([nil], row)
 
560
      count += 1
 
561
    end
 
562
    assert_equal(1, count)
 
563
 
 
564
    assert_equal([["a|b-c|d"]], CSV.parse("a|b-c|d"))
 
565
    assert_equal([["a", "b"], ["c", "d"]], CSV.parse("a|b-c|d", "|", "-"))
 
566
  end
 
567
 
 
568
  def test_s_open_writer
 
569
    writer = CSV.open(@outfile, "w")
 
570
    assert_instance_of(CSV::BasicWriter, writer)
 
571
    writer.close
 
572
 
 
573
    writer = CSV.open(@outfile, "wb")
 
574
    assert_instance_of(CSV::BasicWriter, writer)
 
575
    writer.close
 
576
 
 
577
    writer = CSV.open(@outfile, "wb", ?;)
 
578
    assert_instance_of(CSV::BasicWriter, writer)
 
579
    writer.close
 
580
 
 
581
    CSV.open(@outfile, "w") do |writer|
 
582
      assert_instance_of(CSV::BasicWriter, writer)
 
583
    end
 
584
 
 
585
    CSV.open(@outfile, "w", ?;) do |writer|
 
586
      assert_instance_of(CSV::BasicWriter, writer)
 
587
    end
 
588
 
 
589
    begin
 
590
      CSV.open(@tmpdir, "w")
 
591
      assert(false)
 
592
    rescue Exception => ex
 
593
      assert(ex.is_a?(Errno::EEXIST) || ex.is_a?(Errno::EISDIR) || ex.is_a?(Errno::EACCES))
 
594
    end
 
595
  end
 
596
 
 
597
  def test_s_generate
 
598
    writer = CSV.generate(@outfile)
 
599
    assert_instance_of(CSV::BasicWriter, writer)
 
600
    writer.close
 
601
 
 
602
    writer = CSV.generate(@outfile, ?;)
 
603
    assert_instance_of(CSV::BasicWriter, writer)
 
604
    writer.close
 
605
 
 
606
    CSV.generate(@outfile) do |writer|
 
607
      assert_instance_of(CSV::BasicWriter, writer)
 
608
    end
 
609
 
 
610
    CSV.generate(@outfile, ?;) do |writer|
 
611
      assert_instance_of(CSV::BasicWriter, writer)
 
612
    end
 
613
 
 
614
    begin
 
615
      CSV.generate(@tmpdir)
 
616
      assert(false)
 
617
    rescue Exception => ex
 
618
      assert(ex.is_a?(Errno::EEXIST) || ex.is_a?(Errno::EISDIR) || ex.is_a?(Errno::EACCES))
 
619
    end
 
620
  end
 
621
 
 
622
  def test_s_generate_line
 
623
    str = CSV.generate_line([])
 
624
    assert_equal('', str, "Extra boundary check.")
 
625
 
 
626
    str = CSV.generate_line([], ?;)
 
627
    assert_equal('', str, "Extra boundary check.")
 
628
 
 
629
    @@simpleCSVData.each do |col, str|
 
630
      buf = CSV.generate_line(col)
 
631
      assert_equal(str, buf)
 
632
    end
 
633
 
 
634
    @@simpleCSVData.each do |col, str|
 
635
      buf = CSV.generate_line(col, ?;)
 
636
      assert_equal(str + "\n", ssv2csv(buf))
 
637
    end
 
638
 
 
639
    @@simpleCSVData.each do |col, str|
 
640
      buf = CSV.generate_line(col, ?\t)
 
641
      assert_equal(str + "\n", tsv2csv(buf))
 
642
    end
 
643
 
 
644
    str = CSV.generate_line(['a', 'b'], nil, ?|)
 
645
    assert_equal('a,b', str)
 
646
 
 
647
    str = CSV.generate_line(['a', 'b'], nil, "a")
 
648
    assert_equal('"a",b', str)
 
649
  end
 
650
 
 
651
  def test_s_generate_row
 
652
    buf = ''
 
653
    cols = CSV.generate_row([], 0, buf)
 
654
    assert_equal(0, cols)
 
655
    assert_equal("\n", buf, "Extra boundary check.")
 
656
 
 
657
    buf = ''
 
658
    cols = CSV.generate_row([], 0, buf, ?;)
 
659
    assert_equal(0, cols)
 
660
    assert_equal("\n", buf, "Extra boundary check.")
 
661
 
 
662
    buf = ''
 
663
    cols = CSV.generate_row([], 0, buf, ?\t)
 
664
    assert_equal(0, cols)
 
665
    assert_equal("\n", buf, "Extra boundary check.")
 
666
 
 
667
    buf = ''
 
668
    cols = CSV.generate_row([], 0, buf, ?\t, ?|)
 
669
    assert_equal(0, cols)
 
670
    assert_equal("|", buf, "Extra boundary check.")
 
671
 
 
672
    buf = ''
 
673
    cols = CSV.generate_row([d('1')], 2, buf)
 
674
    assert_equal('1,', buf)
 
675
 
 
676
    buf = ''
 
677
    cols = CSV.generate_row([d('1')], 2, buf, ?;)
 
678
    assert_equal('1;', buf)
 
679
 
 
680
    buf = ''
 
681
    cols = CSV.generate_row([d('1')], 2, buf, ?\t)
 
682
    assert_equal("1\t", buf)
 
683
 
 
684
    buf = ''
 
685
    cols = CSV.generate_row([d('1')], 2, buf, ?\t, ?|)
 
686
    assert_equal("1\t", buf)
 
687
 
 
688
    buf = ''
 
689
    cols = CSV.generate_row([d('1'), d('2')], 1, buf)
 
690
    assert_equal("1\n", buf)
 
691
 
 
692
    buf = ''
 
693
    cols = CSV.generate_row([d('1'), d('2')], 1, buf, ?;)
 
694
    assert_equal("1\n", buf)
 
695
 
 
696
    buf = ''
 
697
    cols = CSV.generate_row([d('1'), d('2')], 1, buf, ?\t)
 
698
    assert_equal("1\n", buf)
 
699
 
 
700
    buf = ''
 
701
    cols = CSV.generate_row([d('1'), d('2')], 1, buf, ?\t, ?\n)
 
702
    assert_equal("1\n", buf)
 
703
 
 
704
    buf = ''
 
705
    cols = CSV.generate_row([d('1'), d('2')], 1, buf, ?\t, ?\r)
 
706
    assert_equal("1\r", buf)
 
707
 
 
708
    buf = ''
 
709
    cols = CSV.generate_row([d('1'), d('2')], 1, buf, ?\t, ?|)
 
710
    assert_equal("1|", buf)
 
711
 
 
712
    @@fullCSVData.each do |col, str|
 
713
      buf = ''
 
714
      cols = CSV.generate_row(col, col.size, buf)
 
715
      assert_equal(col.size, cols)
 
716
      assert_equal(str + "\n", buf)
 
717
    end
 
718
 
 
719
    @@fullCSVData.each do |col, str|
 
720
      buf = ''
 
721
      cols = CSV.generate_row(col, col.size, buf, ?;)
 
722
      assert_equal(col.size, cols)
 
723
      assert_equal(str + "\n", ssv2csv(buf))
 
724
    end
 
725
 
 
726
    @@fullCSVData.each do |col, str|
 
727
      buf = ''
 
728
      cols = CSV.generate_row(col, col.size, buf, ?\t)
 
729
      assert_equal(col.size, cols)
 
730
      assert_equal(str + "\n", tsv2csv(buf))
 
731
    end
 
732
 
 
733
    # row separator
 
734
    @@fullCSVData.each do |col, str|
 
735
      buf = ''
 
736
      cols = CSV.generate_row(col, col.size, buf, ?,, ?|)
 
737
      assert_equal(col.size, cols)
 
738
      assert_equal(str + "|", buf)
 
739
    end
 
740
 
 
741
    # col and row separator
 
742
    @@fullCSVData.each do |col, str|
 
743
      buf = ''
 
744
      cols = CSV.generate_row(col, col.size, buf, ?\t, ?|)
 
745
      assert_equal(col.size, cols)
 
746
      assert_equal(str + "|", tsv2csv(buf, ?|))
 
747
    end
 
748
 
 
749
    buf = ''
 
750
    toBe = ''
 
751
    cols = 0
 
752
    colsToBe = 0
 
753
    @@fullCSVData.each do |col, str|
 
754
      cols += CSV.generate_row(col, col.size, buf)
 
755
      toBe << str << "\n"
 
756
      colsToBe += col.size
 
757
    end
 
758
    assert_equal(colsToBe, cols)
 
759
    assert_equal(toBe, buf)
 
760
 
 
761
    buf = ''
 
762
    toBe = ''
 
763
    cols = 0
 
764
    colsToBe = 0
 
765
    @@fullCSVData.each do |col, str|
 
766
      lineBuf = ''
 
767
      cols += CSV.generate_row(col, col.size, lineBuf, ?;)
 
768
      buf << ssv2csv(lineBuf) << "\n"
 
769
      toBe << ssv2csv(lineBuf) << "\n"
 
770
      colsToBe += col.size
 
771
    end
 
772
    assert_equal(colsToBe, cols)
 
773
    assert_equal(toBe, buf)
 
774
 
 
775
    buf = ''
 
776
    toBe = ''
 
777
    cols = 0
 
778
    colsToBe = 0
 
779
    @@fullCSVData.each do |col, str|
 
780
      lineBuf = ''
 
781
      cols += CSV.generate_row(col, col.size, lineBuf, ?\t)
 
782
      buf << tsv2csv(lineBuf) << "\n"
 
783
      toBe << tsv2csv(lineBuf) << "\n"
 
784
      colsToBe += col.size
 
785
    end
 
786
    assert_equal(colsToBe, cols)
 
787
    assert_equal(toBe, buf)
 
788
 
 
789
    buf = ''
 
790
    toBe = ''
 
791
    cols = 0
 
792
    colsToBe = 0
 
793
    @@fullCSVData.each do |col, str|
 
794
      lineBuf = ''
 
795
      cols += CSV.generate_row(col, col.size, lineBuf, ?|)
 
796
      buf << tsv2csv(lineBuf, ?|)
 
797
      toBe << tsv2csv(lineBuf, ?|)
 
798
      colsToBe += col.size
 
799
    end
 
800
    assert_equal(colsToBe, cols)
 
801
    assert_equal(toBe, buf)
 
802
  end
 
803
 
 
804
  def test_s_parse_line
 
805
    @@simpleCSVData.each do |col, str|
 
806
      row = CSV.parse_line(str)
 
807
      assert_instance_of(Array, row)
 
808
      assert_equal(col.size, row.size)
 
809
      assert_equal(col, row)
 
810
    end
 
811
 
 
812
    @@simpleCSVData.each do |col, str|
 
813
      str = csv2ssv(str)
 
814
      row = CSV.parse_line(str, ?;)
 
815
      assert_instance_of(Array, row)
 
816
      assert_equal(col.size, row.size, str.inspect)
 
817
      assert_equal(col, row, str.inspect)
 
818
    end
 
819
 
 
820
    @@simpleCSVData.each do |col, str|
 
821
      str = csv2tsv(str)
 
822
      row = CSV.parse_line(str, ?\t)
 
823
      assert_instance_of(Array, row)
 
824
      assert_equal(col.size, row.size)
 
825
      assert_equal(col, row)
 
826
    end
 
827
 
 
828
    assert_equal(['a', 'b', 'c'], CSV.parse_line("a,b,c", nil, nil))
 
829
    assert_equal(['a', nil], CSV.parse_line("a,b,c", nil, ?b))
 
830
    assert_equal(['a', 'b', nil], CSV.parse_line("a,b,c", nil, "c"))
 
831
    assert_equal([nil], CSV.parse_line(""))
 
832
    assert_equal([nil], CSV.parse_line("\n"))
 
833
    assert_equal([""], CSV.parse_line("\"\"\n"))
 
834
    
 
835
    # Illegal format.
 
836
    buf = []
 
837
    row = CSV.parse_line("a,b,\"c\"\ra")
 
838
    assert_instance_of(Array, row)
 
839
    assert_equal(0, row.size)
 
840
 
 
841
    buf = Array.new
 
842
    row = CSV.parse_line("a;b;\"c\"\ra", ?;)
 
843
    assert_instance_of(Array, row)
 
844
    assert_equal(0, row.size)
 
845
 
 
846
    buf = Array.new
 
847
    row = CSV.parse_line("a\tb\t\"c\"\ra", ?\t)
 
848
    assert_instance_of(Array, row)
 
849
    assert_equal(0, row.size)
 
850
 
 
851
    row = CSV.parse_line("a,b\"")
 
852
    assert_instance_of(Array, row)
 
853
    assert_equal(0, row.size)
 
854
 
 
855
    row = CSV.parse_line("a;b\"", ?;)
 
856
    assert_instance_of(Array, row)
 
857
    assert_equal(0, row.size)
 
858
 
 
859
    row = CSV.parse_line("a\tb\"", ?\t)
 
860
    assert_instance_of(Array, row)
 
861
    assert_equal(0, row.size)
 
862
 
 
863
    row = CSV.parse_line("\"a,b\"\r,")
 
864
    assert_instance_of(Array, row)
 
865
    assert_equal(0, row.size)
 
866
 
 
867
    row = CSV.parse_line("\"a;b\"\r;", ?;)
 
868
    assert_instance_of(Array, row)
 
869
    assert_equal(0, row.size)
 
870
 
 
871
    row = CSV.parse_line("\"a\tb\"\r\t", ?\t)
 
872
    assert_instance_of(Array, row)
 
873
    assert_equal(0, row.size)
 
874
 
 
875
    row = CSV.parse_line("\"a,b\"\r\"")
 
876
    assert_instance_of(Array, row)
 
877
    assert_equal(0, row.size)
 
878
 
 
879
    row = CSV.parse_line("\"a;b\"\r\"", ?;)
 
880
    assert_instance_of(Array, row)
 
881
    assert_equal(0, row.size)
 
882
 
 
883
    row = CSV.parse_line("\"a\tb\"\r\"", ?\t)
 
884
    assert_instance_of(Array, row)
 
885
    assert_equal(0, row.size)
 
886
  end
 
887
 
 
888
  def test_s_parse_row
 
889
    @@fullCSVData.each do |col, str|
 
890
      buf = Array.new
 
891
      cols, idx = CSV.parse_row(str + "\r\n", 0, buf)
 
892
      assert_equal(cols, buf.size, "Reported size.")
 
893
      assert_equal(col.size, buf.size, "Size.")
 
894
      assert_equal(col, buf, str.inspect)
 
895
 
 
896
      buf = Array.new
 
897
      cols, idx = CSV.parse_row(str + "\n", 0, buf, ?,, ?\n)
 
898
      assert_equal(cols, buf.size, "Reported size.")
 
899
      assert_equal(col.size, buf.size, "Size.")
 
900
      assert_equal(col, buf, str.inspect)
 
901
 
 
902
      # separator: |
 
903
      buf = Array.new
 
904
      cols, idx = CSV.parse_row(str + "|", 0, buf, ?,)
 
905
      assert_not_equal(col, buf)
 
906
      buf = Array.new
 
907
      cols, idx = CSV.parse_row(str + "|", 0, buf, ?,, ?|)
 
908
      assert_equal(cols, buf.size, "Reported size.")
 
909
      assert_equal(col.size, buf.size, "Size.")
 
910
      assert_equal(col, buf, str.inspect)
 
911
    end
 
912
 
 
913
    @@fullCSVData.each do |col, str|
 
914
      str = csv2ssv(str)
 
915
      buf = Array.new
 
916
      cols, idx = CSV.parse_row(str + "\r\n", 0, buf, ?;)
 
917
      assert_equal(cols, buf.size, "Reported size.")
 
918
      assert_equal(col.size, buf.size, "Size.")
 
919
      assert_equal(col, buf, str)
 
920
    end
 
921
 
 
922
    @@fullCSVData.each do |col, str|
 
923
      str = csv2tsv(str)
 
924
      buf = Array.new
 
925
      cols, idx = CSV.parse_row(str + "\r\n", 0, buf, ?\t)
 
926
      assert_equal(cols, buf.size, "Reported size.")
 
927
      assert_equal(col.size, buf.size, "Size.")
 
928
      assert_equal(col, buf, str)
 
929
    end
 
930
 
 
931
    @@fullCSVData.each do |col, str|
 
932
      str = csv2tsv(str, ?|)
 
933
      buf = Array.new
 
934
      cols, idx = CSV.parse_row(str + "|", 0, buf, ?\t, ?|)
 
935
      assert_equal(cols, buf.size, "Reported size.")
 
936
      assert_equal(col.size, buf.size, "Size.")
 
937
      assert_equal(col, buf, str)
 
938
    end
 
939
 
 
940
    buf = []
 
941
    CSV.parse_row("a,b,c", 0, buf, nil, nil)
 
942
    assert_equal(['a', 'b', 'c'], buf)
 
943
 
 
944
    buf = []
 
945
    CSV.parse_row("a,b,c", 0, buf, nil, ?b)
 
946
    assert_equal(['a', nil], buf)
 
947
 
 
948
    buf = []
 
949
    CSV.parse_row("a,b,c", 0, buf, nil, "c")
 
950
    assert_equal(['a', 'b', nil], buf)
 
951
 
 
952
    buf = Array.new
 
953
    cols, idx = CSV.parse_row("a,b,\"c\r\"", 0, buf)
 
954
    assert_equal(["a", "b", "c\r"], buf.to_a)
 
955
 
 
956
    buf = Array.new
 
957
    cols, idx = CSV.parse_row("a;b;\"c\r\"", 0, buf, ?;)
 
958
    assert_equal(["a", "b", "c\r"], buf.to_a)
 
959
 
 
960
    buf = Array.new
 
961
    cols, idx = CSV.parse_row("a\tb\t\"c\r\"", 0, buf, ?\t)
 
962
    assert_equal(["a", "b", "c\r"], buf.to_a)
 
963
 
 
964
    buf = Array.new
 
965
    cols, idx = CSV.parse_row("a,b,c\n", 0, buf, ?,, ?\n)
 
966
    assert_equal(["a", "b", "c"], buf.to_a)
 
967
 
 
968
    buf = Array.new
 
969
    cols, idx = CSV.parse_row("a\tb\tc\n", 0, buf, ?\t, ?\n)
 
970
    assert_equal(["a", "b", "c"], buf.to_a)
 
971
 
 
972
    # Illegal format.
 
973
    buf = Array.new
 
974
    cols, idx = CSV.parse_row("a,b,c\"", 0, buf)
 
975
    assert_equal(0, cols, "Illegal format; unbalanced double-quote.")
 
976
 
 
977
    buf = Array.new
 
978
    cols, idx = CSV.parse_row("a;b;c\"", 0, buf, ?;)
 
979
    assert_equal(0, cols, "Illegal format; unbalanced double-quote.")
 
980
 
 
981
    buf = Array.new
 
982
    cols, idx = CSV.parse_row("a,b,\"c\"\ra", 0, buf)
 
983
    assert_equal(0, cols)
 
984
    assert_equal(0, idx)
 
985
 
 
986
    buf = Array.new
 
987
    cols, idx = CSV.parse_row("a,b,\"c\"\ra", 0, buf, ?;)
 
988
    assert_equal(0, cols)
 
989
    assert_equal(0, idx)
 
990
 
 
991
    buf = Array.new
 
992
    cols, idx = CSV.parse_row("a,b\"", 0, buf)
 
993
    assert_equal(0, cols)
 
994
    assert_equal(0, idx)
 
995
 
 
996
    buf = Array.new
 
997
    cols, idx = CSV.parse_row("a;b\"", 0, buf, ?;)
 
998
    assert_equal(0, cols)
 
999
    assert_equal(0, idx)
 
1000
 
 
1001
    buf = Array.new
 
1002
    cols, idx = CSV.parse_row("\"a,b\"\r,", 0, buf)
 
1003
    assert_equal(0, cols)
 
1004
    assert_equal(0, idx)
 
1005
 
 
1006
    buf = Array.new
 
1007
    cols, idx = CSV.parse_row("a\r,", 0, buf)
 
1008
    assert_equal(0, cols)
 
1009
    assert_equal(0, idx)
 
1010
 
 
1011
    buf = Array.new
 
1012
    cols, idx = CSV.parse_row("a\r", 0, buf)
 
1013
    assert_equal(0, cols)
 
1014
    assert_equal(0, idx)
 
1015
 
 
1016
    buf = Array.new
 
1017
    cols, idx = CSV.parse_row("a\rbc", 0, buf)
 
1018
    assert_equal(0, cols)
 
1019
    assert_equal(0, idx)
 
1020
 
 
1021
    buf = Array.new
 
1022
    cols, idx = CSV.parse_row("a\r\"\"", 0, buf)
 
1023
    assert_equal(0, cols)
 
1024
    assert_equal(0, idx)
 
1025
 
 
1026
    buf = Array.new
 
1027
    cols, idx = CSV.parse_row("a\r\rabc,", 0, buf)
 
1028
    assert_equal(0, cols)
 
1029
    assert_equal(0, idx)
 
1030
 
 
1031
    buf = Array.new
 
1032
    cols, idx = CSV.parse_row("\"a;b\"\r;", 0, buf, ?;)
 
1033
    assert_equal(0, cols)
 
1034
    assert_equal(0, idx)
 
1035
 
 
1036
    buf = Array.new
 
1037
    cols, idx = CSV.parse_row("\"a,b\"\r\"", 0, buf)
 
1038
    assert_equal(0, cols)
 
1039
    assert_equal(0, idx)
 
1040
 
 
1041
    buf = Array.new
 
1042
    cols, idx = CSV.parse_row("\"a;b\"\r\"", 0, buf, ?;)
 
1043
    assert_equal(0, cols)
 
1044
    assert_equal(0, idx)
 
1045
  end
 
1046
 
 
1047
  def test_s_parse_rowEOF
 
1048
    @@fullCSVData.each do |col, str|
 
1049
      if str == ''
 
1050
        # String "" is not allowed.
 
1051
        next
 
1052
      end
 
1053
      buf = Array.new
 
1054
      cols, idx = CSV.parse_row(str, 0, buf)
 
1055
      assert_equal(col.size, cols, "Reported size.")
 
1056
      assert_equal(col.size, buf.size, "Size.")
 
1057
      assert_equal(col, buf)
 
1058
    end
 
1059
  end
 
1060
 
 
1061
  def test_s_parse_rowConcat
 
1062
    buf = ''
 
1063
    toBe = []
 
1064
    @@fullCSVData.each do |col, str|
 
1065
      buf  << str << "\r\n"
 
1066
      toBe.concat(col)
 
1067
    end
 
1068
    idx = 0
 
1069
    cols = 0
 
1070
    parsed = Array.new
 
1071
    parsedCols = 0
 
1072
    begin
 
1073
      cols, idx = CSV.parse_row(buf, idx, parsed)
 
1074
      parsedCols += cols
 
1075
    end while cols > 0
 
1076
    assert_equal(toBe.size, parsedCols)
 
1077
    assert_equal(toBe.size, parsed.size)
 
1078
    assert_equal(toBe, parsed)
 
1079
 
 
1080
    buf = ''
 
1081
    toBe = []
 
1082
    @@fullCSVData.each do |col, str|
 
1083
      buf  << str << "\n"
 
1084
      toBe.concat(col)
 
1085
    end
 
1086
    idx = 0
 
1087
    cols = 0
 
1088
    parsed = Array.new
 
1089
    parsedCols = 0
 
1090
    begin
 
1091
      cols, idx = CSV.parse_row(buf, idx, parsed, ?,, ?\n)
 
1092
      parsedCols += cols
 
1093
    end while cols > 0
 
1094
    assert_equal(toBe.size, parsedCols)
 
1095
    assert_equal(toBe.size, parsed.size)
 
1096
    assert_equal(toBe, parsed)
 
1097
 
 
1098
    buf = ''
 
1099
    toBe = []
 
1100
    @@fullCSVData.sort { |a, b|
 
1101
      a[0].length <=> b[0].length
 
1102
    }.each do |col, str|
 
1103
      buf  << str << "\n"
 
1104
      toBe.concat(col)
 
1105
    end
 
1106
    idx = 0
 
1107
    cols = 0
 
1108
    parsed = Array.new
 
1109
    parsedCols = 0
 
1110
    begin
 
1111
      cols, idx = CSV.parse_row(buf, idx, parsed, ?,, ?\n)
 
1112
      parsedCols += cols
 
1113
    end while cols > 0
 
1114
    assert_equal(toBe.size, parsedCols)
 
1115
    assert_equal(toBe.size, parsed.size)
 
1116
    assert_equal(toBe, parsed)
 
1117
 
 
1118
    buf = ''
 
1119
    toBe = []
 
1120
    @@fullCSVData.each do |col, str|
 
1121
      buf  << str << "|"
 
1122
      toBe.concat(col)
 
1123
    end
 
1124
    idx = 0
 
1125
    cols = 0
 
1126
    parsed = []
 
1127
    parsedCols = 0
 
1128
    begin
 
1129
      cols, idx = CSV.parse_row(buf, idx, parsed, ?,, ?|)
 
1130
      parsedCols += cols
 
1131
    end while cols > 0
 
1132
    assert_equal(toBe.size, parsedCols)
 
1133
    assert_equal(toBe.size, parsed.size)
 
1134
    assert_equal(toBe, parsed)
 
1135
  end
 
1136
 
 
1137
  def test_utf8
 
1138
    rows = []
 
1139
    CSV.open(@bomfile, "r") do |row|
 
1140
      rows << row.to_a
 
1141
    end
 
1142
    assert_equal([["foo"], ["bar"]], rows)
 
1143
 
 
1144
    rows = []
 
1145
    file = File.open(@bomfile)
 
1146
    CSV::Reader.parse(file) do |row|
 
1147
      rows << row.to_a
 
1148
    end
 
1149
    assert_equal([["foo"], ["bar"]], rows)
 
1150
    file.close
 
1151
  end
 
1152
 
 
1153
  def test_macCR
 
1154
    rows = []
 
1155
    CSV.open(@macfile, "r", ?,, ?\r) do |row|
 
1156
      rows << row.to_a
 
1157
    end
 
1158
    assert_equal([["Avenches", "aus Umgebung"], ["Bad Hersfeld", "Ausgrabung"]], rows)
 
1159
 
 
1160
    rows = []
 
1161
    assert_raises(CSV::IllegalFormatError) do
 
1162
      CSV.open(@macfile, "r") do |row|
 
1163
        rows << row.to_a
 
1164
      end
 
1165
      assert_equal([["Avenches", "aus Umgebung\r\"Bad Hersfeld", "Ausgrabung"]], rows)
 
1166
    end
 
1167
 
 
1168
    rows = []
 
1169
    file = File.open(@macfile)
 
1170
    begin
 
1171
      CSV::Reader.parse(file, ?,, ?\r) do |row|
 
1172
        rows << row.to_a
 
1173
      end
 
1174
      assert_equal([["Avenches", "aus Umgebung"], ["Bad Hersfeld", "Ausgrabung"]], rows)
 
1175
    ensure
 
1176
      file.close
 
1177
    end
 
1178
 
 
1179
    rows = []
 
1180
    file = File.open(@macfile)
 
1181
    begin
 
1182
      assert_raises(CSV::IllegalFormatError) do
 
1183
        CSV::Reader.parse(file, ?,) do |row|
 
1184
          rows << row.to_a
 
1185
        end
 
1186
        assert_equal([["Avenches", "aus Umgebung\r\"Bad Hersfeld", "Ausgrabung"]], rows)
 
1187
      end
 
1188
    ensure
 
1189
      file.close
 
1190
    end
 
1191
  end
 
1192
 
 
1193
 
 
1194
  #### CSV unit test
 
1195
 
 
1196
  InputStreamPattern = '0123456789'
 
1197
  InputStreamPatternSize = InputStreamPattern.size
 
1198
  def expChar(idx)
 
1199
    InputStreamPattern[idx % InputStreamPatternSize]
 
1200
  end
 
1201
 
 
1202
  def expStr(idx, n)
 
1203
    if n > InputStreamPatternSize
 
1204
      InputStreamPattern + expStr(0, n - InputStreamPatternSize)
 
1205
    else
 
1206
      InputStreamPattern[idx % InputStreamPatternSize, n]
 
1207
    end
 
1208
  end
 
1209
 
 
1210
  def setupInputStream(size, bufSize = nil)
 
1211
    setBufSize(bufSize) if bufSize
 
1212
    m = ((size / InputStreamPatternSize) + 1).to_i
 
1213
    File.open(@outfile, "wb") do |f|
 
1214
      f << (InputStreamPattern * m)[0, size]
 
1215
    end
 
1216
    file = File.open(@outfile, "rb")
 
1217
    buf = CSV::IOBuf.new(file)
 
1218
    if block_given?
 
1219
      yield(buf)
 
1220
      file.close
 
1221
      nil
 
1222
    else
 
1223
      buf
 
1224
    end
 
1225
  end
 
1226
 
 
1227
  def setBufSize(size)
 
1228
    CSV::StreamBuf.module_eval('remove_const("BufSize")')
 
1229
    CSV::StreamBuf.module_eval("BufSize = #{ size }")
 
1230
  end
 
1231
 
 
1232
  class StrBuf < CSV::StreamBuf
 
1233
  private
 
1234
    def initialize(string)
 
1235
      @str = string
 
1236
      @idx = 0
 
1237
      super()
 
1238
    end
 
1239
 
 
1240
    def read(size)
 
1241
      str = @str[@idx, size]
 
1242
      if str.empty?
 
1243
        nil
 
1244
      else
 
1245
        @idx += str.size
 
1246
        str
 
1247
      end
 
1248
    end
 
1249
  end
 
1250
 
 
1251
  class ErrBuf < CSV::StreamBuf
 
1252
    class Error < RuntimeError; end
 
1253
  private
 
1254
    def initialize
 
1255
      @first = true
 
1256
      super()
 
1257
    end
 
1258
 
 
1259
    def read(size)
 
1260
      if @first
 
1261
        @first = false
 
1262
        "a" * size
 
1263
      else
 
1264
        raise ErrBuf::Error.new
 
1265
      end
 
1266
    end
 
1267
  end
 
1268
 
 
1269
  def test_StreamBuf_MyBuf
 
1270
    # At first, check ruby's behaviour.
 
1271
    s = "abc"
 
1272
    assert_equal(?a, s[0])
 
1273
    assert_equal(?b, s[1])
 
1274
    assert_equal(?c, s[2])
 
1275
    assert_equal(nil, s[3])
 
1276
    assert_equal("a", s[0, 1])
 
1277
    assert_equal("b", s[1, 1])
 
1278
    assert_equal("c", s[2, 1])
 
1279
    assert_equal("", s[3, 1])
 
1280
    assert_equal(nil, s[4, 1])
 
1281
 
 
1282
    s = StrBuf.new("abc")
 
1283
    assert_equal(?a, s[0])
 
1284
    assert_equal(?b, s.get(1))
 
1285
    assert_equal(?c, s[2])
 
1286
    assert_equal(nil, s.get(3))
 
1287
    assert_equal("a", s[0, 1])
 
1288
    assert_equal("b", s.get(1, 1))
 
1289
    assert_equal("c", s[2, 1])
 
1290
    assert_equal("", s.get(3, 1))
 
1291
    assert_equal(nil, s[4, 1])
 
1292
 
 
1293
    dropped = s.drop(1)
 
1294
    assert_equal(1, dropped)
 
1295
    assert_equal(?b, s[0])
 
1296
    assert(!s.is_eos?)
 
1297
    dropped = s.drop(1)
 
1298
    assert_equal(1, dropped)
 
1299
    assert_equal(?c, s[0])
 
1300
    assert(!s.is_eos?)
 
1301
    dropped = s.drop(1)
 
1302
    assert_equal(1, dropped)
 
1303
    assert_equal(nil, s[0])
 
1304
    assert(s.is_eos?)
 
1305
    dropped = s.drop(1)
 
1306
    assert_equal(0, dropped)
 
1307
    assert_equal(nil, s[0])
 
1308
    assert(s.is_eos?)
 
1309
 
 
1310
    s = StrBuf.new("")
 
1311
    assert_equal(nil, s[0])
 
1312
 
 
1313
    s = StrBuf.new("")
 
1314
    dropped = s.drop(1)
 
1315
    assert_equal(0, dropped)
 
1316
 
 
1317
    assert_raises(TestCSV::ErrBuf::Error) do
 
1318
      s = ErrBuf.new
 
1319
      s[1024]
 
1320
    end
 
1321
 
 
1322
    assert_raises(TestCSV::ErrBuf::Error) do
 
1323
      s = ErrBuf.new
 
1324
      s.drop(1024)
 
1325
    end
 
1326
  end
 
1327
 
 
1328
  def test_StreamBuf_AREF # '[idx]'
 
1329
    setupInputStream(22, 1024) do |s|
 
1330
      [0, 1, 9, 10, 19, 20, 21].each do |idx|
 
1331
        assert_equal(expChar(idx), s[idx], idx.to_s)
 
1332
      end
 
1333
      [22, 23].each do |idx|
 
1334
        assert_equal(nil, s[idx], idx.to_s)
 
1335
      end
 
1336
      assert_equal(nil, s[-1])
 
1337
    end
 
1338
 
 
1339
    setupInputStream(22, 1) do |s|
 
1340
      [0, 1, 9, 10, 19, 20, 21].each do |idx|
 
1341
        assert_equal(expChar(idx), s[idx], idx.to_s)
 
1342
      end
 
1343
      [22, 23].each do |idx|
 
1344
        assert_equal(nil, s[idx], idx.to_s)
 
1345
      end
 
1346
    end
 
1347
 
 
1348
    setupInputStream(1024, 1) do |s|
 
1349
      [1023, 0].each do |idx|
 
1350
        assert_equal(expChar(idx), s[idx], idx.to_s)
 
1351
      end
 
1352
      [1024, 1025].each do |idx|
 
1353
        assert_equal(nil, s[idx], idx.to_s)
 
1354
      end
 
1355
    end
 
1356
 
 
1357
    setupInputStream(1, 1) do |s|
 
1358
      [0].each do |idx|
 
1359
        assert_equal(expChar(idx), s[idx], idx.to_s)
 
1360
      end
 
1361
      [1, 2].each do |idx|
 
1362
        assert_equal(nil, s[idx], idx.to_s)
 
1363
      end
 
1364
    end
 
1365
  end
 
1366
 
 
1367
  def test_StreamBuf_AREF_n # '[idx, n]'
 
1368
    # At first, check ruby's behaviour.
 
1369
    assert_equal("", "abc"[3, 1])
 
1370
    assert_equal(nil, "abc"[4, 1])
 
1371
    
 
1372
    setupInputStream(22, 1024) do |s|
 
1373
      [0, 1, 9, 10, 19, 20, 21].each do |idx|
 
1374
        assert_equal(expStr(idx, 1), s[idx, 1], idx.to_s)
 
1375
      end
 
1376
      assert_equal("", s[22, 1])
 
1377
      assert_equal(nil, s[23, 1])
 
1378
    end
 
1379
 
 
1380
    setupInputStream(22, 1) do |s|
 
1381
      [0, 1, 9, 10, 19, 20, 21].each do |idx|
 
1382
        assert_equal(expStr(idx, 1), s[idx, 1], idx.to_s)
 
1383
      end
 
1384
      assert_equal("", s[22, 1])
 
1385
      assert_equal(nil, s[23, 1])
 
1386
    end
 
1387
 
 
1388
    setupInputStream(1024, 1) do |s|
 
1389
      [1023, 0].each do |idx|
 
1390
        assert_equal(expStr(idx, 1), s[idx, 1], idx.to_s)
 
1391
      end
 
1392
      assert_equal("", s[1024, 1])
 
1393
      assert_equal(nil, s[1025, 1])
 
1394
    end
 
1395
 
 
1396
    setupInputStream(1, 1) do |s|
 
1397
      [0].each do |idx|
 
1398
        assert_equal(expStr(idx, 1), s[idx, 1], idx.to_s)
 
1399
      end
 
1400
      assert_equal("", s[1, 1])
 
1401
      assert_equal(nil, s[2, 1])
 
1402
    end
 
1403
 
 
1404
    setupInputStream(22, 11) do |s|
 
1405
      [0, 1, 10, 11, 20].each do  |idx|
 
1406
        assert_equal(expStr(idx, 2), s[idx, 2], idx.to_s)
 
1407
      end
 
1408
      assert_equal(expStr(21, 1), s[21, 2])
 
1409
 
 
1410
      assert_equal(expStr(0, 12), s[0, 12])
 
1411
      assert_equal(expStr(10, 12), s[10, 12])
 
1412
      assert_equal(expStr(10, 12), s[10, 13])
 
1413
      assert_equal(expStr(10, 12), s[10, 14])
 
1414
      assert_equal(expStr(10, 12), s[10, 1024])
 
1415
 
 
1416
      assert_equal(nil, s[0, -1])
 
1417
      assert_equal(nil, s[21, -1])
 
1418
 
 
1419
      assert_equal(nil, s[-1, 10])
 
1420
      assert_equal(nil, s[-1, -1])
 
1421
    end
 
1422
  end
 
1423
 
 
1424
  def test_StreamBuf_get
 
1425
    setupInputStream(22, 1024) do |s|
 
1426
      [0, 1, 9, 10, 19, 20, 21].each do |idx|
 
1427
        assert_equal(expChar(idx), s.get(idx), idx.to_s)
 
1428
      end
 
1429
      [22, 23].each do |idx|
 
1430
        assert_equal(nil, s.get(idx), idx.to_s)
 
1431
      end
 
1432
      assert_equal(nil, s.get(-1))
 
1433
    end
 
1434
  end
 
1435
  
 
1436
  def test_StreamBuf_get_n
 
1437
    setupInputStream(22, 1024) do |s|
 
1438
      [0, 1, 9, 10, 19, 20, 21].each do |idx|
 
1439
        assert_equal(expStr(idx, 1), s.get(idx, 1), idx.to_s)
 
1440
      end
 
1441
      assert_equal("", s.get(22, 1))
 
1442
      assert_equal(nil, s.get(23, 1))
 
1443
 
 
1444
      assert_equal(nil, s.get(-1, 1))
 
1445
      assert_equal(nil, s.get(-1, -1))
 
1446
    end
 
1447
  end
 
1448
 
 
1449
  def test_StreamBuf_drop
 
1450
    setupInputStream(22, 1024) do |s|
 
1451
      assert_equal(expChar(0), s[0])
 
1452
      assert_equal(expChar(21), s[21])
 
1453
      assert_equal(nil, s[22])
 
1454
 
 
1455
      dropped = s.drop(-1)
 
1456
      assert_equal(0, dropped)
 
1457
      assert_equal(expChar(0), s[0])
 
1458
 
 
1459
      dropped = s.drop(0)
 
1460
      assert_equal(0, dropped)
 
1461
      assert_equal(expChar(0), s[0])
 
1462
 
 
1463
      dropped = s.drop(1)
 
1464
      assert_equal(1, dropped)
 
1465
      assert_equal(expChar(1), s[0])
 
1466
      assert_equal(expChar(2), s[1])
 
1467
 
 
1468
      dropped = s.drop(1)
 
1469
      assert_equal(1, dropped)
 
1470
      assert_equal(expChar(2), s[0])
 
1471
      assert_equal(expChar(3), s[1])
 
1472
    end
 
1473
 
 
1474
    setupInputStream(4, 2) do |s|
 
1475
      dropped = s.drop(2)
 
1476
      assert_equal(2, dropped)
 
1477
      assert_equal(expChar(2), s[0])
 
1478
      assert_equal(expChar(3), s[1])
 
1479
      dropped = s.drop(1)
 
1480
      assert_equal(1, dropped)
 
1481
      assert_equal(expChar(3), s[0])
 
1482
      assert_equal(nil, s[1])
 
1483
      dropped = s.drop(1)
 
1484
      assert_equal(1, dropped)
 
1485
      assert_equal(nil, s[0])
 
1486
      assert_equal(nil, s[1])
 
1487
      dropped = s.drop(0)
 
1488
      assert_equal(0, dropped)
 
1489
      assert_equal(nil, s[0])
 
1490
      assert_equal(nil, s[1])
 
1491
    end
 
1492
 
 
1493
    setupInputStream(6, 3) do |s|
 
1494
      dropped = s.drop(2)
 
1495
      assert_equal(2, dropped)
 
1496
      dropped = s.drop(2)
 
1497
      assert_equal(2, dropped)
 
1498
      assert_equal(expChar(4), s[0])
 
1499
      assert_equal(expChar(5), s[1])
 
1500
      dropped = s.drop(3)
 
1501
      assert_equal(2, dropped)
 
1502
      assert_equal(nil, s[0])
 
1503
      assert_equal(nil, s[1])
 
1504
    end
 
1505
  end
 
1506
 
 
1507
  def test_StreamBuf_is_eos?
 
1508
    setupInputStream(3, 1024) do |s|
 
1509
      assert(!s.is_eos?)
 
1510
      s.drop(1)
 
1511
      assert(!s.is_eos?)
 
1512
      s.drop(1)
 
1513
      assert(!s.is_eos?)
 
1514
      s.drop(1)
 
1515
      assert(s.is_eos?)
 
1516
      s.drop(1)
 
1517
      assert(s.is_eos?)
 
1518
    end
 
1519
 
 
1520
    setupInputStream(3, 2) do |s|
 
1521
      assert(!s.is_eos?)
 
1522
      s.drop(1)
 
1523
      assert(!s.is_eos?)
 
1524
      s.drop(1)
 
1525
      assert(!s.is_eos?)
 
1526
      s.drop(1)
 
1527
      assert(s.is_eos?)
 
1528
      s.drop(1)
 
1529
      assert(s.is_eos?)
 
1530
    end
 
1531
  end
 
1532
 
 
1533
  def test_StreamBuf_s_new
 
1534
    # NotImplementedError should be raised from StreamBuf#read.
 
1535
    assert_raises(NotImplementedError) do
 
1536
      CSV::StreamBuf.new
 
1537
    end
 
1538
  end
 
1539
 
 
1540
  def test_IOBuf_close
 
1541
    f = File.open(@outfile, "wb")
 
1542
    f << "tst"
 
1543
    f.close
 
1544
 
 
1545
    f = File.open(@outfile, "rb")
 
1546
    iobuf = CSV::IOBuf.new(f)
 
1547
    iobuf.close
 
1548
    assert(true)        # iobuf.close does not raise any exception.
 
1549
    f.close
 
1550
  end
 
1551
 
 
1552
  def test_IOBuf_s_new
 
1553
    iobuf = CSV::IOBuf.new(Tempfile.new("in.csv"))
 
1554
    assert_instance_of(CSV::IOBuf, iobuf)
 
1555
  end
 
1556
 
 
1557
 
 
1558
  #### CSV functional test
 
1559
 
 
1560
  # sample data
 
1561
  #
 
1562
  #  1      2       3         4       5        6      7    8
 
1563
  # +------+-------+---------+-------+--------+------+----+------+
 
1564
  # | foo  | "foo" | foo,bar | ""    |(empty) |(null)| \r | \r\n |
 
1565
  # +------+-------+---------+-------+--------+------+----+------+
 
1566
  # | NaHi | "Na"  | Na,Hi   | \r.\n | \r\n\n | "    | \n | \r\n |
 
1567
  # +------+-------+---------+-------+--------+------+----+------+
 
1568
  #
 
1569
  def test_s_parseAndCreate
 
1570
    colSize = 8
 
1571
    csvStr = "foo,!!!foo!!!,!foo,bar!,!!!!!!,!!,,!\r!,!\r\n!\nNaHi,!!!Na!!!,!Na,Hi!,!\r.\n!,!\r\n\n!,!!!!,!\n!,!\r\n!".gsub!('!', '"')
 
1572
    csvStrTerminated = csvStr + "\n"
 
1573
 
 
1574
    myStr = csvStr.dup
 
1575
    res1 = []; res2 = []
 
1576
    idx = 0
 
1577
    col, idx = CSV::parse_row(myStr, 0, res1)
 
1578
    col, idx = CSV::parse_row(myStr, idx, res2)
 
1579
 
 
1580
    buf = ''
 
1581
    col = CSV::generate_row(res1, colSize, buf)
 
1582
    col = CSV::generate_row(res2, colSize, buf)
 
1583
    assert_equal(csvStrTerminated, buf)
 
1584
 
 
1585
    parsed = []
 
1586
    CSV::Reader.parse(csvStrTerminated) do |row|
 
1587
      parsed << row
 
1588
    end
 
1589
 
 
1590
    buf = ''
 
1591
    CSV::Writer.generate(buf) do |writer|
 
1592
      parsed.each do |row|
 
1593
        writer.add_row(row)
 
1594
      end
 
1595
    end
 
1596
    assert_equal(csvStrTerminated, buf)
 
1597
 
 
1598
    buf = ''
 
1599
    CSV::Writer.generate(buf) do |writer|
 
1600
      parsed.each do |row|
 
1601
        writer << row
 
1602
      end
 
1603
    end
 
1604
    assert_equal(csvStrTerminated, buf)
 
1605
  end
 
1606
 
 
1607
  def test_writer_fs_rs_generate
 
1608
    buf = ''
 
1609
    CSV::Writer.generate(buf, ",,") do |writer|
 
1610
      writer << []
 
1611
    end
 
1612
    assert_equal("\n", buf)
 
1613
 
 
1614
    buf = ''
 
1615
    CSV::Writer.generate(buf, ",,") do |writer|
 
1616
      writer << [] << []
 
1617
    end
 
1618
    assert_equal("\n\n", buf)
 
1619
 
 
1620
    buf = ''
 
1621
    CSV::Writer.generate(buf, ",,") do |writer|
 
1622
      writer << [1]
 
1623
    end
 
1624
    assert_equal("1\n", buf)
 
1625
 
 
1626
    buf = ''
 
1627
    CSV::Writer.generate(buf, ",,") do |writer|
 
1628
      writer << [1, 2, 3]
 
1629
      writer << [4, ",,", 5]
 
1630
    end
 
1631
    assert_equal("1,,2,,3\n4,,\",,\",,5\n", buf)
 
1632
 
 
1633
    buf = ''
 
1634
    CSV::Writer.generate(buf, ",,:", ",,;") do |writer|
 
1635
      writer << [nil, nil, nil]
 
1636
      writer << [nil, ",,", nil]
 
1637
    end
 
1638
    assert_equal(",,:,,:,,;,,:,,,,:,,;", buf)
 
1639
 
 
1640
    buf = ''
 
1641
    CSV::Writer.generate(buf, "---") do |writer|
 
1642
      writer << [1, 2, 3]
 
1643
      writer << [4, "---\"---", 5]
 
1644
    end
 
1645
    assert_equal("1---2---3\n4---\"---\"\"---\"---5\n", buf)
 
1646
 
 
1647
    buf = ''
 
1648
    CSV::Writer.generate(buf, nil) do |writer|
 
1649
      writer << [1, 2, 3]
 
1650
      writer << [4, ",\",", 5]
 
1651
    end
 
1652
    assert_equal("1,2,3\n4,\",\"\",\",5\n", buf)
 
1653
  end
 
1654
 
 
1655
  def test_writer_fs_rs_parse
 
1656
    reader = CSV::Reader.create('a||b--c||d', '||', '--')
 
1657
    assert_equal(['a', 'b'], reader.shift)
 
1658
    assert_equal(['c', 'd'], reader.shift)
 
1659
 
 
1660
    reader = CSV::Reader.create("a@|b@-c@|d", "@|", "@-")
 
1661
    assert_equal(['a', 'b'], reader.shift)
 
1662
    assert_equal(['c', 'd'], reader.shift)
 
1663
 
 
1664
    reader = CSV::Reader.create("ababfsababrs", "abfs", "abrs")
 
1665
    assert_equal(['ab', 'ab'], reader.shift)
 
1666
 
 
1667
    reader = CSV::Reader.create('"ab"abfsababrs', "abfs", "abrs")
 
1668
    assert_equal(['ab', 'ab'], reader.shift)
 
1669
 
 
1670
    reader = CSV::Reader.create('"ab"aabfsababrs', "abfs", "abrs")
 
1671
    assert_raises(CSV::IllegalFormatError) do
 
1672
      reader.shift
 
1673
    end
 
1674
 
 
1675
    # fs match while matching rs progress
 
1676
    reader = CSV::Reader.create("ab,ababrs", nil, "abrs")
 
1677
    assert_equal(['ab', 'ab'], reader.shift)
 
1678
 
 
1679
    reader = CSV::Reader.create(',ababrs', nil, "abrs")
 
1680
    assert_equal([nil, 'ab'], reader.shift)
 
1681
 
 
1682
    reader = CSV::Reader.create('"",ababrs', nil, "abrs")
 
1683
    assert_equal(['', 'ab'], reader.shift)
 
1684
 
 
1685
    reader = CSV::Reader.create('ab,"ab"abrs', nil, "abrs")
 
1686
    assert_equal(['ab', 'ab'], reader.shift)
 
1687
 
 
1688
    reader = CSV::Reader.create('ab,"ab"aabrs', nil, "abrs")
 
1689
    assert_raises(CSV::IllegalFormatError) do
 
1690
      reader.shift
 
1691
    end
 
1692
 
 
1693
    # rs match while matching fs progress
 
1694
    reader = CSV::Reader.create("ab|abc", 'ab-', "ab|")
 
1695
    assert_equal([nil], reader.shift)
 
1696
    assert_equal(['abc'], reader.shift)
 
1697
 
 
1698
    reader = CSV::Reader.create("ab\ncdabcef", "abc", "\n")
 
1699
    assert_equal(['ab'], reader.shift)
 
1700
    assert_equal(['cd', "ef"], reader.shift)
 
1701
 
 
1702
    # EOF while fs/rs matching
 
1703
    reader = CSV::Reader.create("ab", 'ab-', "xyz")
 
1704
    assert_equal(['ab'], reader.shift)
 
1705
 
 
1706
    reader = CSV::Reader.create("ab", 'xyz', "ab|")
 
1707
    assert_equal(['ab'], reader.shift)
 
1708
 
 
1709
    reader = CSV::Reader.create("ab", 'ab-', "ab|")
 
1710
    assert_equal(['ab'], reader.shift)
 
1711
 
 
1712
    reader = CSV::Reader.create(",,:,,:,,;,,:,,,,:,,;", ",,:", ",,;")
 
1713
    assert_equal([nil, nil, nil], reader.shift)
 
1714
    assert_equal([nil, ",,", nil], reader.shift)
 
1715
  end
 
1716
 
 
1717
  def test_s_foreach
 
1718
    File.open(@outfile, "w") do |f|
 
1719
      f << "1,2,3\n4,5,6"
 
1720
    end
 
1721
    row = []
 
1722
    CSV.foreach(@outfile) { |line|
 
1723
      row << line
 
1724
    }
 
1725
    assert_equal([['1', '2', '3'], ['4', '5', '6']], row)
 
1726
 
 
1727
    File.open(@outfile, "w") do |f|
 
1728
      f << "1,2,3\r4,5,6"
 
1729
    end
 
1730
    row = []
 
1731
    CSV.foreach(@outfile, "\r") { |line|
 
1732
      row << line
 
1733
    }
 
1734
    assert_equal([['1', '2', '3'], ['4', '5', '6']], row)
 
1735
  end
 
1736
 
 
1737
  def test_s_readlines
 
1738
    File.open(@outfile, "w") do |f|
 
1739
      f << "1,2,3\n4,5,6"
 
1740
    end
 
1741
    assert_equal([["1", "2", "3"], ["4", "5", "6"]], CSV.readlines(@outfile))
 
1742
    assert_equal([["1", "2", nil], [nil, "5", "6"]], CSV.readlines(@outfile, "3\n4"))
 
1743
  end
 
1744
 
 
1745
  def test_s_read
 
1746
    File.open(@outfile, "w") do |f|
 
1747
      f << "1,2,3\n4,5,6"
 
1748
    end
 
1749
    assert_equal([["1", "2", "3"], ["4", "5", "6"]], CSV.read(@outfile))
 
1750
    assert_equal([["1", "2"]], CSV.read(@outfile, 3))
 
1751
    assert_equal([[nil], ["4", nil]], CSV.read(@outfile, 3, 5))
 
1752
  end
 
1753
end