diff --git a/comment_test.go b/comment_test.go index 3b9898a..058adce 100644 --- a/comment_test.go +++ b/comment_test.go @@ -5,7 +5,7 @@ import ( ) func TestComment2(t *testing.T) { - for _, test := range []parseToASTTest{ + for _, test := range []parseTest{ {``, `{}`, `unexpected end of file (expected comment) at start of file`}, {`#`, `{}`, ``}, {`# `, `{}`, ``}, @@ -16,6 +16,6 @@ func TestComment2(t *testing.T) { {"# with data and newline\ncode continues here", `{}`, `unexpected input (expected end of file) at line 2, column 1`}, } { p := newParser() - testParseToAST(t, p, p.startComment, test) + testParse(t, p, p.startComment, test) } } diff --git a/helpers_test.go b/helpers_test.go index c64ab09..7ea856e 100644 --- a/helpers_test.go +++ b/helpers_test.go @@ -28,13 +28,13 @@ func testAST(t *testing.T, code func() (error, *parser), expectedError string, e } } -type parseToASTTest struct { +type parseTest struct { input interface{} expected string expectedError string } -func testParseToAST(t *testing.T, p *parser, handler parse.Handler, test parseToASTTest) { +func testParse(t *testing.T, p *parser, handler parse.Handler, test parseTest) { var err error defer func() { recovered := recover() diff --git a/keyvaluepair_test.go b/keyvaluepair_test.go index f19d93b..bc32bd1 100644 --- a/keyvaluepair_test.go +++ b/keyvaluepair_test.go @@ -3,7 +3,7 @@ package toml import "testing" func TestKey(t *testing.T) { - for _, test := range []parseToASTTest{ + for _, test := range []parseTest{ // Bare key tests {"barekey=0", `{"barekey": 0}`, ``}, {"1234567=0", `{"1234567": 0}`, ``}, @@ -24,16 +24,17 @@ func TestKey(t *testing.T) { {`"double quoted"=0`, `{"double quoted": 0}`, ``}, {`"escapes are in\terpreted"=0`, `{"escapes are in\terpreted": 0}`, ``}, {`"using 'inner' \"quotes\""=0`, `{"using 'inner' \"quotes\"": 0}`, ``}, + {`"invalid \xcd string"=0`, `{}`, "invalid escape sequence at line 1, column 10"}, // Mixed key types {`this.'i\s'."madness\t".''=0`, `{"this": {"i\\s": {"madness\t": {"": 0}}}}`, ``}, } { p := newParser() - testParseToAST(t, p, p.startKeyValuePair, test) + testParse(t, p, p.startKeyValuePair, test) } } func TestKeyValuePair(t *testing.T) { - for _, test := range []parseToASTTest{ + for _, test := range []parseTest{ {``, `{}`, ``}, {` `, `{}`, ``}, {" \t ", `{}`, ``}, @@ -49,12 +50,12 @@ func TestKeyValuePair(t *testing.T) { {"with=\"comments\"# boring \nanother.cool =\"one\" \t # to the end\r\n", `{"another": {"cool": "one"}, "with": "comments"}`, ``}, } { p := newParser() - testParseToAST(t, p, p.startKeyValuePair, test) + testParse(t, p, p.startKeyValuePair, test) } } func TestKeyValuePair_ForAllTypes(t *testing.T) { - for _, test := range []parseToASTTest{ + for _, test := range []parseTest{ {"string='literal'", `{"string": "literal"}`, ``}, {"string='''literal\nmulti-line'''", `{"string": "literal\nmulti-line"}`, ``}, {`string="basic"`, `{"string": "basic"}`, ``}, @@ -76,12 +77,12 @@ func TestKeyValuePair_ForAllTypes(t *testing.T) { {"static_array=['a', 'static', 'array']", `{"static_array": ["a", "static", "array"]}`, ``}, } { p := newParser() - testParseToAST(t, p, p.startKeyValuePair, test) + testParse(t, p, p.startKeyValuePair, test) } } func TestKeyValuePair_ExamplesFromSpecification(t *testing.T) { - for _, test := range []parseToASTTest{ + for _, test := range []parseTest{ {"int1 = +99", `{"int1": 99}`, ``}, {"int2 = 42", `{"int2": 42}`, ``}, {"int3 = 0", `{"int3": 0}`, ``}, @@ -130,6 +131,6 @@ func TestKeyValuePair_ExamplesFromSpecification(t *testing.T) { {"arr8 = [\n 1,\n 2, # this is ok\n]", `{"arr8": [1, 2]}`, ``}, } { p := newParser() - testParseToAST(t, p, p.startKeyValuePair, test) + testParse(t, p, p.startKeyValuePair, test) } } diff --git a/value_array_test.go b/value_array_test.go index 8548bd5..23748d5 100644 --- a/value_array_test.go +++ b/value_array_test.go @@ -6,14 +6,14 @@ import ( "git.makaay.nl/mauricem/go-parsekit/parse" ) -func TestArrayStart(t *testing.T) { +func TestStartArray(t *testing.T) { parser := newParser() wrapper := func(p *parse.API) { parser.parseArray(p) } - testParseToAST(t, parser, wrapper, parseToASTTest{"INVALID", "{}", "unexpected input (expected an array) at start of file"}) + testParse(t, parser, wrapper, parseTest{"INVALID", "{}", "unexpected input (expected an array) at start of file"}) } func TestArray(t *testing.T) { - for _, test := range []parseToASTTest{ + for _, test := range []parseTest{ {"x=[ape", `{}`, `unexpected input (expected a value) at line 1, column 4`}, {"x=[1", `{}`, `unexpected end of file (expected an array separator) at line 1, column 5`}, {"x=[]", `{"x": []}`, ``}, @@ -42,6 +42,6 @@ func TestArray(t *testing.T) { {`x=[[1],'a']`, `{}`, `type mismatch in array of static arrays: found an item of type string at line 1, column 11`}, } { p := newParser() - testParseToAST(t, p, p.startKeyValuePair, test) + testParse(t, p, p.startKeyValuePair, test) } } diff --git a/value_boolean_test.go b/value_boolean_test.go index 5394a3d..2c03f99 100644 --- a/value_boolean_test.go +++ b/value_boolean_test.go @@ -6,14 +6,14 @@ import ( "git.makaay.nl/mauricem/go-parsekit/parse" ) -func TestBooleanStart(t *testing.T) { +func TestStartBoolean(t *testing.T) { parser := newParser() wrapper := func(p *parse.API) { parser.parseBoolean(p) } - testParseToAST(t, parser, wrapper, parseToASTTest{"INVALID", "{}", "unexpected input (expected true or false) at start of file"}) + testParse(t, parser, wrapper, parseTest{"INVALID", "{}", "unexpected input (expected true or false) at start of file"}) } func TestBoolean(t *testing.T) { - for _, test := range []parseToASTTest{ + for _, test := range []parseTest{ {`x=true`, `{"x": true}`, ``}, {`x=false`, `{"x": false}`, ``}, {`x=yes`, `{}`, `unexpected input (expected a value) at line 1, column 3`}, @@ -22,6 +22,6 @@ func TestBoolean(t *testing.T) { {`x=0`, `{"x": 0}`, ``}, } { p := newParser() - testParseToAST(t, p, p.startKeyValuePair, test) + testParse(t, p, p.startKeyValuePair, test) } } diff --git a/value_datetime_test.go b/value_datetime_test.go index 7168dd0..7c49b54 100644 --- a/value_datetime_test.go +++ b/value_datetime_test.go @@ -6,14 +6,14 @@ import ( "git.makaay.nl/mauricem/go-parsekit/parse" ) -func TestDateTimeStart(t *testing.T) { +func TestStartDateTime(t *testing.T) { parser := newParser() wrapper := func(p *parse.API) { parser.parseDateTime(p) } - testParseToAST(t, parser, wrapper, parseToASTTest{"INVALID", "{}", "unexpected input (expected a date and/or time) at start of file"}) + testParse(t, parser, wrapper, parseTest{"INVALID", "{}", "unexpected input (expected a date and/or time) at start of file"}) } func TestDateTime(t *testing.T) { - for _, test := range []parseToASTTest{ + for _, test := range []parseTest{ {`x=1979-05-27`, `{"x": 1979-05-27}`, ``}, {`x=00:00:00`, `{"x": 00:00:00}`, ``}, {`x=23:59:59`, `{"x": 23:59:59}`, ``}, @@ -35,6 +35,6 @@ func TestDateTime(t *testing.T) { {`x=25:01:01`, `{}`, `invalid date/time value 25:01:01: parsing time "25:01:01": hour out of range at line 1, column 11`}, } { p := newParser() - testParseToAST(t, p, p.startKeyValuePair, test) + testParse(t, p, p.startKeyValuePair, test) } } diff --git a/value_number_test.go b/value_number_test.go index e3e8525..a547d72 100644 --- a/value_number_test.go +++ b/value_number_test.go @@ -6,14 +6,14 @@ import ( "git.makaay.nl/mauricem/go-parsekit/parse" ) -func TestNumberStart(t *testing.T) { +func TestStartNumber(t *testing.T) { parser := newParser() wrapper := func(p *parse.API) { parser.parseNumber(p) } - testParseToAST(t, parser, wrapper, parseToASTTest{"INVALID", "{}", "unexpected input (expected a number) at start of file"}) + testParse(t, parser, wrapper, parseTest{"INVALID", "{}", "unexpected input (expected a number) at start of file"}) } func TestInteger(t *testing.T) { - for _, test := range []parseToASTTest{ + for _, test := range []parseTest{ // Decimal {`x=0`, `{"x": 0}`, ``}, {`x=+0`, `{"x": 0}`, ``}, @@ -75,12 +75,12 @@ func TestInteger(t *testing.T) { {`x=0b10000000_00000000_00000000_00000000_00000000_00000000_00000000_00000000`, `{}`, `invalid integer value 0b1000000000000000000000000000000000000000000000000000000000000000: strconv.ParseInt: parsing "1000000000000000000000000000000000000000000000000000000000000000": value out of range at line 1, column 76`}, } { p := newParser() - testParseToAST(t, p, p.startKeyValuePair, test) + testParse(t, p, p.startKeyValuePair, test) } } func TestFloat(t *testing.T) { - for _, test := range []parseToASTTest{ + for _, test := range []parseTest{ {`x=0.0`, `{"x": 0}`, ``}, {`x=+0.0`, `{"x": 0}`, ``}, {`x=-0.0`, `{"x": -0}`, ``}, @@ -101,6 +101,6 @@ func TestFloat(t *testing.T) { {`x=-inf`, `{"x": -Inf}`, ``}, } { p := newParser() - testParseToAST(t, p, p.startKeyValuePair, test) + testParse(t, p, p.startKeyValuePair, test) } } diff --git a/value_string_test.go b/value_string_test.go index a8a7143..65da32e 100644 --- a/value_string_test.go +++ b/value_string_test.go @@ -3,10 +3,42 @@ package toml import ( "fmt" "testing" + + "git.makaay.nl/mauricem/go-parsekit/parse" ) +func TestStartString(t *testing.T) { + parser := newParser() + wrapper := func(p *parse.API) { parser.parseString(p) } + testParse(t, parser, wrapper, parseTest{"(not a string)", "{}", "unexpected input (expected a string value) at start of file"}) +} + +func TestStartBasicString(t *testing.T) { + parser := newParser() + wrapper := func(p *parse.API) { parser.parseBasicString("xyz", p) } + testParse(t, parser, wrapper, parseTest{"(not a string)", "{}", "unexpected input (expected opening quotation marks) at start of file"}) +} + +func TestStartLiteralString(t *testing.T) { + parser := newParser() + wrapper := func(p *parse.API) { parser.parseLiteralString("xyz", p) } + testParse(t, parser, wrapper, parseTest{"(not a string)", "{}", "unexpected input (expected opening single quote) at start of file"}) +} + +func TestStartMultiLineBasicString(t *testing.T) { + parser := newParser() + wrapper := func(p *parse.API) { parser.parseMultiLineBasicString(p) } + testParse(t, parser, wrapper, parseTest{"(not a string)", "{}", "unexpected input (expected opening three quotation marks) at start of file"}) +} + +func TestStartMultiLineLiteralString(t *testing.T) { + parser := newParser() + wrapper := func(p *parse.API) { parser.parseMultiLineLiteralString(p) } + testParse(t, parser, wrapper, parseTest{"(not a string)", "{}", "unexpected input (expected opening three single quotes) at start of file"}) +} + func TestString(t *testing.T) { - for _, test := range []parseToASTTest{ + for _, test := range []parseTest{ {`x=no start quote"`, `{}`, `unexpected input (expected a value) at line 1, column 3`}, {`x="basic s\tring"`, `{"x": "basic s\tring"}`, ``}, {"x=\"\"\"\n basic multi-line\n string value\n\"\"\"", `{"x": " basic multi-line\n string value\n"}`, ``}, @@ -14,12 +46,12 @@ func TestString(t *testing.T) { {"x='''\n literal multi-line\n string value\n'''", `{"x": " literal multi-line\n string value\n"}`, ``}, } { p := newParser() - testParseToAST(t, p, p.startKeyValuePair, test) + testParse(t, p, p.startKeyValuePair, test) } } func TestBasipString(t *testing.T) { - for _, test := range []parseToASTTest{ + for _, test := range []parseTest{ {`x="no end quote`, `{}`, `unexpected end of file (expected closing quotation marks) at line 1, column 16`}, {`x=""`, `{"x": ""}`, ``}, {`x="simple string"`, `{"x": "simple string"}`, ``}, @@ -33,12 +65,12 @@ func TestBasipString(t *testing.T) { {"x=\"Character that must be escaped \x7f\"", `{}`, `invalid character in string value: '\u007f' (must be escaped) at line 1, column 35`}, } { p := newParser() - testParseToAST(t, p, p.startKeyValuePair, test) + testParse(t, p, p.startKeyValuePair, test) } } func TestMultiLineBasipString(t *testing.T) { - for _, test := range []parseToASTTest{ + for _, test := range []parseTest{ {`x="""missing close quote""`, `{}`, `unexpected end of file (expected closing three quotation marks) at line 1, column 27`}, {`x=""""""`, `{"x": ""}`, ``}, {"x=\"\"\"\n\"\"\"", `{"x": ""}`, ``}, @@ -51,12 +83,12 @@ func TestMultiLineBasipString(t *testing.T) { {"x=\"\"\"Invalid rune \xcd\"\"\"", `{}`, `invalid UTF8 rune at line 1, column 19`}, } { p := newParser() - testParseToAST(t, p, p.startKeyValuePair, test) + testParse(t, p, p.startKeyValuePair, test) } } func TestLiteralString(t *testing.T) { - for _, test := range []parseToASTTest{ + for _, test := range []parseTest{ {`x='missing close quote`, `{}`, `unexpected end of file (expected closing single quote) at line 1, column 23`}, {`x=''`, `{"x": ""}`, ``}, {`x='simple'`, `{"x": "simple"}`, ``}, @@ -69,12 +101,12 @@ func TestLiteralString(t *testing.T) { {"x='Invalid rune \xcd'", `{}`, `invalid UTF8 rune at line 1, column 17`}, } { p := newParser() - testParseToAST(t, p, p.startKeyValuePair, test) + testParse(t, p, p.startKeyValuePair, test) } } func TestMultiLineLiteralString(t *testing.T) { - for _, test := range []parseToASTTest{ + for _, test := range []parseTest{ {`x='''missing close quote''`, `{}`, `unexpected end of file (expected closing three single quotes) at line 1, column 27`}, {`x=''''''`, `{"x": ""}`, ``}, {"x='''\n'''", `{"x": ""}`, ``}, @@ -84,7 +116,7 @@ func TestMultiLineLiteralString(t *testing.T) { {"x='''No invalid runes allowed \xcd'''", `{}`, `invalid UTF8 rune at line 1, column 31`}, } { p := newParser() - testParseToAST(t, p, p.startKeyValuePair, test) + testParse(t, p, p.startKeyValuePair, test) } } @@ -95,6 +127,6 @@ func TestBasipStringWithUnescapedControlCharacters(t *testing.T) { p := newParser() input := fmt.Sprintf(`x="%c"`, rune(i)) expected := fmt.Sprintf(`invalid character in string value: %q (must be escaped) at line 1, column 4`, rune(i)) - testParseToAST(t, p, p.startKeyValuePair, parseToASTTest{input, "{}", expected}) + testParse(t, p, p.startKeyValuePair, parseTest{input, "{}", expected}) } } diff --git a/value_table_test.go b/value_table_test.go index b61383c..f9f0c6c 100644 --- a/value_table_test.go +++ b/value_table_test.go @@ -2,10 +2,18 @@ package toml import ( "testing" + + "git.makaay.nl/mauricem/go-parsekit/parse" ) +func TestStartTable(t *testing.T) { + parser := newParser() + wrapper := func(p *parse.API) { parser.startTable(p) } + testParse(t, parser, wrapper, parseTest{"(not a table)", "{}", "unexpected input (expected a table) at start of file"}) +} + func TestTableKey(t *testing.T) { - for _, test := range []parseToASTTest{ + for _, test := range []parseTest{ {"[", `{}`, `unexpected end of file (expected a key name) at line 1, column 2`}, {" \t [", `{}`, `unexpected end of file (expected a key name) at line 1, column 5`}, {" \t [key", `{}`, `unexpected end of file (expected closing ']' for table name) at line 1, column 8`}, @@ -18,12 +26,12 @@ func TestTableKey(t *testing.T) { {" \t [key.'sub key' \t] \t # with comment\n", `{"key": {"sub key": {}}}`, ``}, } { p := newParser() - testParseToAST(t, p, p.startTable, test) + testParse(t, p, p.startTable, test) } } func TestTable(t *testing.T) { - for _, test := range []parseToASTTest{ + for _, test := range []parseTest{ {"[a]", `{"a": {}}`, ``}, {"['a key']", `{"a key": {}}`, ``}, {"[\"a key\"]", `{"a key": {}}`, ``}, @@ -35,14 +43,15 @@ func TestTable(t *testing.T) { {"[a]\n[b] #another table \na=1\n", `{"a": {}, "b": {"a": 1}}`, ``}, {"[a]\nx=1\ny=2\n[b] #another table \nx=1\ny=2021-01-01", `{"a": {"x": 1, "y": 2}, "b": {"x": 1, "y": 2021-01-01}}`, ``}, {"[a]\nx=1\ny=2\n[a.b] #subtable \nx=1\ny=2021-01-01", `{"a": {"b": {"x": 1, "y": 2021-01-01}, "x": 1, "y": 2}}`, ``}, + {"[a]\n[a]", `{"a": {}}`, `invalid table: table item already exists at key [a] at line 2, column 4`}, } { p := newParser() - testParseToAST(t, p, p.startTable, test) + testParse(t, p, p.startTable, test) } } func TestArrayOfTableKey(t *testing.T) { - for _, test := range []parseToASTTest{ + for _, test := range []parseTest{ {"[[", `{}`, `unexpected end of file (expected a key name) at line 1, column 3`}, {" \t [[", `{}`, `unexpected end of file (expected a key name) at line 1, column 6`}, {" \t [[key", `{}`, `unexpected end of file (expected closing ']]' for array of tables name) at line 1, column 9`}, @@ -55,19 +64,20 @@ func TestArrayOfTableKey(t *testing.T) { {" \t [[key.'sub key' \t]] \t # with comment\n", `{"key": {"sub key": [{}]}}`, ``}, } { p := newParser() - testParseToAST(t, p, p.startTable, test) + testParse(t, p, p.startTable, test) } } func TestArrayOfTables(t *testing.T) { - for _, test := range []parseToASTTest{ + for _, test := range []parseTest{ {"[[a]]", `{"a": [{}]}`, ``}, {"[[a]]\n[['a']]\n[[\"a\"]]", `{"a": [{}, {}, {}]}`, ``}, {"[[a]]\n[['a']]\n[b]\n[[\"a\"]]", `{"a": [{}, {}, {}], "b": {}}`, ``}, {"[[a]]\nx=1\n[['a']]\nx=2\ny=3\n[[\"a\"]]", `{"a": [{"x": 1}, {"x": 2, "y": 3}, {}]}`, ``}, {"[a]\n[[a.b]]\nx=1\n[[a.b]]\nx=2\n[a.c]\ny=1234", `{"a": {"b": [{"x": 1}, {"x": 2}], "c": {"y": 1234}}}`, ``}, + {"[a]\n[[a]]", `{"a": {}}`, `invalid table array: table item already exists at key [a] at line 2, column 6`}, } { p := newParser() - testParseToAST(t, p, p.startTable, test) + testParse(t, p, p.startTable, test) } }