ostiwe/go-toml
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Simplify redundant types in literals (#95)

Browse Source 
Using `gofmt -s`
This commit is contained in:
Cameron Moore
2016-08-23 02:45:54 -05:00
committed by Thomas Pelletier
parent 0049ab3dc4
commit 0599275eb9
4 changed files with 407 additions and 407 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lexer_test.go
+335 -335
View File
@@ -37,260 +37,260 @@ func testFlow(t *testing.T, input string, expectedFlow []token) {
func TestValidKeyGroup(t *testing.T) { func TestValidKeyGroup(t *testing.T) {
testFlow(t, "[hello world]", []token{ testFlow(t, "[hello world]", []token{
token{Position{1, 1}, tokenLeftBracket, "["}, {Position{1, 1}, tokenLeftBracket, "["},
token{Position{1, 2}, tokenKeyGroup, "hello world"}, {Position{1, 2}, tokenKeyGroup, "hello world"},
token{Position{1, 13}, tokenRightBracket, "]"}, {Position{1, 13}, tokenRightBracket, "]"},
token{Position{1, 14}, tokenEOF, ""}, {Position{1, 14}, tokenEOF, ""},
}) })
} }
func TestNestedQuotedUnicodeKeyGroup(t *testing.T) { func TestNestedQuotedUnicodeKeyGroup(t *testing.T) {
testFlow(t, `[ j . "ʞ" . l ]`, []token{ testFlow(t, `[ j . "ʞ" . l ]`, []token{
token{Position{1, 1}, tokenLeftBracket, "["}, {Position{1, 1}, tokenLeftBracket, "["},
token{Position{1, 2}, tokenKeyGroup, ` j . "ʞ" . l `}, {Position{1, 2}, tokenKeyGroup, ` j . "ʞ" . l `},
token{Position{1, 15}, tokenRightBracket, "]"}, {Position{1, 15}, tokenRightBracket, "]"},
token{Position{1, 16}, tokenEOF, ""}, {Position{1, 16}, tokenEOF, ""},
}) })
} }
func TestUnclosedKeyGroup(t *testing.T) { func TestUnclosedKeyGroup(t *testing.T) {
testFlow(t, "[hello world", []token{ testFlow(t, "[hello world", []token{
token{Position{1, 1}, tokenLeftBracket, "["}, {Position{1, 1}, tokenLeftBracket, "["},
token{Position{1, 2}, tokenError, "unclosed key group"}, {Position{1, 2}, tokenError, "unclosed key group"},
}) })
} }
func TestComment(t *testing.T) { func TestComment(t *testing.T) {
testFlow(t, "# blahblah", []token{ testFlow(t, "# blahblah", []token{
token{Position{1, 11}, tokenEOF, ""}, {Position{1, 11}, tokenEOF, ""},
}) })
} }
func TestKeyGroupComment(t *testing.T) { func TestKeyGroupComment(t *testing.T) {
testFlow(t, "[hello world] # blahblah", []token{ testFlow(t, "[hello world] # blahblah", []token{
token{Position{1, 1}, tokenLeftBracket, "["}, {Position{1, 1}, tokenLeftBracket, "["},
token{Position{1, 2}, tokenKeyGroup, "hello world"}, {Position{1, 2}, tokenKeyGroup, "hello world"},
token{Position{1, 13}, tokenRightBracket, "]"}, {Position{1, 13}, tokenRightBracket, "]"},
token{Position{1, 25}, tokenEOF, ""}, {Position{1, 25}, tokenEOF, ""},
}) })
} }
func TestMultipleKeyGroupsComment(t *testing.T) { func TestMultipleKeyGroupsComment(t *testing.T) {
testFlow(t, "[hello world] # blahblah\n[test]", []token{ testFlow(t, "[hello world] # blahblah\n[test]", []token{
token{Position{1, 1}, tokenLeftBracket, "["}, {Position{1, 1}, tokenLeftBracket, "["},
token{Position{1, 2}, tokenKeyGroup, "hello world"}, {Position{1, 2}, tokenKeyGroup, "hello world"},
token{Position{1, 13}, tokenRightBracket, "]"}, {Position{1, 13}, tokenRightBracket, "]"},
token{Position{2, 1}, tokenLeftBracket, "["}, {Position{2, 1}, tokenLeftBracket, "["},
token{Position{2, 2}, tokenKeyGroup, "test"}, {Position{2, 2}, tokenKeyGroup, "test"},
token{Position{2, 6}, tokenRightBracket, "]"}, {Position{2, 6}, tokenRightBracket, "]"},
token{Position{2, 7}, tokenEOF, ""}, {Position{2, 7}, tokenEOF, ""},
}) })
} }
func TestSimpleWindowsCRLF(t *testing.T) { func TestSimpleWindowsCRLF(t *testing.T) {
testFlow(t, "a=4\r\nb=2", []token{ testFlow(t, "a=4\r\nb=2", []token{
token{Position{1, 1}, tokenKey, "a"}, {Position{1, 1}, tokenKey, "a"},
token{Position{1, 2}, tokenEqual, "="}, {Position{1, 2}, tokenEqual, "="},
token{Position{1, 3}, tokenInteger, "4"}, {Position{1, 3}, tokenInteger, "4"},
token{Position{2, 1}, tokenKey, "b"}, {Position{2, 1}, tokenKey, "b"},
token{Position{2, 2}, tokenEqual, "="}, {Position{2, 2}, tokenEqual, "="},
token{Position{2, 3}, tokenInteger, "2"}, {Position{2, 3}, tokenInteger, "2"},
token{Position{2, 4}, tokenEOF, ""}, {Position{2, 4}, tokenEOF, ""},
}) })
} }
func TestBasicKey(t *testing.T) { func TestBasicKey(t *testing.T) {
testFlow(t, "hello", []token{ testFlow(t, "hello", []token{
token{Position{1, 1}, tokenKey, "hello"}, {Position{1, 1}, tokenKey, "hello"},
token{Position{1, 6}, tokenEOF, ""}, {Position{1, 6}, tokenEOF, ""},
}) })
} }
func TestBasicKeyWithUnderscore(t *testing.T) { func TestBasicKeyWithUnderscore(t *testing.T) {
testFlow(t, "hello_hello", []token{ testFlow(t, "hello_hello", []token{
token{Position{1, 1}, tokenKey, "hello_hello"}, {Position{1, 1}, tokenKey, "hello_hello"},
token{Position{1, 12}, tokenEOF, ""}, {Position{1, 12}, tokenEOF, ""},
}) })
} }
func TestBasicKeyWithDash(t *testing.T) { func TestBasicKeyWithDash(t *testing.T) {
testFlow(t, "hello-world", []token{ testFlow(t, "hello-world", []token{
token{Position{1, 1}, tokenKey, "hello-world"}, {Position{1, 1}, tokenKey, "hello-world"},
token{Position{1, 12}, tokenEOF, ""}, {Position{1, 12}, tokenEOF, ""},
}) })
} }
func TestBasicKeyWithUppercaseMix(t *testing.T) { func TestBasicKeyWithUppercaseMix(t *testing.T) {
testFlow(t, "helloHELLOHello", []token{ testFlow(t, "helloHELLOHello", []token{
token{Position{1, 1}, tokenKey, "helloHELLOHello"}, {Position{1, 1}, tokenKey, "helloHELLOHello"},
token{Position{1, 16}, tokenEOF, ""}, {Position{1, 16}, tokenEOF, ""},
}) })
} }
func TestBasicKeyWithInternationalCharacters(t *testing.T) { func TestBasicKeyWithInternationalCharacters(t *testing.T) {
testFlow(t, "héllÖ", []token{ testFlow(t, "héllÖ", []token{
token{Position{1, 1}, tokenKey, "héllÖ"}, {Position{1, 1}, tokenKey, "héllÖ"},
token{Position{1, 6}, tokenEOF, ""}, {Position{1, 6}, tokenEOF, ""},
}) })
} }
func TestBasicKeyAndEqual(t *testing.T) { func TestBasicKeyAndEqual(t *testing.T) {
testFlow(t, "hello =", []token{ testFlow(t, "hello =", []token{
token{Position{1, 1}, tokenKey, "hello"}, {Position{1, 1}, tokenKey, "hello"},
token{Position{1, 7}, tokenEqual, "="}, {Position{1, 7}, tokenEqual, "="},
token{Position{1, 8}, tokenEOF, ""}, {Position{1, 8}, tokenEOF, ""},
}) })
} }
func TestKeyWithSharpAndEqual(t *testing.T) { func TestKeyWithSharpAndEqual(t *testing.T) {
testFlow(t, "key#name = 5", []token{ testFlow(t, "key#name = 5", []token{
token{Position{1, 1}, tokenError, "keys cannot contain # character"}, {Position{1, 1}, tokenError, "keys cannot contain # character"},
}) })
} }
func TestKeyWithSymbolsAndEqual(t *testing.T) { func TestKeyWithSymbolsAndEqual(t *testing.T) {
testFlow(t, "~!@$^&*()_+-`1234567890[]\\|/?><.,;:' = 5", []token{ testFlow(t, "~!@$^&*()_+-`1234567890[]\\|/?><.,;:' = 5", []token{
token{Position{1, 1}, tokenError, "keys cannot contain ~ character"}, {Position{1, 1}, tokenError, "keys cannot contain ~ character"},
}) })
} }
func TestKeyEqualStringEscape(t *testing.T) { func TestKeyEqualStringEscape(t *testing.T) {
testFlow(t, `foo = "hello\""`, []token{ testFlow(t, `foo = "hello\""`, []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 5}, tokenEqual, "="}, {Position{1, 5}, tokenEqual, "="},
token{Position{1, 8}, tokenString, "hello\""}, {Position{1, 8}, tokenString, "hello\""},
token{Position{1, 16}, tokenEOF, ""}, {Position{1, 16}, tokenEOF, ""},
}) })
} }
func TestKeyEqualStringUnfinished(t *testing.T) { func TestKeyEqualStringUnfinished(t *testing.T) {
testFlow(t, `foo = "bar`, []token{ testFlow(t, `foo = "bar`, []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 5}, tokenEqual, "="}, {Position{1, 5}, tokenEqual, "="},
token{Position{1, 8}, tokenError, "unclosed string"}, {Position{1, 8}, tokenError, "unclosed string"},
}) })
} }
func TestKeyEqualString(t *testing.T) { func TestKeyEqualString(t *testing.T) {
testFlow(t, `foo = "bar"`, []token{ testFlow(t, `foo = "bar"`, []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 5}, tokenEqual, "="}, {Position{1, 5}, tokenEqual, "="},
token{Position{1, 8}, tokenString, "bar"}, {Position{1, 8}, tokenString, "bar"},
token{Position{1, 12}, tokenEOF, ""}, {Position{1, 12}, tokenEOF, ""},
}) })
} }
func TestKeyEqualTrue(t *testing.T) { func TestKeyEqualTrue(t *testing.T) {
testFlow(t, "foo = true", []token{ testFlow(t, "foo = true", []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 5}, tokenEqual, "="}, {Position{1, 5}, tokenEqual, "="},
token{Position{1, 7}, tokenTrue, "true"}, {Position{1, 7}, tokenTrue, "true"},
token{Position{1, 11}, tokenEOF, ""}, {Position{1, 11}, tokenEOF, ""},
}) })
} }
func TestKeyEqualFalse(t *testing.T) { func TestKeyEqualFalse(t *testing.T) {
testFlow(t, "foo = false", []token{ testFlow(t, "foo = false", []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 5}, tokenEqual, "="}, {Position{1, 5}, tokenEqual, "="},
token{Position{1, 7}, tokenFalse, "false"}, {Position{1, 7}, tokenFalse, "false"},
token{Position{1, 12}, tokenEOF, ""}, {Position{1, 12}, tokenEOF, ""},
}) })
} }
func TestArrayNestedString(t *testing.T) { func TestArrayNestedString(t *testing.T) {
testFlow(t, `a = [ ["hello", "world"] ]`, []token{ testFlow(t, `a = [ ["hello", "world"] ]`, []token{
token{Position{1, 1}, tokenKey, "a"}, {Position{1, 1}, tokenKey, "a"},
token{Position{1, 3}, tokenEqual, "="}, {Position{1, 3}, tokenEqual, "="},
token{Position{1, 5}, tokenLeftBracket, "["}, {Position{1, 5}, tokenLeftBracket, "["},
token{Position{1, 7}, tokenLeftBracket, "["}, {Position{1, 7}, tokenLeftBracket, "["},
token{Position{1, 9}, tokenString, "hello"}, {Position{1, 9}, tokenString, "hello"},
token{Position{1, 15}, tokenComma, ","}, {Position{1, 15}, tokenComma, ","},
token{Position{1, 18}, tokenString, "world"}, {Position{1, 18}, tokenString, "world"},
token{Position{1, 24}, tokenRightBracket, "]"}, {Position{1, 24}, tokenRightBracket, "]"},
token{Position{1, 26}, tokenRightBracket, "]"}, {Position{1, 26}, tokenRightBracket, "]"},
token{Position{1, 27}, tokenEOF, ""}, {Position{1, 27}, tokenEOF, ""},
}) })
} }
func TestArrayNestedInts(t *testing.T) { func TestArrayNestedInts(t *testing.T) {
testFlow(t, "a = [ [42, 21], [10] ]", []token{ testFlow(t, "a = [ [42, 21], [10] ]", []token{
token{Position{1, 1}, tokenKey, "a"}, {Position{1, 1}, tokenKey, "a"},
token{Position{1, 3}, tokenEqual, "="}, {Position{1, 3}, tokenEqual, "="},
token{Position{1, 5}, tokenLeftBracket, "["}, {Position{1, 5}, tokenLeftBracket, "["},
token{Position{1, 7}, tokenLeftBracket, "["}, {Position{1, 7}, tokenLeftBracket, "["},
token{Position{1, 8}, tokenInteger, "42"}, {Position{1, 8}, tokenInteger, "42"},
token{Position{1, 10}, tokenComma, ","}, {Position{1, 10}, tokenComma, ","},
token{Position{1, 12}, tokenInteger, "21"}, {Position{1, 12}, tokenInteger, "21"},
token{Position{1, 14}, tokenRightBracket, "]"}, {Position{1, 14}, tokenRightBracket, "]"},
token{Position{1, 15}, tokenComma, ","}, {Position{1, 15}, tokenComma, ","},
token{Position{1, 17}, tokenLeftBracket, "["}, {Position{1, 17}, tokenLeftBracket, "["},
token{Position{1, 18}, tokenInteger, "10"}, {Position{1, 18}, tokenInteger, "10"},
token{Position{1, 20}, tokenRightBracket, "]"}, {Position{1, 20}, tokenRightBracket, "]"},
token{Position{1, 22}, tokenRightBracket, "]"}, {Position{1, 22}, tokenRightBracket, "]"},
token{Position{1, 23}, tokenEOF, ""}, {Position{1, 23}, tokenEOF, ""},
}) })
} }
func TestArrayInts(t *testing.T) { func TestArrayInts(t *testing.T) {
testFlow(t, "a = [ 42, 21, 10, ]", []token{ testFlow(t, "a = [ 42, 21, 10, ]", []token{
token{Position{1, 1}, tokenKey, "a"}, {Position{1, 1}, tokenKey, "a"},
token{Position{1, 3}, tokenEqual, "="}, {Position{1, 3}, tokenEqual, "="},
token{Position{1, 5}, tokenLeftBracket, "["}, {Position{1, 5}, tokenLeftBracket, "["},
token{Position{1, 7}, tokenInteger, "42"}, {Position{1, 7}, tokenInteger, "42"},
token{Position{1, 9}, tokenComma, ","}, {Position{1, 9}, tokenComma, ","},
token{Position{1, 11}, tokenInteger, "21"}, {Position{1, 11}, tokenInteger, "21"},
token{Position{1, 13}, tokenComma, ","}, {Position{1, 13}, tokenComma, ","},
token{Position{1, 15}, tokenInteger, "10"}, {Position{1, 15}, tokenInteger, "10"},
token{Position{1, 17}, tokenComma, ","}, {Position{1, 17}, tokenComma, ","},
token{Position{1, 19}, tokenRightBracket, "]"}, {Position{1, 19}, tokenRightBracket, "]"},
token{Position{1, 20}, tokenEOF, ""}, {Position{1, 20}, tokenEOF, ""},
}) })
} }
func TestMultilineArrayComments(t *testing.T) { func TestMultilineArrayComments(t *testing.T) {
testFlow(t, "a = [1, # wow\n2, # such items\n3, # so array\n]", []token{ testFlow(t, "a = [1, # wow\n2, # such items\n3, # so array\n]", []token{
token{Position{1, 1}, tokenKey, "a"}, {Position{1, 1}, tokenKey, "a"},
token{Position{1, 3}, tokenEqual, "="}, {Position{1, 3}, tokenEqual, "="},
token{Position{1, 5}, tokenLeftBracket, "["}, {Position{1, 5}, tokenLeftBracket, "["},
token{Position{1, 6}, tokenInteger, "1"}, {Position{1, 6}, tokenInteger, "1"},
token{Position{1, 7}, tokenComma, ","}, {Position{1, 7}, tokenComma, ","},
token{Position{2, 1}, tokenInteger, "2"}, {Position{2, 1}, tokenInteger, "2"},
token{Position{2, 2}, tokenComma, ","}, {Position{2, 2}, tokenComma, ","},
token{Position{3, 1}, tokenInteger, "3"}, {Position{3, 1}, tokenInteger, "3"},
token{Position{3, 2}, tokenComma, ","}, {Position{3, 2}, tokenComma, ","},
token{Position{4, 1}, tokenRightBracket, "]"}, {Position{4, 1}, tokenRightBracket, "]"},
token{Position{4, 2}, tokenEOF, ""}, {Position{4, 2}, tokenEOF, ""},
}) })
} }
func TestKeyEqualArrayBools(t *testing.T) { func TestKeyEqualArrayBools(t *testing.T) {
testFlow(t, "foo = [true, false, true]", []token{ testFlow(t, "foo = [true, false, true]", []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 5}, tokenEqual, "="}, {Position{1, 5}, tokenEqual, "="},
token{Position{1, 7}, tokenLeftBracket, "["}, {Position{1, 7}, tokenLeftBracket, "["},
token{Position{1, 8}, tokenTrue, "true"}, {Position{1, 8}, tokenTrue, "true"},
token{Position{1, 12}, tokenComma, ","}, {Position{1, 12}, tokenComma, ","},
token{Position{1, 14}, tokenFalse, "false"}, {Position{1, 14}, tokenFalse, "false"},
token{Position{1, 19}, tokenComma, ","}, {Position{1, 19}, tokenComma, ","},
token{Position{1, 21}, tokenTrue, "true"}, {Position{1, 21}, tokenTrue, "true"},
token{Position{1, 25}, tokenRightBracket, "]"}, {Position{1, 25}, tokenRightBracket, "]"},
token{Position{1, 26}, tokenEOF, ""}, {Position{1, 26}, tokenEOF, ""},
}) })
} }
func TestKeyEqualArrayBoolsWithComments(t *testing.T) { func TestKeyEqualArrayBoolsWithComments(t *testing.T) {
testFlow(t, "foo = [true, false, true] # YEAH", []token{ testFlow(t, "foo = [true, false, true] # YEAH", []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 5}, tokenEqual, "="}, {Position{1, 5}, tokenEqual, "="},
token{Position{1, 7}, tokenLeftBracket, "["}, {Position{1, 7}, tokenLeftBracket, "["},
token{Position{1, 8}, tokenTrue, "true"}, {Position{1, 8}, tokenTrue, "true"},
token{Position{1, 12}, tokenComma, ","}, {Position{1, 12}, tokenComma, ","},
token{Position{1, 14}, tokenFalse, "false"}, {Position{1, 14}, tokenFalse, "false"},
token{Position{1, 19}, tokenComma, ","}, {Position{1, 19}, tokenComma, ","},
token{Position{1, 21}, tokenTrue, "true"}, {Position{1, 21}, tokenTrue, "true"},
token{Position{1, 25}, tokenRightBracket, "]"}, {Position{1, 25}, tokenRightBracket, "]"},
token{Position{1, 33}, tokenEOF, ""}, {Position{1, 33}, tokenEOF, ""},
}) })
} }
@@ -308,401 +308,401 @@ func TestDateRegexp(t *testing.T) {
func TestKeyEqualDate(t *testing.T) { func TestKeyEqualDate(t *testing.T) {
testFlow(t, "foo = 1979-05-27T07:32:00Z", []token{ testFlow(t, "foo = 1979-05-27T07:32:00Z", []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 5}, tokenEqual, "="}, {Position{1, 5}, tokenEqual, "="},
token{Position{1, 7}, tokenDate, "1979-05-27T07:32:00Z"}, {Position{1, 7}, tokenDate, "1979-05-27T07:32:00Z"},
token{Position{1, 27}, tokenEOF, ""}, {Position{1, 27}, tokenEOF, ""},
}) })
testFlow(t, "foo = 1979-05-27T00:32:00-07:00", []token{ testFlow(t, "foo = 1979-05-27T00:32:00-07:00", []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 5}, tokenEqual, "="}, {Position{1, 5}, tokenEqual, "="},
token{Position{1, 7}, tokenDate, "1979-05-27T00:32:00-07:00"}, {Position{1, 7}, tokenDate, "1979-05-27T00:32:00-07:00"},
token{Position{1, 32}, tokenEOF, ""}, {Position{1, 32}, tokenEOF, ""},
}) })
testFlow(t, "foo = 1979-05-27T00:32:00.999999-07:00", []token{ testFlow(t, "foo = 1979-05-27T00:32:00.999999-07:00", []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 5}, tokenEqual, "="}, {Position{1, 5}, tokenEqual, "="},
token{Position{1, 7}, tokenDate, "1979-05-27T00:32:00.999999-07:00"}, {Position{1, 7}, tokenDate, "1979-05-27T00:32:00.999999-07:00"},
token{Position{1, 39}, tokenEOF, ""}, {Position{1, 39}, tokenEOF, ""},
}) })
} }
func TestFloatEndingWithDot(t *testing.T) { func TestFloatEndingWithDot(t *testing.T) {
testFlow(t, "foo = 42.", []token{ testFlow(t, "foo = 42.", []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 5}, tokenEqual, "="}, {Position{1, 5}, tokenEqual, "="},
token{Position{1, 7}, tokenError, "float cannot end with a dot"}, {Position{1, 7}, tokenError, "float cannot end with a dot"},
}) })
} }
func TestFloatWithTwoDots(t *testing.T) { func TestFloatWithTwoDots(t *testing.T) {
testFlow(t, "foo = 4.2.", []token{ testFlow(t, "foo = 4.2.", []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 5}, tokenEqual, "="}, {Position{1, 5}, tokenEqual, "="},
token{Position{1, 7}, tokenError, "cannot have two dots in one float"}, {Position{1, 7}, tokenError, "cannot have two dots in one float"},
}) })
} }
func TestFloatWithExponent1(t *testing.T) { func TestFloatWithExponent1(t *testing.T) {
testFlow(t, "a = 5e+22", []token{ testFlow(t, "a = 5e+22", []token{
token{Position{1, 1}, tokenKey, "a"}, {Position{1, 1}, tokenKey, "a"},
token{Position{1, 3}, tokenEqual, "="}, {Position{1, 3}, tokenEqual, "="},
token{Position{1, 5}, tokenFloat, "5e+22"}, {Position{1, 5}, tokenFloat, "5e+22"},
token{Position{1, 10}, tokenEOF, ""}, {Position{1, 10}, tokenEOF, ""},
}) })
} }
func TestFloatWithExponent2(t *testing.T) { func TestFloatWithExponent2(t *testing.T) {
testFlow(t, "a = 5E+22", []token{ testFlow(t, "a = 5E+22", []token{
token{Position{1, 1}, tokenKey, "a"}, {Position{1, 1}, tokenKey, "a"},
token{Position{1, 3}, tokenEqual, "="}, {Position{1, 3}, tokenEqual, "="},
token{Position{1, 5}, tokenFloat, "5E+22"}, {Position{1, 5}, tokenFloat, "5E+22"},
token{Position{1, 10}, tokenEOF, ""}, {Position{1, 10}, tokenEOF, ""},
}) })
} }
func TestFloatWithExponent3(t *testing.T) { func TestFloatWithExponent3(t *testing.T) {
testFlow(t, "a = -5e+22", []token{ testFlow(t, "a = -5e+22", []token{
token{Position{1, 1}, tokenKey, "a"}, {Position{1, 1}, tokenKey, "a"},
token{Position{1, 3}, tokenEqual, "="}, {Position{1, 3}, tokenEqual, "="},
token{Position{1, 5}, tokenFloat, "-5e+22"}, {Position{1, 5}, tokenFloat, "-5e+22"},
token{Position{1, 11}, tokenEOF, ""}, {Position{1, 11}, tokenEOF, ""},
}) })
} }
func TestFloatWithExponent4(t *testing.T) { func TestFloatWithExponent4(t *testing.T) {
testFlow(t, "a = -5e-22", []token{ testFlow(t, "a = -5e-22", []token{
token{Position{1, 1}, tokenKey, "a"}, {Position{1, 1}, tokenKey, "a"},
token{Position{1, 3}, tokenEqual, "="}, {Position{1, 3}, tokenEqual, "="},
token{Position{1, 5}, tokenFloat, "-5e-22"}, {Position{1, 5}, tokenFloat, "-5e-22"},
token{Position{1, 11}, tokenEOF, ""}, {Position{1, 11}, tokenEOF, ""},
}) })
} }
func TestFloatWithExponent5(t *testing.T) { func TestFloatWithExponent5(t *testing.T) {
testFlow(t, "a = 6.626e-34", []token{ testFlow(t, "a = 6.626e-34", []token{
token{Position{1, 1}, tokenKey, "a"}, {Position{1, 1}, tokenKey, "a"},
token{Position{1, 3}, tokenEqual, "="}, {Position{1, 3}, tokenEqual, "="},
token{Position{1, 5}, tokenFloat, "6.626e-34"}, {Position{1, 5}, tokenFloat, "6.626e-34"},
token{Position{1, 14}, tokenEOF, ""}, {Position{1, 14}, tokenEOF, ""},
}) })
} }
func TestInvalidEsquapeSequence(t *testing.T) { func TestInvalidEsquapeSequence(t *testing.T) {
testFlow(t, `foo = "\x"`, []token{ testFlow(t, `foo = "\x"`, []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 5}, tokenEqual, "="}, {Position{1, 5}, tokenEqual, "="},
token{Position{1, 8}, tokenError, "invalid escape sequence: \\x"}, {Position{1, 8}, tokenError, "invalid escape sequence: \\x"},
}) })
} }
func TestNestedArrays(t *testing.T) { func TestNestedArrays(t *testing.T) {
testFlow(t, "foo = [[[]]]", []token{ testFlow(t, "foo = [[[]]]", []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 5}, tokenEqual, "="}, {Position{1, 5}, tokenEqual, "="},
token{Position{1, 7}, tokenLeftBracket, "["}, {Position{1, 7}, tokenLeftBracket, "["},
token{Position{1, 8}, tokenLeftBracket, "["}, {Position{1, 8}, tokenLeftBracket, "["},
token{Position{1, 9}, tokenLeftBracket, "["}, {Position{1, 9}, tokenLeftBracket, "["},
token{Position{1, 10}, tokenRightBracket, "]"}, {Position{1, 10}, tokenRightBracket, "]"},
token{Position{1, 11}, tokenRightBracket, "]"}, {Position{1, 11}, tokenRightBracket, "]"},
token{Position{1, 12}, tokenRightBracket, "]"}, {Position{1, 12}, tokenRightBracket, "]"},
token{Position{1, 13}, tokenEOF, ""}, {Position{1, 13}, tokenEOF, ""},
}) })
} }
func TestKeyEqualNumber(t *testing.T) { func TestKeyEqualNumber(t *testing.T) {
testFlow(t, "foo = 42", []token{ testFlow(t, "foo = 42", []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 5}, tokenEqual, "="}, {Position{1, 5}, tokenEqual, "="},
token{Position{1, 7}, tokenInteger, "42"}, {Position{1, 7}, tokenInteger, "42"},
token{Position{1, 9}, tokenEOF, ""}, {Position{1, 9}, tokenEOF, ""},
}) })
testFlow(t, "foo = +42", []token{ testFlow(t, "foo = +42", []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 5}, tokenEqual, "="}, {Position{1, 5}, tokenEqual, "="},
token{Position{1, 7}, tokenInteger, "+42"}, {Position{1, 7}, tokenInteger, "+42"},
token{Position{1, 10}, tokenEOF, ""}, {Position{1, 10}, tokenEOF, ""},
}) })
testFlow(t, "foo = -42", []token{ testFlow(t, "foo = -42", []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 5}, tokenEqual, "="}, {Position{1, 5}, tokenEqual, "="},
token{Position{1, 7}, tokenInteger, "-42"}, {Position{1, 7}, tokenInteger, "-42"},
token{Position{1, 10}, tokenEOF, ""}, {Position{1, 10}, tokenEOF, ""},
}) })
testFlow(t, "foo = 4.2", []token{ testFlow(t, "foo = 4.2", []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 5}, tokenEqual, "="}, {Position{1, 5}, tokenEqual, "="},
token{Position{1, 7}, tokenFloat, "4.2"}, {Position{1, 7}, tokenFloat, "4.2"},
token{Position{1, 10}, tokenEOF, ""}, {Position{1, 10}, tokenEOF, ""},
}) })
testFlow(t, "foo = +4.2", []token{ testFlow(t, "foo = +4.2", []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 5}, tokenEqual, "="}, {Position{1, 5}, tokenEqual, "="},
token{Position{1, 7}, tokenFloat, "+4.2"}, {Position{1, 7}, tokenFloat, "+4.2"},
token{Position{1, 11}, tokenEOF, ""}, {Position{1, 11}, tokenEOF, ""},
}) })
testFlow(t, "foo = -4.2", []token{ testFlow(t, "foo = -4.2", []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 5}, tokenEqual, "="}, {Position{1, 5}, tokenEqual, "="},
token{Position{1, 7}, tokenFloat, "-4.2"}, {Position{1, 7}, tokenFloat, "-4.2"},
token{Position{1, 11}, tokenEOF, ""}, {Position{1, 11}, tokenEOF, ""},
}) })
testFlow(t, "foo = 1_000", []token{ testFlow(t, "foo = 1_000", []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 5}, tokenEqual, "="}, {Position{1, 5}, tokenEqual, "="},
token{Position{1, 7}, tokenInteger, "1_000"}, {Position{1, 7}, tokenInteger, "1_000"},
token{Position{1, 12}, tokenEOF, ""}, {Position{1, 12}, tokenEOF, ""},
}) })
testFlow(t, "foo = 5_349_221", []token{ testFlow(t, "foo = 5_349_221", []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 5}, tokenEqual, "="}, {Position{1, 5}, tokenEqual, "="},
token{Position{1, 7}, tokenInteger, "5_349_221"}, {Position{1, 7}, tokenInteger, "5_349_221"},
token{Position{1, 16}, tokenEOF, ""}, {Position{1, 16}, tokenEOF, ""},
}) })
testFlow(t, "foo = 1_2_3_4_5", []token{ testFlow(t, "foo = 1_2_3_4_5", []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 5}, tokenEqual, "="}, {Position{1, 5}, tokenEqual, "="},
token{Position{1, 7}, tokenInteger, "1_2_3_4_5"}, {Position{1, 7}, tokenInteger, "1_2_3_4_5"},
token{Position{1, 16}, tokenEOF, ""}, {Position{1, 16}, tokenEOF, ""},
}) })
testFlow(t, "flt8 = 9_224_617.445_991_228_313", []token{ testFlow(t, "flt8 = 9_224_617.445_991_228_313", []token{
token{Position{1, 1}, tokenKey, "flt8"}, {Position{1, 1}, tokenKey, "flt8"},
token{Position{1, 6}, tokenEqual, "="}, {Position{1, 6}, tokenEqual, "="},
token{Position{1, 8}, tokenFloat, "9_224_617.445_991_228_313"}, {Position{1, 8}, tokenFloat, "9_224_617.445_991_228_313"},
token{Position{1, 33}, tokenEOF, ""}, {Position{1, 33}, tokenEOF, ""},
}) })
testFlow(t, "foo = +", []token{ testFlow(t, "foo = +", []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 5}, tokenEqual, "="}, {Position{1, 5}, tokenEqual, "="},
token{Position{1, 7}, tokenError, "no digit in that number"}, {Position{1, 7}, tokenError, "no digit in that number"},
}) })
} }
func TestMultiline(t *testing.T) { func TestMultiline(t *testing.T) {
testFlow(t, "foo = 42\nbar=21", []token{ testFlow(t, "foo = 42\nbar=21", []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 5}, tokenEqual, "="}, {Position{1, 5}, tokenEqual, "="},
token{Position{1, 7}, tokenInteger, "42"}, {Position{1, 7}, tokenInteger, "42"},
token{Position{2, 1}, tokenKey, "bar"}, {Position{2, 1}, tokenKey, "bar"},
token{Position{2, 4}, tokenEqual, "="}, {Position{2, 4}, tokenEqual, "="},
token{Position{2, 5}, tokenInteger, "21"}, {Position{2, 5}, tokenInteger, "21"},
token{Position{2, 7}, tokenEOF, ""}, {Position{2, 7}, tokenEOF, ""},
}) })
} }
func TestKeyEqualStringUnicodeEscape(t *testing.T) { func TestKeyEqualStringUnicodeEscape(t *testing.T) {
testFlow(t, `foo = "hello \u2665"`, []token{ testFlow(t, `foo = "hello \u2665"`, []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 5}, tokenEqual, "="}, {Position{1, 5}, tokenEqual, "="},
token{Position{1, 8}, tokenString, "hello ♥"}, {Position{1, 8}, tokenString, "hello ♥"},
token{Position{1, 21}, tokenEOF, ""}, {Position{1, 21}, tokenEOF, ""},
}) })
testFlow(t, `foo = "hello \U000003B4"`, []token{ testFlow(t, `foo = "hello \U000003B4"`, []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 5}, tokenEqual, "="}, {Position{1, 5}, tokenEqual, "="},
token{Position{1, 8}, tokenString, "hello δ"}, {Position{1, 8}, tokenString, "hello δ"},
token{Position{1, 25}, tokenEOF, ""}, {Position{1, 25}, tokenEOF, ""},
}) })
testFlow(t, `foo = "\u2"`, []token{ testFlow(t, `foo = "\u2"`, []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 5}, tokenEqual, "="}, {Position{1, 5}, tokenEqual, "="},
token{Position{1, 8}, tokenError, "unfinished unicode escape"}, {Position{1, 8}, tokenError, "unfinished unicode escape"},
}) })
testFlow(t, `foo = "\U2"`, []token{ testFlow(t, `foo = "\U2"`, []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 5}, tokenEqual, "="}, {Position{1, 5}, tokenEqual, "="},
token{Position{1, 8}, tokenError, "unfinished unicode escape"}, {Position{1, 8}, tokenError, "unfinished unicode escape"},
}) })
} }
func TestKeyEqualStringNoEscape(t *testing.T) { func TestKeyEqualStringNoEscape(t *testing.T) {
testFlow(t, "foo = \"hello \u0002\"", []token{ testFlow(t, "foo = \"hello \u0002\"", []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 5}, tokenEqual, "="}, {Position{1, 5}, tokenEqual, "="},
token{Position{1, 8}, tokenError, "unescaped control character U+0002"}, {Position{1, 8}, tokenError, "unescaped control character U+0002"},
}) })
testFlow(t, "foo = \"hello \u001F\"", []token{ testFlow(t, "foo = \"hello \u001F\"", []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 5}, tokenEqual, "="}, {Position{1, 5}, tokenEqual, "="},
token{Position{1, 8}, tokenError, "unescaped control character U+001F"}, {Position{1, 8}, tokenError, "unescaped control character U+001F"},
}) })
} }
func TestLiteralString(t *testing.T) { func TestLiteralString(t *testing.T) {
testFlow(t, `foo = 'C:\Users\nodejs\templates'`, []token{ testFlow(t, `foo = 'C:\Users\nodejs\templates'`, []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 5}, tokenEqual, "="}, {Position{1, 5}, tokenEqual, "="},
token{Position{1, 8}, tokenString, `C:\Users\nodejs\templates`}, {Position{1, 8}, tokenString, `C:\Users\nodejs\templates`},
token{Position{1, 34}, tokenEOF, ""}, {Position{1, 34}, tokenEOF, ""},
}) })
testFlow(t, `foo = '\\ServerX\admin$\system32\'`, []token{ testFlow(t, `foo = '\\ServerX\admin$\system32\'`, []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 5}, tokenEqual, "="}, {Position{1, 5}, tokenEqual, "="},
token{Position{1, 8}, tokenString, `\\ServerX\admin$\system32\`}, {Position{1, 8}, tokenString, `\\ServerX\admin$\system32\`},
token{Position{1, 35}, tokenEOF, ""}, {Position{1, 35}, tokenEOF, ""},
}) })
testFlow(t, `foo = 'Tom "Dubs" Preston-Werner'`, []token{ testFlow(t, `foo = 'Tom "Dubs" Preston-Werner'`, []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 5}, tokenEqual, "="}, {Position{1, 5}, tokenEqual, "="},
token{Position{1, 8}, tokenString, `Tom "Dubs" Preston-Werner`}, {Position{1, 8}, tokenString, `Tom "Dubs" Preston-Werner`},
token{Position{1, 34}, tokenEOF, ""}, {Position{1, 34}, tokenEOF, ""},
}) })
testFlow(t, `foo = '<\i\c*\s*>'`, []token{ testFlow(t, `foo = '<\i\c*\s*>'`, []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 5}, tokenEqual, "="}, {Position{1, 5}, tokenEqual, "="},
token{Position{1, 8}, tokenString, `<\i\c*\s*>`}, {Position{1, 8}, tokenString, `<\i\c*\s*>`},
token{Position{1, 19}, tokenEOF, ""}, {Position{1, 19}, tokenEOF, ""},
}) })
testFlow(t, `foo = 'C:\Users\nodejs\unfinis`, []token{ testFlow(t, `foo = 'C:\Users\nodejs\unfinis`, []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 5}, tokenEqual, "="}, {Position{1, 5}, tokenEqual, "="},
token{Position{1, 8}, tokenError, "unclosed string"}, {Position{1, 8}, tokenError, "unclosed string"},
}) })
} }
func TestMultilineLiteralString(t *testing.T) { func TestMultilineLiteralString(t *testing.T) {
testFlow(t, `foo = '''hello 'literal' world'''`, []token{ testFlow(t, `foo = '''hello 'literal' world'''`, []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 5}, tokenEqual, "="}, {Position{1, 5}, tokenEqual, "="},
token{Position{1, 10}, tokenString, `hello 'literal' world`}, {Position{1, 10}, tokenString, `hello 'literal' world`},
token{Position{1, 34}, tokenEOF, ""}, {Position{1, 34}, tokenEOF, ""},
}) })
testFlow(t, "foo = '''\nhello\n'literal'\nworld'''", []token{ testFlow(t, "foo = '''\nhello\n'literal'\nworld'''", []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 5}, tokenEqual, "="}, {Position{1, 5}, tokenEqual, "="},
token{Position{2, 1}, tokenString, "hello\n'literal'\nworld"}, {Position{2, 1}, tokenString, "hello\n'literal'\nworld"},
token{Position{4, 9}, tokenEOF, ""}, {Position{4, 9}, tokenEOF, ""},
}) })
testFlow(t, "foo = '''\r\nhello\r\n'literal'\r\nworld'''", []token{ testFlow(t, "foo = '''\r\nhello\r\n'literal'\r\nworld'''", []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 5}, tokenEqual, "="}, {Position{1, 5}, tokenEqual, "="},
token{Position{2, 1}, tokenString, "hello\r\n'literal'\r\nworld"}, {Position{2, 1}, tokenString, "hello\r\n'literal'\r\nworld"},
token{Position{4, 9}, tokenEOF, ""}, {Position{4, 9}, tokenEOF, ""},
}) })
} }
func TestMultilineString(t *testing.T) { func TestMultilineString(t *testing.T) {
testFlow(t, `foo = """hello "literal" world"""`, []token{ testFlow(t, `foo = """hello "literal" world"""`, []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 5}, tokenEqual, "="}, {Position{1, 5}, tokenEqual, "="},
token{Position{1, 10}, tokenString, `hello "literal" world`}, {Position{1, 10}, tokenString, `hello "literal" world`},
token{Position{1, 34}, tokenEOF, ""}, {Position{1, 34}, tokenEOF, ""},
}) })
testFlow(t, "foo = \"\"\"\r\nhello\\\r\n\"literal\"\\\nworld\"\"\"", []token{ testFlow(t, "foo = \"\"\"\r\nhello\\\r\n\"literal\"\\\nworld\"\"\"", []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 5}, tokenEqual, "="}, {Position{1, 5}, tokenEqual, "="},
token{Position{2, 1}, tokenString, "hello\"literal\"world"}, {Position{2, 1}, tokenString, "hello\"literal\"world"},
token{Position{4, 9}, tokenEOF, ""}, {Position{4, 9}, tokenEOF, ""},
}) })
testFlow(t, "foo = \"\"\"\\\n \\\n \\\n hello\\\nmultiline\\\nworld\"\"\"", []token{ testFlow(t, "foo = \"\"\"\\\n \\\n \\\n hello\\\nmultiline\\\nworld\"\"\"", []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 5}, tokenEqual, "="}, {Position{1, 5}, tokenEqual, "="},
token{Position{1, 10}, tokenString, "hellomultilineworld"}, {Position{1, 10}, tokenString, "hellomultilineworld"},
token{Position{6, 9}, tokenEOF, ""}, {Position{6, 9}, tokenEOF, ""},
}) })
testFlow(t, "key2 = \"\"\"\nThe quick brown \\\n\n\n fox jumps over \\\n the lazy dog.\"\"\"", []token{ testFlow(t, "key2 = \"\"\"\nThe quick brown \\\n\n\n fox jumps over \\\n the lazy dog.\"\"\"", []token{
token{Position{1, 1}, tokenKey, "key2"}, {Position{1, 1}, tokenKey, "key2"},
token{Position{1, 6}, tokenEqual, "="}, {Position{1, 6}, tokenEqual, "="},
token{Position{2, 1}, tokenString, "The quick brown fox jumps over the lazy dog."}, {Position{2, 1}, tokenString, "The quick brown fox jumps over the lazy dog."},
token{Position{6, 21}, tokenEOF, ""}, {Position{6, 21}, tokenEOF, ""},
}) })
testFlow(t, "key2 = \"\"\"\\\n The quick brown \\\n fox jumps over \\\n the lazy dog.\\\n \"\"\"", []token{ testFlow(t, "key2 = \"\"\"\\\n The quick brown \\\n fox jumps over \\\n the lazy dog.\\\n \"\"\"", []token{
token{Position{1, 1}, tokenKey, "key2"}, {Position{1, 1}, tokenKey, "key2"},
token{Position{1, 6}, tokenEqual, "="}, {Position{1, 6}, tokenEqual, "="},
token{Position{1, 11}, tokenString, "The quick brown fox jumps over the lazy dog."}, {Position{1, 11}, tokenString, "The quick brown fox jumps over the lazy dog."},
token{Position{5, 11}, tokenEOF, ""}, {Position{5, 11}, tokenEOF, ""},
}) })
testFlow(t, `key2 = "Roses are red\nViolets are blue"`, []token{ testFlow(t, `key2 = "Roses are red\nViolets are blue"`, []token{
token{Position{1, 1}, tokenKey, "key2"}, {Position{1, 1}, tokenKey, "key2"},
token{Position{1, 6}, tokenEqual, "="}, {Position{1, 6}, tokenEqual, "="},
token{Position{1, 9}, tokenString, "Roses are red\nViolets are blue"}, {Position{1, 9}, tokenString, "Roses are red\nViolets are blue"},
token{Position{1, 41}, tokenEOF, ""}, {Position{1, 41}, tokenEOF, ""},
}) })
testFlow(t, "key2 = \"\"\"\nRoses are red\nViolets are blue\"\"\"", []token{ testFlow(t, "key2 = \"\"\"\nRoses are red\nViolets are blue\"\"\"", []token{
token{Position{1, 1}, tokenKey, "key2"}, {Position{1, 1}, tokenKey, "key2"},
token{Position{1, 6}, tokenEqual, "="}, {Position{1, 6}, tokenEqual, "="},
token{Position{2, 1}, tokenString, "Roses are red\nViolets are blue"}, {Position{2, 1}, tokenString, "Roses are red\nViolets are blue"},
token{Position{3, 20}, tokenEOF, ""}, {Position{3, 20}, tokenEOF, ""},
}) })
} }
func TestUnicodeString(t *testing.T) { func TestUnicodeString(t *testing.T) {
testFlow(t, `foo = "hello ♥ world"`, []token{ testFlow(t, `foo = "hello ♥ world"`, []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 5}, tokenEqual, "="}, {Position{1, 5}, tokenEqual, "="},
token{Position{1, 8}, tokenString, "hello ♥ world"}, {Position{1, 8}, tokenString, "hello ♥ world"},
token{Position{1, 22}, tokenEOF, ""}, {Position{1, 22}, tokenEOF, ""},
}) })
} }
func TestEscapeInString(t *testing.T) { func TestEscapeInString(t *testing.T) {
testFlow(t, `foo = "\b\f\/"`, []token{ testFlow(t, `foo = "\b\f\/"`, []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 5}, tokenEqual, "="}, {Position{1, 5}, tokenEqual, "="},
token{Position{1, 8}, tokenString, "\b\f/"}, {Position{1, 8}, tokenString, "\b\f/"},
token{Position{1, 15}, tokenEOF, ""}, {Position{1, 15}, tokenEOF, ""},
}) })
} }
func TestKeyGroupArray(t *testing.T) { func TestKeyGroupArray(t *testing.T) {
testFlow(t, "[[foo]]", []token{ testFlow(t, "[[foo]]", []token{
token{Position{1, 1}, tokenDoubleLeftBracket, "[["}, {Position{1, 1}, tokenDoubleLeftBracket, "[["},
token{Position{1, 3}, tokenKeyGroupArray, "foo"}, {Position{1, 3}, tokenKeyGroupArray, "foo"},
token{Position{1, 6}, tokenDoubleRightBracket, "]]"}, {Position{1, 6}, tokenDoubleRightBracket, "]]"},
token{Position{1, 8}, tokenEOF, ""}, {Position{1, 8}, tokenEOF, ""},
}) })
} }
func TestQuotedKey(t *testing.T) { func TestQuotedKey(t *testing.T) {
testFlow(t, "\"a b\" = 42", []token{ testFlow(t, "\"a b\" = 42", []token{
token{Position{1, 1}, tokenKey, "\"a b\""}, {Position{1, 1}, tokenKey, "\"a b\""},
token{Position{1, 7}, tokenEqual, "="}, {Position{1, 7}, tokenEqual, "="},
token{Position{1, 9}, tokenInteger, "42"}, {Position{1, 9}, tokenInteger, "42"},
token{Position{1, 11}, tokenEOF, ""}, {Position{1, 11}, tokenEOF, ""},
}) })
} }
func TestKeyNewline(t *testing.T) { func TestKeyNewline(t *testing.T) {
testFlow(t, "a\n= 4", []token{ testFlow(t, "a\n= 4", []token{
token{Position{1, 1}, tokenError, "keys cannot contain new lines"}, {Position{1, 1}, tokenError, "keys cannot contain new lines"},
}) })
} }
func TestInvalidFloat(t *testing.T) { func TestInvalidFloat(t *testing.T) {
testFlow(t, "a=7e1_", []token{ testFlow(t, "a=7e1_", []token{
token{Position{1, 1}, tokenKey, "a"}, {Position{1, 1}, tokenKey, "a"},
token{Position{1, 2}, tokenEqual, "="}, {Position{1, 2}, tokenEqual, "="},
token{Position{1, 3}, tokenFloat, "7e1_"}, {Position{1, 3}, tokenFloat, "7e1_"},
token{Position{1, 7}, tokenEOF, ""}, {Position{1, 7}, tokenEOF, ""},
}) })
} }
func TestLexUnknownRvalue(t *testing.T) { func TestLexUnknownRvalue(t *testing.T) {
testFlow(t, `a = !b`, []token{ testFlow(t, `a = !b`, []token{
token{Position{1, 1}, tokenKey, "a"}, {Position{1, 1}, tokenKey, "a"},
token{Position{1, 3}, tokenEqual, "="}, {Position{1, 3}, tokenEqual, "="},
token{Position{1, 5}, tokenError, "no value can start with !"}, {Position{1, 5}, tokenError, "no value can start with !"},
}) })
testFlow(t, `a = \b`, []token{ testFlow(t, `a = \b`, []token{
token{Position{1, 1}, tokenKey, "a"}, {Position{1, 1}, tokenKey, "a"},
token{Position{1, 3}, tokenEqual, "="}, {Position{1, 3}, tokenEqual, "="},
token{Position{1, 5}, tokenError, `no value can start with \`}, {Position{1, 5}, tokenError, `no value can start with \`},
}) })
} }
parser_test.go
+21 -21
View File
@@ -269,14 +269,14 @@ func TestArrayMultiline(t *testing.T) {
func TestArrayNested(t *testing.T) { func TestArrayNested(t *testing.T) {
tree, err := Load("a = [[42, 21], [10]]") tree, err := Load("a = [[42, 21], [10]]")
assertTree(t, tree, err, map[string]interface{}{ assertTree(t, tree, err, map[string]interface{}{
"a": [][]int64{[]int64{int64(42), int64(21)}, []int64{int64(10)}}, "a": [][]int64{{int64(42), int64(21)}, {int64(10)}},
}) })
} }
func TestNestedEmptyArrays(t *testing.T) { func TestNestedEmptyArrays(t *testing.T) {
tree, err := Load("a = [[[]]]") tree, err := Load("a = [[[]]]")
assertTree(t, tree, err, map[string]interface{}{ assertTree(t, tree, err, map[string]interface{}{
"a": [][][]interface{}{[][]interface{}{[]interface{}{}}}, "a": [][][]interface{}{{{}}},
}) })
} }
@@ -295,7 +295,7 @@ func TestArrayMixedTypes(t *testing.T) {
func TestArrayNestedStrings(t *testing.T) { func TestArrayNestedStrings(t *testing.T) {
tree, err := Load("data = [ [\"gamma\", \"delta\"], [\"Foo\"] ]") tree, err := Load("data = [ [\"gamma\", \"delta\"], [\"Foo\"] ]")
assertTree(t, tree, err, map[string]interface{}{ assertTree(t, tree, err, map[string]interface{}{
"data": [][]string{[]string{"gamma", "delta"}, []string{"Foo"}}, "data": [][]string{{"gamma", "delta"}, {"Foo"}},
}) })
} }
@@ -394,7 +394,7 @@ func TestExampleInlineGroupInArray(t *testing.T) {
tree, err := Load(`points = [{ x = 1, y = 2 }]`) tree, err := Load(`points = [{ x = 1, y = 2 }]`)
assertTree(t, tree, err, map[string]interface{}{ assertTree(t, tree, err, map[string]interface{}{
"points": []map[string]interface{}{ "points": []map[string]interface{}{
map[string]interface{}{ {
"x": int64(1), "x": int64(1),
"y": int64(2), "y": int64(2),
}, },
@@ -668,10 +668,10 @@ func TestDocumentPositions(t *testing.T) {
assertPosition(t, assertPosition(t,
"[foo]\nbar=42\nbaz=69", "[foo]\nbar=42\nbaz=69",
map[string]Position{ map[string]Position{
"": Position{1, 1}, "": {1, 1},
"foo": Position{1, 1}, "foo": {1, 1},
"foo.bar": Position{2, 1}, "foo.bar": {2, 1},
"foo.baz": Position{3, 1}, "foo.baz": {3, 1},
}) })
} }
@@ -679,10 +679,10 @@ func TestDocumentPositionsWithSpaces(t *testing.T) {
assertPosition(t, assertPosition(t,
" [foo]\n bar=42\n baz=69", " [foo]\n bar=42\n baz=69",
map[string]Position{ map[string]Position{
"": Position{1, 1}, "": {1, 1},
"foo": Position{1, 3}, "foo": {1, 3},
"foo.bar": Position{2, 3}, "foo.bar": {2, 3},
"foo.baz": Position{3, 3}, "foo.baz": {3, 3},
}) })
} }
@@ -690,10 +690,10 @@ func TestDocumentPositionsWithGroupArray(t *testing.T) {
assertPosition(t, assertPosition(t,
"[[foo]]\nbar=42\nbaz=69", "[[foo]]\nbar=42\nbaz=69",
map[string]Position{ map[string]Position{
"": Position{1, 1}, "": {1, 1},
"foo": Position{1, 1}, "foo": {1, 1},
"foo.bar": Position{2, 1}, "foo.bar": {2, 1},
"foo.baz": Position{3, 1}, "foo.baz": {3, 1},
}) })
} }
@@ -701,11 +701,11 @@ func TestNestedTreePosition(t *testing.T) {
assertPosition(t, assertPosition(t,
"[foo.bar]\na=42\nb=69", "[foo.bar]\na=42\nb=69",
map[string]Position{ map[string]Position{
"": Position{1, 1}, "": {1, 1},
"foo": Position{1, 1}, "foo": {1, 1},
"foo.bar": Position{1, 1}, "foo.bar": {1, 1},
"foo.bar.a": Position{2, 1}, "foo.bar.a": {2, 1},
"foo.bar.b": Position{3, 1}, "foo.bar.b": {3, 1},
}) })
} }
position_test.go
+3 -3
View File
@@ -18,9 +18,9 @@ func TestPositionString(t *testing.T) {
func TestInvalid(t *testing.T) { func TestInvalid(t *testing.T) {
for i, v := range []Position{ for i, v := range []Position{
Position{0, 1234}, {0, 1234},
Position{1234, 0}, {1234, 0},
Position{0, 0}, {0, 0},
} { } {
if !v.Invalid() { if !v.Invalid() {
t.Errorf("Position at %v is valid: %v", i, v) t.Errorf("Position at %v is valid: %v", i, v)
querylexer_test.go
+48 -48
View File
@@ -36,143 +36,143 @@ func testQLFlow(t *testing.T, input string, expectedFlow []token) {
func TestLexSpecialChars(t *testing.T) { func TestLexSpecialChars(t *testing.T) {
testQLFlow(t, " .$[]..()?*", []token{ testQLFlow(t, " .$[]..()?*", []token{
token{Position{1, 2}, tokenDot, "."}, {Position{1, 2}, tokenDot, "."},
token{Position{1, 3}, tokenDollar, "$"}, {Position{1, 3}, tokenDollar, "$"},
token{Position{1, 4}, tokenLeftBracket, "["}, {Position{1, 4}, tokenLeftBracket, "["},
token{Position{1, 5}, tokenRightBracket, "]"}, {Position{1, 5}, tokenRightBracket, "]"},
token{Position{1, 6}, tokenDotDot, ".."}, {Position{1, 6}, tokenDotDot, ".."},
token{Position{1, 8}, tokenLeftParen, "("}, {Position{1, 8}, tokenLeftParen, "("},
token{Position{1, 9}, tokenRightParen, ")"}, {Position{1, 9}, tokenRightParen, ")"},
token{Position{1, 10}, tokenQuestion, "?"}, {Position{1, 10}, tokenQuestion, "?"},
token{Position{1, 11}, tokenStar, "*"}, {Position{1, 11}, tokenStar, "*"},
token{Position{1, 12}, tokenEOF, ""}, {Position{1, 12}, tokenEOF, ""},
}) })
} }
func TestLexString(t *testing.T) { func TestLexString(t *testing.T) {
testQLFlow(t, "'foo\n'", []token{ testQLFlow(t, "'foo\n'", []token{
token{Position{1, 2}, tokenString, "foo\n"}, {Position{1, 2}, tokenString, "foo\n"},
token{Position{2, 2}, tokenEOF, ""}, {Position{2, 2}, tokenEOF, ""},
}) })
} }
func TestLexDoubleString(t *testing.T) { func TestLexDoubleString(t *testing.T) {
testQLFlow(t, `"bar"`, []token{ testQLFlow(t, `"bar"`, []token{
token{Position{1, 2}, tokenString, "bar"}, {Position{1, 2}, tokenString, "bar"},
token{Position{1, 6}, tokenEOF, ""}, {Position{1, 6}, tokenEOF, ""},
}) })
} }
func TestLexStringEscapes(t *testing.T) { func TestLexStringEscapes(t *testing.T) {
testQLFlow(t, `"foo \" \' \b \f \/ \t \r \\ \u03A9 \U00012345 \n bar"`, []token{ testQLFlow(t, `"foo \" \' \b \f \/ \t \r \\ \u03A9 \U00012345 \n bar"`, []token{
token{Position{1, 2}, tokenString, "foo \" ' \b \f / \t \r \\ \u03A9 \U00012345 \n bar"}, {Position{1, 2}, tokenString, "foo \" ' \b \f / \t \r \\ \u03A9 \U00012345 \n bar"},
token{Position{1, 55}, tokenEOF, ""}, {Position{1, 55}, tokenEOF, ""},
}) })
} }
func TestLexStringUnfinishedUnicode4(t *testing.T) { func TestLexStringUnfinishedUnicode4(t *testing.T) {
testQLFlow(t, `"\u000"`, []token{ testQLFlow(t, `"\u000"`, []token{
token{Position{1, 2}, tokenError, "unfinished unicode escape"}, {Position{1, 2}, tokenError, "unfinished unicode escape"},
}) })
} }
func TestLexStringUnfinishedUnicode8(t *testing.T) { func TestLexStringUnfinishedUnicode8(t *testing.T) {
testQLFlow(t, `"\U0000"`, []token{ testQLFlow(t, `"\U0000"`, []token{
token{Position{1, 2}, tokenError, "unfinished unicode escape"}, {Position{1, 2}, tokenError, "unfinished unicode escape"},
}) })
} }
func TestLexStringInvalidEscape(t *testing.T) { func TestLexStringInvalidEscape(t *testing.T) {
testQLFlow(t, `"\x"`, []token{ testQLFlow(t, `"\x"`, []token{
token{Position{1, 2}, tokenError, "invalid escape sequence: \\x"}, {Position{1, 2}, tokenError, "invalid escape sequence: \\x"},
}) })
} }
func TestLexStringUnfinished(t *testing.T) { func TestLexStringUnfinished(t *testing.T) {
testQLFlow(t, `"bar`, []token{ testQLFlow(t, `"bar`, []token{
token{Position{1, 2}, tokenError, "unclosed string"}, {Position{1, 2}, tokenError, "unclosed string"},
}) })
} }
func TestLexKey(t *testing.T) { func TestLexKey(t *testing.T) {
testQLFlow(t, "foo", []token{ testQLFlow(t, "foo", []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 4}, tokenEOF, ""}, {Position{1, 4}, tokenEOF, ""},
}) })
} }
func TestLexRecurse(t *testing.T) { func TestLexRecurse(t *testing.T) {
testQLFlow(t, "$..*", []token{ testQLFlow(t, "$..*", []token{
token{Position{1, 1}, tokenDollar, "$"}, {Position{1, 1}, tokenDollar, "$"},
token{Position{1, 2}, tokenDotDot, ".."}, {Position{1, 2}, tokenDotDot, ".."},
token{Position{1, 4}, tokenStar, "*"}, {Position{1, 4}, tokenStar, "*"},
token{Position{1, 5}, tokenEOF, ""}, {Position{1, 5}, tokenEOF, ""},
}) })
} }
func TestLexBracketKey(t *testing.T) { func TestLexBracketKey(t *testing.T) {
testQLFlow(t, "$[foo]", []token{ testQLFlow(t, "$[foo]", []token{
token{Position{1, 1}, tokenDollar, "$"}, {Position{1, 1}, tokenDollar, "$"},
token{Position{1, 2}, tokenLeftBracket, "["}, {Position{1, 2}, tokenLeftBracket, "["},
token{Position{1, 3}, tokenKey, "foo"}, {Position{1, 3}, tokenKey, "foo"},
token{Position{1, 6}, tokenRightBracket, "]"}, {Position{1, 6}, tokenRightBracket, "]"},
token{Position{1, 7}, tokenEOF, ""}, {Position{1, 7}, tokenEOF, ""},
}) })
} }
func TestLexSpace(t *testing.T) { func TestLexSpace(t *testing.T) {
testQLFlow(t, "foo bar baz", []token{ testQLFlow(t, "foo bar baz", []token{
token{Position{1, 1}, tokenKey, "foo"}, {Position{1, 1}, tokenKey, "foo"},
token{Position{1, 5}, tokenKey, "bar"}, {Position{1, 5}, tokenKey, "bar"},
token{Position{1, 9}, tokenKey, "baz"}, {Position{1, 9}, tokenKey, "baz"},
token{Position{1, 12}, tokenEOF, ""}, {Position{1, 12}, tokenEOF, ""},
}) })
} }
func TestLexInteger(t *testing.T) { func TestLexInteger(t *testing.T) {
testQLFlow(t, "100 +200 -300", []token{ testQLFlow(t, "100 +200 -300", []token{
token{Position{1, 1}, tokenInteger, "100"}, {Position{1, 1}, tokenInteger, "100"},
token{Position{1, 5}, tokenInteger, "+200"}, {Position{1, 5}, tokenInteger, "+200"},
token{Position{1, 10}, tokenInteger, "-300"}, {Position{1, 10}, tokenInteger, "-300"},
token{Position{1, 14}, tokenEOF, ""}, {Position{1, 14}, tokenEOF, ""},
}) })
} }
func TestLexFloat(t *testing.T) { func TestLexFloat(t *testing.T) {
testQLFlow(t, "100.0 +200.0 -300.0", []token{ testQLFlow(t, "100.0 +200.0 -300.0", []token{
token{Position{1, 1}, tokenFloat, "100.0"}, {Position{1, 1}, tokenFloat, "100.0"},
token{Position{1, 7}, tokenFloat, "+200.0"}, {Position{1, 7}, tokenFloat, "+200.0"},
token{Position{1, 14}, tokenFloat, "-300.0"}, {Position{1, 14}, tokenFloat, "-300.0"},
token{Position{1, 20}, tokenEOF, ""}, {Position{1, 20}, tokenEOF, ""},
}) })
} }
func TestLexFloatWithMultipleDots(t *testing.T) { func TestLexFloatWithMultipleDots(t *testing.T) {
testQLFlow(t, "4.2.", []token{ testQLFlow(t, "4.2.", []token{
token{Position{1, 1}, tokenError, "cannot have two dots in one float"}, {Position{1, 1}, tokenError, "cannot have two dots in one float"},
}) })
} }
func TestLexFloatLeadingDot(t *testing.T) { func TestLexFloatLeadingDot(t *testing.T) {
testQLFlow(t, "+.1", []token{ testQLFlow(t, "+.1", []token{
token{Position{1, 1}, tokenError, "cannot start float with a dot"}, {Position{1, 1}, tokenError, "cannot start float with a dot"},
}) })
} }
func TestLexFloatWithTrailingDot(t *testing.T) { func TestLexFloatWithTrailingDot(t *testing.T) {
testQLFlow(t, "42.", []token{ testQLFlow(t, "42.", []token{
token{Position{1, 1}, tokenError, "float cannot end with a dot"}, {Position{1, 1}, tokenError, "float cannot end with a dot"},
}) })
} }
func TestLexNumberWithoutDigit(t *testing.T) { func TestLexNumberWithoutDigit(t *testing.T) {
testQLFlow(t, "+", []token{ testQLFlow(t, "+", []token{
token{Position{1, 1}, tokenError, "no digit in that number"}, {Position{1, 1}, tokenError, "no digit in that number"},
}) })
} }
func TestLexUnknown(t *testing.T) { func TestLexUnknown(t *testing.T) {
testQLFlow(t, "^", []token{ testQLFlow(t, "^", []token{
token{Position{1, 1}, tokenError, "unexpected char: '94'"}, {Position{1, 1}, tokenError, "unexpected char: '94'"},
}) })
} }