mirror of git://gcc.gnu.org/git/gcc.git
372 lines
8.8 KiB
Go
372 lines
8.8 KiB
Go
// Copyright 2011 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package csv
|
|
|
|
import (
|
|
"io"
|
|
"reflect"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
var readTests = []struct {
|
|
Name string
|
|
Input string
|
|
Output [][]string
|
|
UseFieldsPerRecord bool // false (default) means FieldsPerRecord is -1
|
|
|
|
// These fields are copied into the Reader
|
|
Comma rune
|
|
Comment rune
|
|
FieldsPerRecord int
|
|
LazyQuotes bool
|
|
TrailingComma bool
|
|
TrimLeadingSpace bool
|
|
|
|
Error string
|
|
Line int // Expected error line if != 0
|
|
Column int // Expected error column if line != 0
|
|
}{
|
|
{
|
|
Name: "Simple",
|
|
Input: "a,b,c\n",
|
|
Output: [][]string{{"a", "b", "c"}},
|
|
},
|
|
{
|
|
Name: "CRLF",
|
|
Input: "a,b\r\nc,d\r\n",
|
|
Output: [][]string{{"a", "b"}, {"c", "d"}},
|
|
},
|
|
{
|
|
Name: "BareCR",
|
|
Input: "a,b\rc,d\r\n",
|
|
Output: [][]string{{"a", "b\rc", "d"}},
|
|
},
|
|
{
|
|
Name: "RFC4180test",
|
|
UseFieldsPerRecord: true,
|
|
Input: `#field1,field2,field3
|
|
"aaa","bb
|
|
b","ccc"
|
|
"a,a","b""bb","ccc"
|
|
zzz,yyy,xxx
|
|
`,
|
|
Output: [][]string{
|
|
{"#field1", "field2", "field3"},
|
|
{"aaa", "bb\nb", "ccc"},
|
|
{"a,a", `b"bb`, "ccc"},
|
|
{"zzz", "yyy", "xxx"},
|
|
},
|
|
},
|
|
{
|
|
Name: "NoEOLTest",
|
|
Input: "a,b,c",
|
|
Output: [][]string{{"a", "b", "c"}},
|
|
},
|
|
{
|
|
Name: "Semicolon",
|
|
Comma: ';',
|
|
Input: "a;b;c\n",
|
|
Output: [][]string{{"a", "b", "c"}},
|
|
},
|
|
{
|
|
Name: "MultiLine",
|
|
Input: `"two
|
|
line","one line","three
|
|
line
|
|
field"`,
|
|
Output: [][]string{{"two\nline", "one line", "three\nline\nfield"}},
|
|
},
|
|
{
|
|
Name: "BlankLine",
|
|
Input: "a,b,c\n\nd,e,f\n\n",
|
|
Output: [][]string{
|
|
{"a", "b", "c"},
|
|
{"d", "e", "f"},
|
|
},
|
|
},
|
|
{
|
|
Name: "BlankLineFieldCount",
|
|
Input: "a,b,c\n\nd,e,f\n\n",
|
|
UseFieldsPerRecord: true,
|
|
Output: [][]string{
|
|
{"a", "b", "c"},
|
|
{"d", "e", "f"},
|
|
},
|
|
},
|
|
{
|
|
Name: "TrimSpace",
|
|
Input: " a, b, c\n",
|
|
TrimLeadingSpace: true,
|
|
Output: [][]string{{"a", "b", "c"}},
|
|
},
|
|
{
|
|
Name: "LeadingSpace",
|
|
Input: " a, b, c\n",
|
|
Output: [][]string{{" a", " b", " c"}},
|
|
},
|
|
{
|
|
Name: "Comment",
|
|
Comment: '#',
|
|
Input: "#1,2,3\na,b,c\n#comment",
|
|
Output: [][]string{{"a", "b", "c"}},
|
|
},
|
|
{
|
|
Name: "NoComment",
|
|
Input: "#1,2,3\na,b,c",
|
|
Output: [][]string{{"#1", "2", "3"}, {"a", "b", "c"}},
|
|
},
|
|
{
|
|
Name: "LazyQuotes",
|
|
LazyQuotes: true,
|
|
Input: `a "word","1"2",a","b`,
|
|
Output: [][]string{{`a "word"`, `1"2`, `a"`, `b`}},
|
|
},
|
|
{
|
|
Name: "BareQuotes",
|
|
LazyQuotes: true,
|
|
Input: `a "word","1"2",a"`,
|
|
Output: [][]string{{`a "word"`, `1"2`, `a"`}},
|
|
},
|
|
{
|
|
Name: "BareDoubleQuotes",
|
|
LazyQuotes: true,
|
|
Input: `a""b,c`,
|
|
Output: [][]string{{`a""b`, `c`}},
|
|
},
|
|
{
|
|
Name: "BadDoubleQuotes",
|
|
Input: `a""b,c`,
|
|
Error: `bare " in non-quoted-field`, Line: 1, Column: 1,
|
|
},
|
|
{
|
|
Name: "TrimQuote",
|
|
Input: ` "a"," b",c`,
|
|
TrimLeadingSpace: true,
|
|
Output: [][]string{{"a", " b", "c"}},
|
|
},
|
|
{
|
|
Name: "BadBareQuote",
|
|
Input: `a "word","b"`,
|
|
Error: `bare " in non-quoted-field`, Line: 1, Column: 2,
|
|
},
|
|
{
|
|
Name: "BadTrailingQuote",
|
|
Input: `"a word",b"`,
|
|
Error: `bare " in non-quoted-field`, Line: 1, Column: 10,
|
|
},
|
|
{
|
|
Name: "ExtraneousQuote",
|
|
Input: `"a "word","b"`,
|
|
Error: `extraneous " in field`, Line: 1, Column: 3,
|
|
},
|
|
{
|
|
Name: "BadFieldCount",
|
|
UseFieldsPerRecord: true,
|
|
Input: "a,b,c\nd,e",
|
|
Error: "wrong number of fields", Line: 2,
|
|
},
|
|
{
|
|
Name: "BadFieldCount1",
|
|
UseFieldsPerRecord: true,
|
|
FieldsPerRecord: 2,
|
|
Input: `a,b,c`,
|
|
Error: "wrong number of fields", Line: 1,
|
|
},
|
|
{
|
|
Name: "FieldCount",
|
|
Input: "a,b,c\nd,e",
|
|
Output: [][]string{{"a", "b", "c"}, {"d", "e"}},
|
|
},
|
|
{
|
|
Name: "TrailingCommaEOF",
|
|
Input: "a,b,c,",
|
|
Output: [][]string{{"a", "b", "c", ""}},
|
|
},
|
|
{
|
|
Name: "TrailingCommaEOL",
|
|
Input: "a,b,c,\n",
|
|
Output: [][]string{{"a", "b", "c", ""}},
|
|
},
|
|
{
|
|
Name: "TrailingCommaSpaceEOF",
|
|
TrimLeadingSpace: true,
|
|
Input: "a,b,c, ",
|
|
Output: [][]string{{"a", "b", "c", ""}},
|
|
},
|
|
{
|
|
Name: "TrailingCommaSpaceEOL",
|
|
TrimLeadingSpace: true,
|
|
Input: "a,b,c, \n",
|
|
Output: [][]string{{"a", "b", "c", ""}},
|
|
},
|
|
{
|
|
Name: "TrailingCommaLine3",
|
|
TrimLeadingSpace: true,
|
|
Input: "a,b,c\nd,e,f\ng,hi,",
|
|
Output: [][]string{{"a", "b", "c"}, {"d", "e", "f"}, {"g", "hi", ""}},
|
|
},
|
|
{
|
|
Name: "NotTrailingComma3",
|
|
Input: "a,b,c, \n",
|
|
Output: [][]string{{"a", "b", "c", " "}},
|
|
},
|
|
{
|
|
Name: "CommaFieldTest",
|
|
TrailingComma: true,
|
|
Input: `x,y,z,w
|
|
x,y,z,
|
|
x,y,,
|
|
x,,,
|
|
,,,
|
|
"x","y","z","w"
|
|
"x","y","z",""
|
|
"x","y","",""
|
|
"x","","",""
|
|
"","","",""
|
|
`,
|
|
Output: [][]string{
|
|
{"x", "y", "z", "w"},
|
|
{"x", "y", "z", ""},
|
|
{"x", "y", "", ""},
|
|
{"x", "", "", ""},
|
|
{"", "", "", ""},
|
|
{"x", "y", "z", "w"},
|
|
{"x", "y", "z", ""},
|
|
{"x", "y", "", ""},
|
|
{"x", "", "", ""},
|
|
{"", "", "", ""},
|
|
},
|
|
},
|
|
{
|
|
Name: "TrailingCommaIneffective1",
|
|
TrailingComma: true,
|
|
TrimLeadingSpace: true,
|
|
Input: "a,b,\nc,d,e",
|
|
Output: [][]string{
|
|
{"a", "b", ""},
|
|
{"c", "d", "e"},
|
|
},
|
|
},
|
|
{
|
|
Name: "TrailingCommaIneffective2",
|
|
TrailingComma: false,
|
|
TrimLeadingSpace: true,
|
|
Input: "a,b,\nc,d,e",
|
|
Output: [][]string{
|
|
{"a", "b", ""},
|
|
{"c", "d", "e"},
|
|
},
|
|
},
|
|
}
|
|
|
|
func TestRead(t *testing.T) {
|
|
for _, tt := range readTests {
|
|
r := NewReader(strings.NewReader(tt.Input))
|
|
r.Comment = tt.Comment
|
|
if tt.UseFieldsPerRecord {
|
|
r.FieldsPerRecord = tt.FieldsPerRecord
|
|
} else {
|
|
r.FieldsPerRecord = -1
|
|
}
|
|
r.LazyQuotes = tt.LazyQuotes
|
|
r.TrailingComma = tt.TrailingComma
|
|
r.TrimLeadingSpace = tt.TrimLeadingSpace
|
|
if tt.Comma != 0 {
|
|
r.Comma = tt.Comma
|
|
}
|
|
out, err := r.ReadAll()
|
|
perr, _ := err.(*ParseError)
|
|
if tt.Error != "" {
|
|
if err == nil || !strings.Contains(err.Error(), tt.Error) {
|
|
t.Errorf("%s: error %v, want error %q", tt.Name, err, tt.Error)
|
|
} else if tt.Line != 0 && (tt.Line != perr.Line || tt.Column != perr.Column) {
|
|
t.Errorf("%s: error at %d:%d expected %d:%d", tt.Name, perr.Line, perr.Column, tt.Line, tt.Column)
|
|
}
|
|
} else if err != nil {
|
|
t.Errorf("%s: unexpected error %v", tt.Name, err)
|
|
} else if !reflect.DeepEqual(out, tt.Output) {
|
|
t.Errorf("%s: out=%q want %q", tt.Name, out, tt.Output)
|
|
}
|
|
}
|
|
}
|
|
|
|
// nTimes is an io.Reader which yields the string s n times.
|
|
type nTimes struct {
|
|
s string
|
|
n int
|
|
off int
|
|
}
|
|
|
|
func (r *nTimes) Read(p []byte) (n int, err error) {
|
|
for {
|
|
if r.n <= 0 || r.s == "" {
|
|
return n, io.EOF
|
|
}
|
|
n0 := copy(p, r.s[r.off:])
|
|
p = p[n0:]
|
|
n += n0
|
|
r.off += n0
|
|
if r.off == len(r.s) {
|
|
r.off = 0
|
|
r.n--
|
|
}
|
|
if len(p) == 0 {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
// benchmarkRead measures reading the provided CSV rows data.
|
|
// initReader, if non-nil, modifies the Reader before it's used.
|
|
func benchmarkRead(b *testing.B, initReader func(*Reader), rows string) {
|
|
b.ReportAllocs()
|
|
r := NewReader(&nTimes{s: rows, n: b.N})
|
|
if initReader != nil {
|
|
initReader(r)
|
|
}
|
|
for {
|
|
_, err := r.Read()
|
|
if err == io.EOF {
|
|
break
|
|
}
|
|
if err != nil {
|
|
b.Fatal(err)
|
|
}
|
|
}
|
|
}
|
|
|
|
const benchmarkCSVData = `x,y,z,w
|
|
x,y,z,
|
|
x,y,,
|
|
x,,,
|
|
,,,
|
|
"x","y","z","w"
|
|
"x","y","z",""
|
|
"x","y","",""
|
|
"x","","",""
|
|
"","","",""
|
|
`
|
|
|
|
func BenchmarkRead(b *testing.B) {
|
|
benchmarkRead(b, nil, benchmarkCSVData)
|
|
}
|
|
|
|
func BenchmarkReadWithFieldsPerRecord(b *testing.B) {
|
|
benchmarkRead(b, func(r *Reader) { r.FieldsPerRecord = 4 }, benchmarkCSVData)
|
|
}
|
|
|
|
func BenchmarkReadWithoutFieldsPerRecord(b *testing.B) {
|
|
benchmarkRead(b, func(r *Reader) { r.FieldsPerRecord = -1 }, benchmarkCSVData)
|
|
}
|
|
|
|
func BenchmarkReadLargeFields(b *testing.B) {
|
|
benchmarkRead(b, nil, strings.Repeat(`xxxxxxxxxxxxxxxx,yyyyyyyyyyyyyyyy,zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz,wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww,vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
|
|
xxxxxxxxxxxxxxxxxxxxxxxx,yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy,zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz,wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww,vvvv
|
|
,,zzzz,wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww,vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
|
|
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx,yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy,zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz,wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww,vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
|
|
`, 3))
|
|
}
|